diff --git a/.github/workflows/TagBot.yml b/.github/workflows/TagBot.yml
index ad381d1f..6f39f1db 100644
--- a/.github/workflows/TagBot.yml
+++ b/.github/workflows/TagBot.yml
@@ -25,9 +25,16 @@ jobs:
   TagBot:
     if: github.event_name == 'workflow_dispatch' || github.actor == 'JuliaTagBot'
     runs-on: ubuntu-latest
-    timeout-minutes: 5
+    timeout-minutes: 15
     steps:
-      - uses: JuliaRegistries/TagBot@v1
+      - name: Tag Arrow.jl
+        uses: JuliaRegistries/TagBot@v1
         with:
           token: ${{ secrets.GITHUB_TOKEN }}
           ssh: ${{ secrets.DOCUMENTER_KEY }}
+      - name: Tag ArrowTypes.jl
+        uses: JuliaRegistries/TagBot@v1
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          ssh: ${{ secrets.DOCUMENTER_KEY }}
+          subdir: src/ArrowTypes
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0a1e9530..ad0144b3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -39,7 +39,7 @@ jobs:
   release:
     name: Verify release - ${{ matrix.os }}
     runs-on: ${{ matrix.os }}
-    timeout-minutes: 30
+    timeout-minutes: 45
     strategy:
       fail-fast: false
       matrix:
@@ -57,38 +57,52 @@ jobs:
         run: |
           sudo apt update
           sudo apt install -y -V subversion
+      # Without an installed Julia, verify_rc.sh asks api.github.com for the
+      # latest release without a token, which a rate-limited runner refuses.
+      - uses: julia-actions/setup-julia@v3
+        if: matrix.os == 'ubuntu-latest'
+        with:
+          version: '1'
       - name: Create
         run: |
           git config user.name "github-actions[bot]"
           git config user.email "github-actions[bot]@users.noreply.github.com"
-          RELEASE_DEFAULT=0 dev/release/release_rc.sh 100
+          RELEASE_DEFAULT=0 dev/release/release_rc.sh 100 > release-rc-output.txt
+          cat release-rc-output.txt
+          grep -F "The vote will be open for at least 72 hours." release-rc-output.txt
       - uses: actions/cache@v6
         with:
           path: ~/.julia/artifacts
           key: ${{ runner.os }}-release-${{ hashFiles('**/Project.toml') }}
           restore-keys: |
             ${{ runner.os }}-release-
+      # The release candidate's suite, with one generated property case in four
+      # (the test job runs them all).
       - name: Verify
+        env:
+          ARROW_PROPERTY_CASES: 3/4
         run: |
           version=$(grep -o '^version = ".*"' "Project.toml" | \
                       sed -e 's/^version = "//g' \
                           -e 's/"$//g')
           VERIFY_DEFAULT=0 dev/release/verify_rc.sh ${version} 100
   test:
-    name: ${{ matrix.pkg.name }} - Julia ${{ matrix.version }} - ${{ matrix.runner || matrix.os }} - ${{ matrix.nthreads }} threads - ${{ github.event_name }}
+    # Coverage makes Julia compile the package, and each child process the tests
+    # start, without its precompiled code, so it runs on one job: ubuntu, Julia 1,
+    # 2 threads. That job also runs every generated property case; the others run
+    # one in four, chosen by their matrix position (ARROW_PROPERTY_CASES).
+    name: Arrow.jl - Julia ${{ matrix.version }} - ${{ matrix.runner || matrix.os }} - ${{ matrix.nthreads }} threads - ${{ github.event_name }}
     runs-on: ${{ matrix.runner || matrix.os }}
     timeout-minutes: 45
+    permissions:
+      contents: read
+      id-token: write
     strategy:
       fail-fast: false
       matrix:
-        pkg:
-          - name: Arrow.jl
-            dir: '.'
-          - name: ArrowTypes.jl
-            dir: './src/ArrowTypes'
         version:
           - 'min'
-          - 'lts'
+          - '1.11'
           - '1' # automatically expands to the latest stable 1.x release of Julia
           - 'pre' # expands to latest alpha, beta or RC, if available, otherwise same as `1`
         os:
@@ -98,7 +112,7 @@ jobs:
           - 1
           - 2
         include:
-          # Julia 1.9's libopenlibm requires executable-stack support rejected by newer glibc.
+          # Older Julia binaries need executable-stack support from this runner.
           - version: 'min'
             os: ubuntu-latest
             runner: ubuntu-24.04
@@ -107,6 +121,7 @@ jobs:
       - uses: julia-actions/setup-julia@v3
         with:
           version: ${{ matrix.version }}
+          project: '.'
       - uses: actions/cache@v6
         env:
           cache-name: cache-artifacts
@@ -117,24 +132,75 @@ jobs:
             ${{ runner.os }}-test-${{ env.cache-name }}-
             ${{ runner.os }}-test-
             ${{ runner.os }}-
-      - uses: julia-actions/julia-buildpkg@v1.6
-        with:
-          project: ${{ matrix.pkg.dir }}
-      - name: Dev local ArrowTypes for Arrow.jl tests
-        if: matrix.pkg.name == 'Arrow.jl'
+      # Julia 1.10 needs the local ArrowTypes source developed explicitly.
+      - name: Dev local subpackages
         shell: julia --project=. {0}
         run: |
           using Pkg
-          Pkg.develop(PackageSpec(path="src/ArrowTypes"))
+          Pkg.develop([PackageSpec(path="src/ArrowTypes")])
+      - uses: julia-actions/julia-buildpkg@v1.6
       - uses: julia-actions/julia-runtest@v1
+        with:
+          coverage: ${{ matrix.os == 'ubuntu-latest' && matrix.version == '1' && matrix.nthreads == 2 }}
         env:
           JULIA_NUM_THREADS: ${{ matrix.nthreads }}
+          ARROW_PROPERTY_CASES: ${{ (matrix.os == 'ubuntu-latest' && matrix.version == '1' && matrix.nthreads == 2) && 'all' || format('{0}/4', strategy.job-index) }}
+      - uses: julia-actions/julia-processcoverage@v1
+        if: matrix.os == 'ubuntu-latest' && matrix.version == '1' && matrix.nthreads == 2
+        with:
+          directories: src,ext
+      - uses: codecov/codecov-action@v7
+        if: matrix.os == 'ubuntu-latest' && matrix.version == '1' && matrix.nthreads == 2
+        with:
+          files: lcov.info
+          fail_ci_if_error: true
+          use_oidc: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }}
+  # The subpackages' own suites: one job each, on the package's minimum
+  # supported Julia. The full Arrow.jl matrix above exercises both packages'
+  # code on every version, OS, and thread count.
+  test-subpackages:
+    name: ${{ matrix.pkg.name }} - Julia min - ${{ github.event_name }}
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    permissions:
+      contents: read
+      id-token: write
+    strategy:
+      fail-fast: false
+      matrix:
+        pkg:
+          - name: ArrowTypes.jl
+            dir: './src/ArrowTypes'
+    steps:
+      - uses: actions/checkout@v7
+      - uses: julia-actions/setup-julia@v3
+        with:
+          version: 'min'
+          project: ${{ matrix.pkg.dir }}
+      - uses: actions/cache@v6
+        env:
+          cache-name: cache-artifacts
+        with:
+          path: ~/.julia/artifacts
+          key: ${{ runner.os }}-test-${{ env.cache-name }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: |
+            ${{ runner.os }}-test-${{ env.cache-name }}-
+            ${{ runner.os }}-test-
+            ${{ runner.os }}-
+      - uses: julia-actions/julia-buildpkg@v1.6
+        with:
+          project: ${{ matrix.pkg.dir }}
+      - uses: julia-actions/julia-runtest@v1
         with:
           project: ${{ matrix.pkg.dir }}
       - uses: julia-actions/julia-processcoverage@v1
+        with:
+          directories: ${{ matrix.pkg.dir }}/src
       - uses: codecov/codecov-action@v7
         with:
           files: lcov.info
+          fail_ci_if_error: true
+          use_oidc: ${{ github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository }}
   test_monorepo:
     name: Monorepo dev - Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
     runs-on: ${{ matrix.os }}
@@ -171,19 +237,105 @@ jobs:
           Pkg.develop([PackageSpec(path="."), PackageSpec(path="src/ArrowTypes")])
       - name: Run monorepo tests
         continue-on-error: false
+        env:
+          ARROW_PROPERTY_CASES: 2/4
         run: >
           julia --color=yes --project=monorepo -e 'using Pkg; Pkg.test("Arrow")'
+  test_min_arrowtypes:
+    name: Arrow.jl - ArrowTypes 2.0 compatibility
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v7
+      - uses: julia-actions/setup-julia@v3
+        with:
+          version: '1.10'
+          project: '.'
+      - uses: actions/cache@v6
+        with:
+          path: ~/.julia/artifacts
+          key: min-arrowtypes-${{ runner.os }}-${{ hashFiles('Project.toml') }}
+          restore-keys: min-arrowtypes-${{ runner.os }}-
+      - name: Resolve the minimum supported ArrowTypes version
+        shell: julia --project=. {0}
+        run: |
+          using Pkg
+          Pkg.add(PackageSpec(name="ArrowTypes", version=v"2.0.0"))
+          Pkg.pin(PackageSpec(name="ArrowTypes"))
+      - name: Test custom-type file and stream round trips
+        run: julia --startup-file=no --history-file=no --project=. test/min_arrowtypes_compat.jl
+  test_windows:
+    name: ${{ matrix.pkg.name }} - Julia latest - Windows - 2 threads
+    runs-on: windows-latest
+    timeout-minutes: 45
+    strategy:
+      fail-fast: false
+      matrix:
+        pkg:
+          - name: Arrow.jl
+            dir: '.'
+          - name: ArrowTypes.jl
+            dir: './src/ArrowTypes'
+    steps:
+      - uses: actions/checkout@v7
+      - uses: julia-actions/setup-julia@v3
+        with:
+          version: '1'
+          project: ${{ matrix.pkg.dir }}
+      - uses: actions/cache@v6
+        with:
+          path: ~/.julia/artifacts
+          key: windows-test-${{ hashFiles('**/Project.toml') }}
+          restore-keys: windows-test-
+      - name: Prepare Arrow.jl development dependencies
+        if: matrix.pkg.name == 'Arrow.jl'
+        shell: julia --project=. {0}
+        run: |
+          using Pkg
+          Pkg.develop([PackageSpec(path="src/ArrowTypes")])
+      - uses: julia-actions/julia-buildpkg@v1.6
+        with:
+          project: ${{ matrix.pkg.dir }}
+      # Nothing uploads this job's coverage, so it runs without it.
+      - uses: julia-actions/julia-runtest@v1
+        env:
+          JULIA_NUM_THREADS: 2
+          ARROW_PROPERTY_CASES: 1/4
+        with:
+          project: ${{ matrix.pkg.dir }}
+          coverage: false
+  trim:
+    name: ArrowCore and DataStrings JuliaC trim-safe compile
+    runs-on: ubuntu-latest
+    timeout-minutes: 15
+    steps:
+      - uses: actions/checkout@v7
+      - uses: julia-actions/setup-julia@v3
+        with:
+          version: '1.12.6'
+      - uses: actions/cache@v6
+        with:
+          path: ~/.julia/artifacts
+          key: trim-${{ runner.os }}-${{ hashFiles('test/trim/Project.toml') }}
+          restore-keys: trim-${{ runner.os }}-
+      - name: Compile and run the trim-safe ArrowCore and DataStrings workload
+        run: julia --startup-file=no --history-file=no test/trim_compile_tests.jl
   docs:
     name: Documentation
     runs-on: ubuntu-latest
-    timeout-minutes: 5
+    timeout-minutes: 15
     steps:
       - uses: actions/checkout@v7
       - uses: julia-actions/setup-julia@v3
         with:
           version: '1'
-      - uses: julia-actions/julia-buildpkg@latest
-      - uses: julia-actions/julia-docdeploy@latest
+      - name: Prepare Arrow.jl development dependencies for the docs
+        shell: julia --project=docs {0}
+        run: |
+          using Pkg
+          Pkg.develop([PackageSpec(path="."), PackageSpec(path="src/ArrowTypes")])
+      - uses: julia-actions/julia-buildpkg@v1.7.0
+      - uses: julia-actions/julia-docdeploy@v1.3.1
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           DOCUMENTER_KEY: ${{ secrets.DOCUMENTER_KEY }}
@@ -194,11 +346,9 @@ jobs:
       - uses: julia-actions/setup-julia@v3
       - uses: actions/checkout@v7
       - name: Install JuliaFormatter and format
-        # This will use the latest version by default but you can set the version like so:
-        # julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="0.13.0"))'
         run: |
-          julia  -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter"))'
-          julia  -e 'using JuliaFormatter; format(".", verbose=true)'
+          julia -e 'using Pkg; Pkg.add(PackageSpec(name="JuliaFormatter", version="2.12.4"))'
+          julia -e 'using JuliaFormatter; format(".", verbose=true)'
       - name: Format check
         run: |
           julia -e '
diff --git a/.github/workflows/ci_nightly.yml b/.github/workflows/ci_nightly.yml
index 53b2432b..d4fd3375 100644
--- a/.github/workflows/ci_nightly.yml
+++ b/.github/workflows/ci_nightly.yml
@@ -25,6 +25,9 @@ jobs:
     name: ${{ matrix.pkg.name }} - Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ matrix.nthreads }} threads - ${{ github.event_name }}
     runs-on: ${{ matrix.os }}
     timeout-minutes: 45
+    permissions:
+      contents: read
+      id-token: write
     strategy:
       fail-fast: false
       matrix:
@@ -64,10 +67,21 @@ jobs:
           JULIA_NUM_THREADS: ${{ matrix.nthreads }}
         with:
           project: ${{ matrix.pkg.dir }}
-      - uses: julia-actions/julia-processcoverage@v1
+      - name: Process Arrow.jl coverage
+        if: matrix.pkg.name == 'Arrow.jl'
+        uses: julia-actions/julia-processcoverage@v1
+        with:
+          directories: src,ext
+      - name: Process subpackage coverage
+        if: matrix.pkg.name != 'Arrow.jl'
+        uses: julia-actions/julia-processcoverage@v1
+        with:
+          directories: ${{ matrix.pkg.dir }}/src
       - uses: codecov/codecov-action@v7
         with:
           files: lcov.info
+          fail_ci_if_error: true
+          use_oidc: true
   test_monorepo:
     name: Monorepo dev - Julia ${{ matrix.version }} - ${{ matrix.os }} - ${{ matrix.arch }} - ${{ github.event_name }}
     runs-on: ${{ matrix.os }}
diff --git a/.github/workflows/conformance.yml b/.github/workflows/conformance.yml
new file mode 100644
index 00000000..ca867627
--- /dev/null
+++ b/.github/workflows/conformance.yml
@@ -0,0 +1,54 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+name: Conformance
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '30 1 * * 1'
+  pull_request:
+    paths:
+      - 'Project.toml'
+      - 'conformance/**'
+      - 'src/**'
+      - 'test/**'
+      - '.github/workflows/conformance.yml'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: conformance-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  conformance:
+    name: Arrow corpus and external oracles
+    runs-on: ubuntu-latest
+    timeout-minutes: 120
+    steps:
+      - uses: actions/checkout@v7
+      - uses: julia-actions/setup-julia@v3
+        with:
+          version: '1.12.6'
+      - uses: actions/cache@v6
+        with:
+          path: ~/.julia/artifacts
+          key: conformance-${{ runner.os }}-${{ hashFiles('conformance/host/Project.toml') }}
+          restore-keys: conformance-${{ runner.os }}-
+      - name: Run the Arrow corpus and PyArrow/Nanoarrow oracles
+        run: julia --startup-file=no --history-file=no conformance/run.jl --rebuild
diff --git a/.github/workflows/fuzz.yml b/.github/workflows/fuzz.yml
new file mode 100644
index 00000000..d9aaba8b
--- /dev/null
+++ b/.github/workflows/fuzz.yml
@@ -0,0 +1,94 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+name: Deterministic fuzz
+
+on:
+  schedule:
+    - cron: '15 3 * * 3'
+  workflow_dispatch:
+    inputs:
+      seed:
+        description: Master UInt64 seed (decimal or 0x-prefixed hex)
+        required: false
+        default: '0x9f5a37c241de880b'
+      cases:
+        description: Differential cases
+        required: false
+        default: '512'
+      mutations:
+        description: Byte mutations
+        required: false
+        default: '20000'
+
+permissions:
+  contents: read
+
+concurrency:
+  group: fuzz-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: false
+
+jobs:
+  fuzz:
+    name: Extended differential and mutation fuzz - stable Julia
+    runs-on: ubuntu-latest
+    timeout-minutes: 90
+    env:
+      FUZZ_SEED: ${{ github.event_name == 'schedule' && github.run_id || inputs.seed || '0x9f5a37c241de880b' }}
+      FUZZ_CASES: ${{ inputs.cases || '512' }}
+      FUZZ_MUTATIONS: ${{ inputs.mutations || '20000' }}
+      FUZZ_REPRO_DIR: fuzz-reproductions
+    steps:
+      - uses: actions/checkout@v7
+      - uses: julia-actions/setup-julia@v3
+        with:
+          version: '1'
+      - uses: actions/cache@v6
+        with:
+          path: ~/.julia/artifacts
+          key: fuzz-${{ runner.os }}-${{ hashFiles('**/Project.toml') }}
+          restore-keys: fuzz-${{ runner.os }}-
+      - name: Prepare development dependencies
+        shell: julia --project=. {0}
+        run: |
+          using Pkg
+          Pkg.develop([PackageSpec(path="src/ArrowTypes")])
+      - name: Report replay coordinates
+        run: |
+          echo "event=$GITHUB_EVENT_NAME"
+          echo "master_seed=$FUZZ_SEED"
+          if [ "$GITHUB_EVENT_NAME" = "schedule" ] && [ "$FUZZ_SEED" != "$GITHUB_RUN_ID" ]; then
+            echo "scheduled fuzz seed must equal the workflow run ID" >&2
+            exit 1
+          fi
+      - name: Run deterministic differential and mutation fuzzing
+        run: >-
+          timeout --signal=TERM --kill-after=30s 80m
+          julia --color=yes --startup-file=no --history-file=no --project=.
+          test/fuzz.jl
+          --seed "$FUZZ_SEED"
+          --cases "$FUZZ_CASES"
+          --mutations "$FUZZ_MUTATIONS"
+          --determinism-every 256
+          --repro-dir "$FUZZ_REPRO_DIR"
+      - name: Upload failure reproductions
+        if: failure() && hashFiles('fuzz-reproductions/**') != ''
+        uses: actions/upload-artifact@v6
+        with:
+          name: deterministic-fuzz-reproductions
+          path: fuzz-reproductions
+          if-no-files-found: ignore
+          retention-days: 14
diff --git a/.gitignore b/.gitignore
index 4c10e7e3..a722be11 100644
--- a/.gitignore
+++ b/.gitignore
@@ -17,10 +17,10 @@
 
 Manifest.toml
 Manifest-v*.toml
-.DS_STORE
+.DS_Store
 *.jl.cov
 *.jl.*.cov
 *.jl.mem
+docs/build/
 
 test/_scrap.jl
-.DS_STORE
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000..29de11c0
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,134 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# Changelog
+
+## 3.0.0 - Unreleased
+
+Arrow.jl 3.0 is a new implementation of the reader, the writer, and the C data
+interface. The main names stay: `Arrow.Table`, `Arrow.Stream`, `Arrow.write`,
+`Arrow.Writer`, `Arrow.append`, `Arrow.tobuffer`, `Arrow.DictEncode`, and
+`Arrow.getmetadata`. The [migration guide](docs/src/migration.md) shows how to update
+code, and what Arrow 2.x can read of files Arrow 3.0 writes.
+
+### Breaking
+
+- Requires Julia 1.10, ArrowTypes.jl 2, Tables.jl 1.14, DataStrings.jl 1,
+  DataDecimals.jl 1, and Durations.jl 1.4. TimeZones.jl and BitIntegers.jl are no
+  longer dependencies.
+- Value types: strings read as `DataStrings.DataString` and binary as `DataBytes`
+  (`stringtype=String` reads `String`s); timestamps as `Durations.Timestamp{P}` at the
+  column's unit, no longer truncated to `DateTime`; zoned timestamps as
+  `Durations.ZonedTimestamp{P,Z}` instead of `ZonedDateTime`; decimals as
+  `DataDecimals.Decimal`; intervals as `Durations.Duration`.
+- Nested values: list rows are `Arrow.ListValue` views; map rows are `Arrow.MapValue`s,
+  an `AbstractDict` in stored order, instead of `Dict`s (copies, as in `DataFrame(table)`,
+  hold `Dict`s); fixed-size lists read as tuples only when they have at most 64 values
+  and no nulls.
+- Columns are read-only; assigning into one is an error. Copy with `copy(table)`,
+  `DataFrame(table)`, or `Arrow.read(source, DataFrame)`.
+- Removed: the `convert` keyword, `Arrow.Table(bytes, pos, len)`, reading a vector of
+  sources as one table or stream, `Arrow.ToTimestamp`, and the `Arrow.ToArrow`
+  binding. Compressor objects are no longer accepted by `compress`.
+- Unknown keywords are an `ArgumentError`. The 2.x writer keywords `alignment`,
+  `dictencodenested`, `denseunions`, and `maxdepth` are ignored with a warning.
+- `Arrow.Writer` takes its schema from the first table, with every column nullable
+  unless `nullable=false`; later tables, and tables given to `Arrow.append`, must
+  convert to the schema exactly.
+- `dictencode=false` writes `PooledArray` and `CategoricalArray` columns as plain values.
+- Writing a string that is not valid UTF-8 is an error.
+- New column encodings that Arrow 2.x reads differently or not at all: `UUID` as the
+  canonical `arrow.uuid` extension; `Int128` and `UInt128` as 16-byte fixed-size binary
+  labelled `JuliaLang.Int128`/`UInt128`; `Minute`, `Hour`, `Day`, and `Week` as
+  durations in seconds and `Month` and `Year` as year-month intervals, labelled;
+  `VersionNumber` as labelled strings; `Durations.Duration` as month-day-nano intervals.
+- A `Symbol` column interns at most `Limits.max_new_symbols` new symbols per read.
+- Columns that share a name read as `a`, `a_1`, `a_2`, as in CSV.jl.
+- Rejected input: big-endian IPC, metadata versions before V4, bytes after a stream's
+  end marker in `Arrow.Table` (read several streams with one `Arrow.Stream` each), and
+  a time of day outside [0, 24 h), which 2.x wrapped.
+
+### Added
+
+- `select`, `drop`, `filter`, `limit`, `offset`, and `scan` (a `Tables.Scan`) on
+  `Arrow.Table`, `Arrow.Stream`, and `Arrow.read`, with the filter functions `Arrow.col`,
+  `Arrow.colcmp`, `Arrow.colin`, and `Arrow.isnull`.
+- `Arrow.read(source, sink)` reads into a sink with owned columns.
+- `==`, `isequal`, and `hash` on `Arrow.Table`, comparing names and columns, and
+  `DataAPI.nrow` and `DataAPI.ncol`.
+- `Arrow.AbstractArrowSource` (`Arrow.sourcelength`, `Arrow.readrange`,
+  `Arrow.concurrentreads`) reads only the byte ranges a read needs, and a CloudStore.jl
+  extension reads S3 and Azure objects that way.
+- `Arrow.Stream` reads a stream-format `IO` one record batch at a time as it arrives,
+  and gives file-format batches by index (`stream[i]`), with `length`, `DataAPI.nrow`,
+  `Tables.schema`, and DataAPI metadata without reading data.
+- `ntasks` on reads. Reads and writes give the same values and bytes for every `ntasks`.
+- `Arrow.release!`, `copy(table)`, `Arrow.Limits`, `Arrow.ValidationError`, and
+  `Arrow.AllocationLimitError`.
+- Writer keywords `compresslevel`, `batchsize`, `dictdeltas` (delta dictionaries),
+  `stringview` (string and binary views), and, on `Arrow.Writer`, `nullable` and
+  `dictreplacement` (replacement dictionaries); `dictencode` takes column names.
+- Reading list views, run-end encoding, month-day-nano intervals, and the canonical
+  `arrow.uuid`, `arrow.bool8`, and `arrow.fixed_shape_tensor` extensions. Rewriting a
+  table keeps these types.
+- The C data and C stream interfaces: `Arrow.to_c_data(table)` and
+  `Arrow.export_stream!(streamptr, table)` export any Tables.jl table, built as
+  `Arrow.write` builds it: plain integer and float `Vector`s and an `Arrow.Table`'s
+  integer, float, and boolean buffers cross without copying, and other columns are built
+  into new buffers. `Arrow.Table(schemaptr, arrayptr)`,
+  `Arrow.Table(streamptr)`, and `Arrow.Stream(streamptr)` import a record batch or a
+  stream with the column types an IPC read gives, reading fixed-width values in the
+  producer's memory. Memory handed to a consumer is freed once the consumer releases
+  it, with nothing to call.
+- Rows of a dictionary column, `t.c[rows]` for any vector of integer indices or a `Bool`
+  mask, are a `PooledArray` with the column's categories, as `copy(t.c)` is.
+- A TimeZones.jl extension that writes `ZonedDateTime` columns, and a CategoricalArrays
+  extension that writes ordered `CategoricalArray`s as ordered dictionaries and reports
+  `isordered` for ordered dictionary columns.
+- A FileIO.jl extension: `load("x.arrow")` reads an `Arrow.Table` and
+  `save("x.arrow", table)` writes one.
+- A DataFrames.jl extension that precompiles reading into and writing from a
+  `DataFrame`, so the first one in a session takes about 0.1 s rather than 0.3 s.
+
+### Changed
+
+- On Windows, a path is read into memory unless `mmap=true`, since Windows cannot
+  delete a mapped file.
+- String columns are `StringVector`s of 16-byte values over the source's own bytes
+  (the mapped file, the byte vector, or the decompressed buffer), built once when the
+  column is first taken; 2.x allocated a new `String` on every access. `copy(table)`
+  and `Arrow.read` give string columns that own their bytes.
+- `Arrow.write` writes partition by partition, so a partitioned source such as
+  `CSV.Chunks` writes in about one partition's memory, and validates each record batch
+  before writing it.
+- Writing to an existing path writes a new file and renames it over the old one: a
+  failed write leaves the old file, and tables that map the old file keep working.
+- Decimals write as decimal128, or decimal256 above 38 digits, whatever the storage of
+  the Julia value.
+- `metadata` and `colmetadata` default to the table's DataAPI metadata.
+- A table with several partitions writes every column as nullable.
+- A buffer that compression would not shrink is written uncompressed.
+
+### Fixed
+
+- Polars' IPC files read; 2.x read them as an empty table.
+- Decimal32 and Decimal64 columns read their values; 2.x read them as 128-bit values.
+- Timestamps finer than a millisecond read exactly.
+- Corrupt or hostile input fails with a `ValidationError` or `AllocationLimitError`
+  instead of crashing, hanging, or allocating without bound.
diff --git a/CONTEXT.md b/CONTEXT.md
new file mode 100644
index 00000000..3bb11fd8
--- /dev/null
+++ b/CONTEXT.md
@@ -0,0 +1,54 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements. See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership. The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied. See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# Arrow.jl
+
+Arrow.jl maps between the Arrow columnar format and Julia values. These terms name the
+domains and verification paths used by the package.
+
+## Language
+
+**Storage domain**:
+The Julia values that directly represent an Arrow physical layout before facade or
+ArrowTypes conversion.
+_Avoid_: Raw values, wire values
+
+**Public domain**:
+The Julia values exposed by `Arrow.Table` and `Arrow.Stream` after facade and
+ArrowTypes conversion.
+_Avoid_: Converted values, logical values
+
+**Scan plan**:
+A `Tables.Scan` request resolved against one Arrow schema, including its storage-domain
+filter, selected output, row window, and remaining public-domain conversion.
+_Avoid_: Lowered scan
+
+**Column construction**:
+The mapping from a Julia column and optional retained Arrow field to one Arrow field and
+its array data.
+_Avoid_: Column conversion, column building
+
+**Acceptance battery**:
+An assertion-dense executable that verifies one Arrow adapter through its supported
+interface.
+_Avoid_: Integration script, smoke test
+
+**Conformance oracle**:
+An independent Arrow implementation or corpus used to judge interoperability.
+_Avoid_: Golden test, reference test
diff --git a/NOTICE b/NOTICE
index 147b1901..fc6b69b3 100644
--- a/NOTICE
+++ b/NOTICE
@@ -1,5 +1,5 @@
 Apache Arrow Julia
-Copyright 2016-2025 The Apache Software Foundation
+Copyright 2016-2026 The Apache Software Foundation
 
 This product includes software developed at
 The Apache Software Foundation (https://www.apache.org/).
diff --git a/Project.toml b/Project.toml
index e9fc73f0..f71f2503 100644
--- a/Project.toml
+++ b/Project.toml
@@ -17,38 +17,70 @@
 name = "Arrow"
 uuid = "69666777-d1a9-59fb-9406-91d4454c9d45"
 authors = ["quinnj <quinn.jacobd@gmail.com>"]
-version = "2.8.1"
+version = "3.0.0-DEV"
 
 [deps]
+DataDecimals = "3e2245cb-6932-498d-a7cf-39d39de8bde3"
+Durations = "41ac09f5-0a95-4810-aa18-c88bf48ee130"
+DataStrings = "48204bd6-5611-42ea-b167-fc1d713f9be2"
 ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd"
-BitIntegers = "c3b6d118-76ef-56ca-8cc7-ebb389d030a1"
 CodecLz4 = "5ba52731-8f18-5e0d-9241-30f10d1ec561"
 CodecZstd = "6b39b394-51ab-5f42-8807-6242bab2b4c2"
-ConcurrentUtilities = "f0e56b4a-5159-44fe-b623-3e5288b988bb"
 DataAPI = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 EnumX = "4e289a0a-7415-4d19-859d-a7e5c4648b56"
 Mmap = "a63ad114-7e13-5084-954f-fe012c677804"
 PooledArrays = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
+PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a"
 SentinelArrays = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
-StringViews = "354b36f9-a18e-4713-926e-db85100087ba"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
-TimeZones = "f269a46b-ccf7-5d73-abea-4c690281aa53"
 TranscodingStreams = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
+# ArrowTypes is developed in this repository. DataStrings resolves from General.
+[sources]
+ArrowTypes = {path = "src/ArrowTypes"}
+
+[weakdeps]
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
+FilePathsBase = "48062228-2e41-5def-b9a4-89aafe57970f"
+Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597"
+CloudStore = "3365d9ee-d53b-4a56-812d-5344d5b716d7"
+TimeZones = "f269a46b-ccf7-5d73-abea-4c690281aa53"
+
+[extensions]
+ArrowDataFramesExt = "DataFrames"
+ArrowFileIOExt = "FileIO"
+ArrowFilePathsBaseExt = "FilePathsBase"
+ArrowSerializationExt = "Serialization"
+ArrowCategoricalArraysExt = "CategoricalArrays"
+ArrowCloudStoreExt = "CloudStore"
+ArrowTimeZonesExt = "TimeZones"
+
 [compat]
-ArrowTypes = "1.1,2"
-BitIntegers = "0.2, 0.3"
+DataFrames = "1"
+FileIO = "1.16"
+FilePathsBase = "0.9"
+Serialization = "1.10"
+DataDecimals = "1"
+Durations = "1.4"
+DataStrings = "1"
+ArrowTypes = "2"
+CategoricalArrays = "0.10, 1"
+CloudStore = "1.6"
 CodecLz4 = "0.4"
-CodecZstd = "0.7, 0.8"
-ConcurrentUtilities = "2"
-DataAPI = "1"
+DataAPI = "1.12"
+Dates = "1.10"
+CodecZstd = "0.8"
 EnumX = "1"
-PooledArrays = "0.5, 1.0"
-SentinelArrays = "1"
-StringViews = "1, 2"
-Tables = "1.1"
+Mmap = "1.10"
+PooledArrays = "1.4"
+PrecompileTools = "1"
+SentinelArrays = "1.4"
+Tables = "1.14"
 TimeZones = "1"
 TranscodingStreams = "0.9.12, 0.10, 0.11"
-julia = "1.9"
+UUIDs = "1.10"
+julia = "1.10"
diff --git a/README.md b/README.md
index 98bc9fd9..7c8450f9 100644
--- a/README.md
+++ b/README.md
@@ -17,55 +17,80 @@
   under the License.
 -->
 
-# Arrow
+# Arrow.jl
 
-[![docs](https://img.shields.io/badge/docs-latest-blue&logo=julia)](https://arrow.apache.org/julia/)
-[![CI](https://github.com/apache/arrow-julia/workflows/CI/badge.svg)](https://github.com/apache/arrow-julia/actions?query=workflow%3ACI)
-[![codecov](https://app.codecov.io/gh/apache/arrow-julia/branch/main/graph/badge.svg)](https://app.codecov.io/gh/apache/arrow-julia)
+[![Documentation](https://img.shields.io/badge/docs-latest-blue?logo=julia)](https://arrow.apache.org/julia/)
+[![CI](https://github.com/apache/arrow-julia/actions/workflows/ci.yml/badge.svg)](https://github.com/apache/arrow-julia/actions/workflows/ci.yml)
+[![Codecov](https://codecov.io/gh/apache/arrow-julia/branch/main/graph/badge.svg)](https://codecov.io/gh/apache/arrow-julia)
 
-[![deps](https://juliahub.com/docs/Arrow/deps.svg)](https://juliahub.com/ui/Packages/Arrow/QnF3w?t=2)
-[![version](https://juliahub.com/docs/Arrow/version.svg)](https://juliahub.com/ui/Packages/Arrow/QnF3w)
-[![pkgeval](https://juliahub.com/docs/Arrow/pkgeval.svg)](https://juliahub.com/ui/Packages/Arrow/QnF3w)
+Arrow.jl reads and writes the [Apache Arrow](https://arrow.apache.org) IPC file and
+stream formats in pure Julia. A file reads as Tables.jl columns that view its memory, and
+any Tables.jl table writes. It also implements the Arrow C data and C stream interfaces.
 
-This is a pure Julia implementation of the [Apache Arrow](https://arrow.apache.org) data standard.  This package provides Julia `AbstractVector` objects for
-referencing data that conforms to the Arrow standard.  This allows users to seamlessly interface Arrow formatted data with a great deal of existing Julia code.
-
-Please see this [document](https://arrow.apache.org/docs/format/Columnar.html#physical-memory-layout) for a description of the Arrow memory layout.
+> [!IMPORTANT]
+> This is the Arrow.jl 3.0 development branch; 3.0 is not registered yet. Arrow 3.0 is a
+> breaking release: read the [migration guide](docs/src/migration.md) before you upgrade
+> from 2.x. A checkout uses the in-repository `src/ArrowTypes` package: Julia 1.11+
+> resolves it through `[sources]`; on Julia 1.10 run the `Pkg.develop` commands below.
 
 ## Installation
 
-The package can be installed by typing in the following in a Julia REPL:
-
 ```julia
-julia> using Pkg; Pkg.add("Arrow")
+import Pkg
+Pkg.add("Arrow")
 ```
 
-## Local Development
+## Quick start
+
+```julia
+using Arrow, DataFrames
+
+Arrow.write("data.arrow", (id=[1, 2, 3], name=["Ada", "Ben", missing]))
+
+table = Arrow.Table("data.arrow")        # columns view the file
+table.name                               # ["Ada", "Ben", missing]
+df = Arrow.read("data.arrow", DataFrame) # a DataFrame with its own columns
 
-When developing on Arrow.jl it is recommended that you run the following to ensure that any
-changes to ArrowTypes.jl are immediately available to Arrow.jl without requiring a release:
+subset = Arrow.Table("data.arrow"; select=[:id], filter=Arrow.col(:id) > 1)
 
-```sh
-julia --project -e 'using Pkg; Pkg.develop(path="src/ArrowTypes")'
+for batch in Arrow.Stream("data.arrow")  # one record batch at a time
+    # ...
+end
 ```
 
-## Format Support
+The [documentation](https://arrow.apache.org/julia/) covers reading, writing, streams,
+the type mapping, limits and errors, the C data interface, and migrating from 2.x. The
+[changelog](CHANGELOG.md) summarizes what changed in 3.0.
 
-This implementation supports the 1.0 version of the specification, including support for:
-  * All primitive data types
-  * All nested data types
-  * Dictionary encodings and messages
-  * Extension types
-  * Streaming, file, record batch, and replacement and isdelta dictionary messages
+## Development
 
-It currently doesn't include support for:
-  * Tensors or sparse tensors
-  * Flight RPC
-  * C data interface
+In a checkout of this branch, prepare the local subpackages, then run the
+tests:
 
-Third-party data formats:
-  * CSV, parquet and avro support via the existing [CSV.jl](https://github.com/JuliaData/CSV.jl), [Parquet.jl](https://github.com/JuliaIO/Parquet.jl) and [Avro.jl](https://github.com/JuliaData/Avro.jl) packages
-  * Other Tables.jl-compatible packages automatically supported ([DataFrames.jl](https://github.com/JuliaData/DataFrames.jl), [JSONTables.jl](https://github.com/JuliaData/JSONTables.jl), [JuliaDB.jl](https://github.com/JuliaData/JuliaDB.jl), [SQLite.jl](https://github.com/JuliaDatabases/SQLite.jl), [MySQL.jl](https://github.com/JuliaDatabases/MySQL.jl), [JDBC.jl](https://github.com/JuliaDatabases/JDBC.jl), [ODBC.jl](https://github.com/JuliaDatabases/ODBC.jl), [XLSX.jl](https://github.com/felipenoris/XLSX.jl), etc.)
-  * No current Julia packages support ORC
+```julia
+import Pkg
+Pkg.activate(".")
+Pkg.develop(path="src/ArrowTypes")
+Pkg.test()
+```
 
-See the [full documentation](https://arrow.apache.org/julia/) for details on reading and writing arrow data.
+The repository also has Apache Arrow gold-corpus checks, PyArrow and
+Nanoarrow IPC oracle checks, and PyArrow C interface checks. Run all of them
+with `julia conformance/run.jl`. Docker and network access for the first image
+build are required.
+
+Run `julia --project=. test/fuzz.jl --cases 16 --mutations 64` for the
+deterministic PR-sized fuzz suite. The scheduled workflow runs the extended
+512-case and 20,000-mutation suite with a new reproducible master seed for each
+scheduled run. It repeats the first full route sweep and every 256th mutation
+to detect unstable outcomes. If the runner records or times out on a case, the
+workflow uploads its replay coordinates, mutated bytes when available, the
+resolved package environment, and a location-independent `replay.sh` wrapper.
+
+The Arrow 3.0 rewrite used Anthropic Claude Code and OpenAI Codex for code
+generation, test generation, and review. Apache Arrow maintainers remain
+responsible for understanding, reviewing, testing, and approving the code and
+each release.
+
+See [the engine design](docs/dev/core-README.md) for the source layout and
+internal contracts.
diff --git a/bench/README.md b/bench/README.md
new file mode 100644
index 00000000..357d5353
--- /dev/null
+++ b/bench/README.md
@@ -0,0 +1,70 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# IPC throughput benchmarks
+
+Run the package and PyArrow against deterministic primitive, nullable, string,
+list, and dictionary columns:
+
+```sh
+julia --project=. -t 1 bench/run.jl /tmp/arrow-bench-1
+julia --project=. -t 8 bench/run.jl /tmp/arrow-bench-8
+```
+
+The driver uses a host `python3` with PyArrow installed. Set `ARROW_BENCH_PYTHON`
+to a different Python executable if needed. If host PyArrow is unavailable, it
+uses the image built by `julia conformance/run.jl`, or reports that the Python leg
+was skipped. A Docker fallback is useful for checking the harness; its timings
+include different filesystem and CPU scheduling costs from the host Julia run.
+
+Both readers use the **same Julia-written file**, memory mapped, and request all
+columns. Arrow.jl validates buffers and constructs its DataStrings columns on
+first access. Numeric and nested columns retain views. PyArrow's `read_all`
+returns its native Arrow arrays, usually without further construction. These
+measure the cost of making columns available, not iterating every value or
+copying them into mutable Julia/Python objects. The driver prints this distinction
+with every report. Both legs check the complete logical values outside the timing.
+
+Writes start from equivalent in-memory data, use batches of at most 1,048,576
+rows, and write uncompressed IPC files. Dictionary construction is timed in both
+implementations. Each repetition writes a fresh destination; deletion of the
+previous output happens before the timer. This does not measure the additional
+cost of Arrow.jl's atomic replacement of an existing file.
+
+Each operation warms up once, then reports the median of three repetitions.
+The Julia process and PyArrow CPU pool use the driver's thread count. Filesystem
+caches are warm. File size divided by elapsed time gives the displayed MB/s;
+writer output sizes can differ because physical layout choices differ.
+
+Use a quiet machine, alternate thread counts, and repeat runs before drawing
+conclusions from small timing differences. This harness does not measure peak
+memory, first-use compilation, compressed IO, or predicate pushdown. It is a
+small throughput check, not evidence that every workload is faster than another
+implementation.
+
+For a quick correctness check of the harness, scale every workload down:
+
+```sh
+ARROW_BENCH_SCALE=0.001 julia --project=. bench/run.jl /tmp/arrow-bench-smoke
+```
+
+`ARROW_BENCH_SCALE` must be positive and finite. Keep it at the same value for
+all compared runs; the default is 1 (10M primitive rows, 2M strings, 1M lists,
+2M dictionary rows). The work directory retains both implementations' files and
+JSONL results for inspection.
diff --git a/bench/bench_pyarrow.py b/bench/bench_pyarrow.py
new file mode 100644
index 00000000..08390dfc
--- /dev/null
+++ b/bench/bench_pyarrow.py
@@ -0,0 +1,135 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# PyArrow serialize/deserialize timing over the same logical workloads.
+# Both readers use the Julia-written files. read_all returns Arrow arrays;
+# neither leg times scalar iteration or conversion to Python objects.
+# Usage: bench/run.jl chooses a local Python or the conformance image.
+
+import sys, time, os, math
+import pyarrow as pa
+import pyarrow.ipc as ipc
+
+SCALE = float(os.environ.get("ARROW_BENCH_SCALE", "1"))
+if not math.isfinite(SCALE) or SCALE <= 0:
+    raise ValueError("ARROW_BENCH_SCALE must be positive and finite")
+ROWS_PRIMITIVE = max(1, round(10_000_000 * SCALE))
+ROWS_STRINGS = max(1, round(2_000_000 * SCALE))
+ROWS_LISTS = max(1, round(1_000_000 * SCALE))
+ROWS_DICT = max(1, round(2_000_000 * SCALE))
+BATCHSIZE = 1_048_576
+THREADS = int(sys.argv[2]) if len(sys.argv) > 2 else 1
+pa.set_cpu_count(THREADS)
+
+
+def wl_primitive():
+    n = ROWS_PRIMITIVE
+    return pa.table({
+        "a": pa.array(range(1, n + 1), type=pa.int64()),
+        "b": pa.array((float(i) for i in range(1, n + 1)),
+                      type=pa.float64(), size=n),
+    })
+
+
+def wl_nullable():
+    n = ROWS_PRIMITIVE
+    return pa.table({
+        "a": pa.array((None if i % 7 == 0 else i for i in range(1, n + 1)),
+                      type=pa.int64(), size=n),
+    })
+
+
+def wl_strings():
+    n = ROWS_STRINGS
+    return pa.table({"s": pa.array("value-%d" % (i % 1000)
+                                   for i in range(1, n + 1))})
+
+
+def wl_lists():
+    n = ROWS_LISTS
+    return pa.table({"l": pa.array([[i, i + 1, i + 2]
+                                    for i in range(1, n + 1)],
+                                   type=pa.list_(pa.int64()))})
+
+
+def wl_dictpool():
+    # Plain strings: dictionary_encode runs INSIDE the write timer so all
+    # both legs time pool construction + dictionary write.
+    n = ROWS_DICT
+    return pa.table({"d": pa.array("cat-%d" % (i % 32)
+                                   for i in range(1, n + 1))})
+
+
+WORKLOADS = [
+    ("primitive", wl_primitive),
+    ("nullable", wl_nullable),
+    ("strings", wl_strings),
+    ("lists", wl_lists),
+    ("dictpool", wl_dictpool),
+]
+
+
+def bench(f, runs=3, setup=lambda: None):
+    setup()
+    f()
+    ts = []
+    for _ in range(runs):
+        setup()
+        t0 = time.perf_counter()
+        f()
+        ts.append(time.perf_counter() - t0)
+    ts.sort()
+    return ts[len(ts) // 2]
+
+
+def main(outdir):
+    for name, make in WORKLOADS:
+        tbl = make()
+        path = os.path.join(outdir, "pyarrow-%s.arrow" % name)
+
+        def write():
+            out = tbl
+            if name == "dictpool":
+                out = pa.table({"d": tbl["d"].combine_chunks()
+                                .dictionary_encode()})
+            with ipc.new_file(path, out.schema) as w:
+                w.write_table(out, max_chunksize=BATCHSIZE)
+
+        def fresh():
+            if os.path.exists(path):
+                os.remove(path)
+
+        twrite = bench(write, setup=fresh)
+        size = os.path.getsize(path)
+        inputpath = os.path.join(outdir, "rewrite-%s.arrow" % name)
+
+        def read():
+            with pa.memory_map(inputpath) as src:
+                return ipc.open_file(
+                    src, options=ipc.IpcReadOptions(use_threads=THREADS > 1)
+                ).read_all()
+
+        tread = bench(read)
+        # Cast dictionary columns back to their plain-string input domain.
+        if not read().cast(tbl.schema).equals(tbl):
+            raise AssertionError("round-trip mismatch in %s" % name)
+        for op, secs in (("write", twrite), ("read", tread)):
+            nbytes = size if op == "write" else os.path.getsize(inputpath)
+            print('{"impl":"pyarrow","workload":"%s","op":"%s",'
+                  '"seconds":%r,"bytes":%d}' % (name, op, secs, nbytes))
+
+
+main(sys.argv[1])
diff --git a/bench/bench_rewrite.jl b/bench/bench_rewrite.jl
new file mode 100644
index 00000000..3d747d02
--- /dev/null
+++ b/bench/bench_rewrite.jl
@@ -0,0 +1,60 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Arrow.jl 3.0 (this repo) serialize/deserialize timing. Emits one JSON
+# object per line: {"impl","workload","op","seconds","bytes"}.
+# Usage: julia --project=. bench/bench_rewrite.jl <outdir>
+
+using Arrow, Tables
+include(joinpath(@__DIR__, "workloads.jl"))
+
+function main(outdir::String)
+    for (name, make) in BENCH_WORKLOADS
+        tbl = make()
+        path = joinpath(outdir, "rewrite-$name.arrow")
+        # Fresh destinations keep atomic replacement of existing paths out of
+        # the measurement. Removing the preceding output is untimed.
+        twrite = bench_time(
+            () -> Arrow.write(path, tbl; batchsize=BENCH_BATCHSIZE);
+            setup=() -> rm(path; force=true),
+        )
+        sz = filesize(path)
+        # Request every column: string payload construction is deferred until
+        # first access. Numeric and nested columns still contain views.
+        tread = bench_time() do
+            t = Arrow.Table(path)
+            for nm in Tables.columnnames(t)
+                length(Tables.getcolumn(t, nm))
+            end
+            Arrow.release!(t)
+        end
+        # Check every value outside the timing, including dictionary decoding.
+        t = Arrow.Table(path)
+        for nm in Tables.columnnames(tbl)
+            isequal(Tables.getcolumn(t, nm), Tables.getcolumn(tbl, nm)) ||
+                error("round-trip mismatch in $name.$nm")
+        end
+        Arrow.release!(t)
+        for (op, secs) in (("write", twrite), ("read", tread))
+            println(
+                "{\"impl\":\"rewrite\",\"workload\":\"$name\"," *
+                "\"op\":\"$op\",\"seconds\":$secs,\"bytes\":$sz}",
+            )
+        end
+    end
+end
+
+main(ARGS[1])
diff --git a/bench/run.jl b/bench/run.jl
new file mode 100644
index 00000000..23056109
--- /dev/null
+++ b/bench/run.jl
@@ -0,0 +1,158 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Serialize/deserialize benchmark driver: Arrow.jl vs PyArrow over
+# identical logical workloads.
+#
+#   julia --project=. bench/run.jl [workdir]
+#
+# Legs run in separate processes on the host when PyArrow is installed.
+# The conformance image is a fallback. Results print seconds and throughput.
+#
+# Both readers open the Julia-written files and return native columns.
+# Arrow.jl also validates buffers and builds DataStrings payloads; PyArrow
+# generally wraps buffers. Neither times scalar iteration or mutable copies.
+
+function _runleg(cmd::Cmd, out::String)
+    open(out, "w") do io
+        run(pipeline(cmd; stdout=io))
+    end
+    return nothing
+end
+
+# The workload names each leg must report (bench/workloads.jl owns their
+# definitions; the driver cannot include that file — it references Arrow).
+const WORKLOAD_NAMES = ("primitive", "nullable", "strings", "lists", "dictpool")
+
+function main(workdir::String)
+    mkpath(workdir)
+    here = @__DIR__
+    repo = dirname(here)
+    legs = Tuple{String,String}[]
+    threads = Threads.nthreads()
+    scale = get(ENV, "ARROW_BENCH_SCALE", "1")
+    println("Julia $(VERSION), $threads threads; ARROW_BENCH_SCALE=$scale")
+
+    rewriteout = joinpath(workdir, "rewrite.jsonl")
+    rewritescript = joinpath(here, "bench_rewrite.jl")
+    _runleg(
+        `$(Base.julia_cmd()) --startup-file=no --threads=$threads --project=$repo $rewritescript $workdir`,
+        rewriteout,
+    )
+    push!(legs, ("rewrite", rewriteout))
+
+    pyout = joinpath(workdir, "pyarrow.jsonl")
+    python = get(ENV, "ARROW_BENCH_PYTHON", something(Sys.which("python3"), "python3"))
+    havepython = try
+        success(pipeline(`$python -c "import pyarrow"`; stdout=devnull, stderr=devnull))
+    catch
+        false
+    end
+    !havepython &&
+        haskey(ENV, "ARROW_BENCH_PYTHON") &&
+        error("ARROW_BENCH_PYTHON must name a Python executable with pyarrow installed")
+    # A container is useful for smoke checks, but its IO and CPU scheduling
+    # differ from the host Julia process. Prefer a local Python for timings.
+    havedocker =
+        !havepython &&
+        Sys.which("docker") !== nothing &&
+        try
+            success(
+                pipeline(
+                    `docker image inspect arrow-julia-conformance:latest`;
+                    stdout=devnull,
+                    stderr=devnull,
+                ),
+            )
+        catch
+            false
+        end
+    if havepython
+        version = readchomp(`$python -c "import pyarrow; print(pyarrow.__version__)"`)
+        println("PyArrow $version, $threads threads, host Python: $python")
+        _runleg(`$python $(joinpath(here, "bench_pyarrow.py")) $workdir $threads`, pyout)
+        push!(legs, ("pyarrow", pyout))
+    elseif havedocker
+        image = "arrow-julia-conformance:latest"
+        python = "/opt/pyarrow/bin/python"
+        println(
+            "PyArrow runs in Docker; host/container timing ratios are not directly comparable.",
+        )
+        _runleg(
+            `docker run --rm -e ARROW_BENCH_SCALE=$scale -v $workdir:/bench -v $here:/src $image $python /src/bench_pyarrow.py /bench $threads`,
+            pyout,
+        )
+        push!(legs, ("pyarrow", pyout))
+    else
+        println(
+            "(pyarrow leg skipped: neither host PyArrow nor the conformance Docker image is available)",
+        )
+    end
+
+    # Minimal JSONL field extraction; the emitters write flat one-line
+    # objects with known keys.
+    results = Dict{Tuple{String,String,String},Tuple{Float64,Int64}}()
+    for (_, file) in legs, line in eachline(file)
+        isempty(strip(line)) && continue
+        g(k) = match(Regex("\"$k\":\"?([^\",}]+)"), line).captures[1]
+        key = (g("impl"), g("workload"), g("op"))
+        haskey(results, key) && error("duplicate benchmark record for $key")
+        results[key] = (parse(Float64, g("seconds")), parse(Int64, g("bytes")))
+    end
+    # A leg that exits 0 with partial output must refuse, not print a
+    # plausible table.
+    impls = [name for (name, _) in legs]
+    for impl in impls, wl in WORKLOAD_NAMES, op in ("write", "read")
+        haskey(results, (impl, wl, op)) ||
+            error("missing benchmark record for $((impl, wl, op))")
+    end
+
+    println()
+    println("Reads use the same memory-mapped files and request every column.")
+    println(
+        "Arrow.jl validates buffers and builds string payloads; PyArrow generally wraps buffers.",
+    )
+    println(
+        "Neither read times scalar iteration or mutable copies. Writes use fresh destinations.",
+    )
+    println()
+    println(
+        "| workload | op | " *
+        join(impls, " | ") *
+        " | MB/s (" *
+        join(impls, " / ") *
+        ") |",
+    )
+    println("|---|---|" * repeat("---|", length(impls) + 1))
+    for wl in WORKLOAD_NAMES, op in ("write", "read")
+        secs = [get(results, (impl, wl, op), (NaN, 0))[1] for impl in impls]
+        mbs = [
+            begin
+                s, b = get(results, (impl, wl, op), (NaN, 0))
+                isnan(s) ? "-" : string(round(b / s / 1e6; digits=0))
+            end for impl in impls
+        ]
+        println(
+            "| $wl | $op | " *
+            join([isnan(s) ? "-" : string(round(s; digits=4)) for s in secs], " | ") *
+            " | " *
+            join(mbs, " / ") *
+            " |",
+        )
+    end
+end
+
+main(isempty(ARGS) ? mktempdir() : abspath(ARGS[1]))
diff --git a/bench/workloads.jl b/bench/workloads.jl
new file mode 100644
index 00000000..04b7409f
--- /dev/null
+++ b/bench/workloads.jl
@@ -0,0 +1,82 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Shared workload definitions for the serialize/deserialize benchmarks.
+# Deterministic arithmetic data — every implementation
+# builds the same logical tables. The driver reads the Julia-written files
+# in both implementations; writers may choose different physical layouts.
+
+const BENCH_SCALE = parse(Float64, get(ENV, "ARROW_BENCH_SCALE", "1"))
+isfinite(BENCH_SCALE) && BENCH_SCALE > 0 ||
+    error("ARROW_BENCH_SCALE must be positive and finite")
+const BENCH_ROWS_PRIMITIVE = max(1, round(Int, 10_000_000 * BENCH_SCALE))
+const BENCH_ROWS_STRINGS = max(1, round(Int, 2_000_000 * BENCH_SCALE))
+const BENCH_ROWS_LISTS = max(1, round(Int, 1_000_000 * BENCH_SCALE))
+const BENCH_ROWS_DICT = max(1, round(Int, 2_000_000 * BENCH_SCALE))
+const BENCH_BATCHSIZE = 1_048_576
+
+function workload_primitive()
+    n = BENCH_ROWS_PRIMITIVE
+    return (a=collect(Int64, 1:n), b=collect(Float64, 1:n))
+end
+
+function workload_nullable()
+    n = BENCH_ROWS_PRIMITIVE
+    a = Vector{Union{Missing,Int64}}(undef, n)
+    for i = 1:n
+        a[i] = i % 7 == 0 ? missing : Int64(i)
+    end
+    return (a=a,)
+end
+
+function workload_strings()
+    n = BENCH_ROWS_STRINGS
+    return (s=[string("value-", i % 1000) for i = 1:n],)
+end
+
+function workload_lists()
+    n = BENCH_ROWS_LISTS
+    return (l=[Int64[i, i + 1, i + 2] for i = 1:n],)
+end
+
+function workload_dictpool()
+    # The leg times pool construction + dictionary write from plain
+    # strings, matching the PyArrow leg's timed dictionary_encode + write.
+    n = BENCH_ROWS_DICT
+    return (d=Arrow.DictEncode([string("cat-", i % 32) for i = 1:n]),)
+end
+
+const BENCH_WORKLOADS = (
+    ("primitive", workload_primitive),
+    ("nullable", workload_nullable),
+    ("strings", workload_strings),
+    ("lists", workload_lists),
+    ("dictpool", workload_dictpool),
+)
+
+"Median-of-k timing after one warmup run."
+function bench_time(f::F; runs::Int=3, setup=() -> nothing) where {F}
+    setup()
+    f()
+    times = Float64[]
+    for _ = 1:runs
+        setup()
+        t0 = time_ns()
+        f()
+        push!(times, (time_ns() - t0) / 1e9)
+    end
+    return sort!(times)[cld(length(times), 2)]
+end
diff --git a/codecov.yaml b/codecov.yaml
index a7b3fb59..e8daef95 100644
--- a/codecov.yaml
+++ b/codecov.yaml
@@ -18,5 +18,5 @@
 ---
 codecov:
   notify:
-    # Wait for all "test" matrix jobs
-    after_n_builds: 6
+    # One CI run uploads 16 Arrow reports and one ArrowTypes report.
+    after_n_builds: 17
diff --git a/conformance/ConformanceSupport.jl b/conformance/ConformanceSupport.jl
new file mode 100644
index 00000000..33cbbea0
--- /dev/null
+++ b/conformance/ConformanceSupport.jl
@@ -0,0 +1,1207 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Private support for the standalone Arrow conformance adapters.
+
+This module owns integration-JSON conversion, value-level comparison, skip
+policy, verdict construction, and common reporting. The corpus, IPC oracle,
+and C-interface oracle remain thin adapters that select cases and routes.
+"""
+module ConformanceSupport
+
+using CodecZlib
+using JSON
+import Arrow
+
+const AC = Arrow.ArrowCore
+const ArrowCore = Arrow.ArrowCore
+
+include(joinpath(@__DIR__, "arrowjson.jl"))
+
+const DEFAULT_CORPUS = get(ENV, "ARROW_TESTING_DIR", "")
+
+# Families declared out of scope for every conformance route. Everything else
+# must pass or it is a failure.
+const FAMILY_SKIP = Dict{String,String}(
+    "0.17.1" => "V4 experimental compression marker era; superseded by 2.0.0-compression",
+)
+
+# These families contain legacy gold IPC that our reader intentionally does
+# not accept. Their integration JSON and IPC written by the current Arrow.jl
+# implementation remain valid inputs to every other corpus and oracle route.
+const GOLD_IPC_SKIP = Dict{String,String}(
+    "1.0.0-bigendian" => "big-endian streams are not supported (no endianness normalization)",
+    "0.14.1" => "pre-1.0 legacy framing (four-byte prefix) is not accepted by design",
+)
+
+familyskipreason(family::AbstractString, context::AbstractString="") =
+    get(FAMILY_SKIP, family, get(FAMILY_SKIP, context, ""))
+
+goldipcskipreason(family::AbstractString, context::AbstractString="") =
+    get(GOLD_IPC_SKIP, family, get(GOLD_IPC_SKIP, context, ""))
+
+# --- value-level comparison -----------------------------------------------------
+
+# Compared values normally need no physical identity: dictionary ids, pool
+# unification, and integer JSON spellings are representation choices. A Union's
+# selected type id is different. It chooses one declared child and remains part
+# of the public-domain value even when two children materialize as equal Julia values.
+struct _PublicUnion
+    typeid::Int8
+    value::Any
+end
+
+# Core materialization intentionally replaces the physical integration-JSON
+# columns during comparison. Validate the JSON envelope first so that arity,
+# names, scalar kinds, and per-slot array lengths cannot disappear at that
+# boundary. Array lengths describe JSON entries, not legal byte-level buffer
+# padding. Nested child counts remain independent so null List/Map segments can
+# retain any spec-valid physical span.
+_isjsoninteger(value) = value isa Integer && !(value isa Bool)
+
+function _jsonkind(value)
+    value === nothing && return "null"
+    value isa Bool && return "Bool"
+    value isa Integer && return "integer"
+    value isa AbstractFloat && return "float"
+    value isa AbstractString && return "string"
+    value isa AbstractVector && return "array"
+    value isa AbstractDict && return "object"
+    return string(typeof(value))
+end
+
+function _shapediff!(diffs::Vector{String}, path::String, detail::AbstractString)
+    length(diffs) > 20 || push!(diffs, "$path: $detail")
+    return nothing
+end
+
+function _requireproperty!(
+    object::AbstractDict,
+    key::String,
+    predicate,
+    expectedkind::String,
+    path::String,
+    diffs::Vector{String},
+)
+    if !haskey(object, key)
+        _shapediff!(diffs, "$path.$key", "missing required property")
+        return false
+    end
+    predicate(object[key]) && return true
+    _shapediff!(
+        diffs,
+        "$path.$key",
+        "expected $expectedkind, got $(_jsonkind(object[key]))",
+    )
+    return false
+end
+
+function _validatemetadata!(owner::AbstractDict, path::String, diffs::Vector{String})
+    haskey(owner, "metadata") || return
+    metadata = owner["metadata"]
+    metadata === nothing && return
+    if !(metadata isa AbstractVector)
+        _shapediff!(
+            diffs,
+            "$path.metadata",
+            "expected array or null, got $(_jsonkind(metadata))",
+        )
+        return
+    end
+    for (index, entry) in enumerate(metadata)
+        entrypath = "$path.metadata[$index]"
+        if !(entry isa AbstractDict)
+            _shapediff!(diffs, entrypath, "expected object, got $(_jsonkind(entry))")
+            continue
+        end
+        _requireproperty!(
+            entry,
+            "key",
+            x -> x isa AbstractString,
+            "string",
+            entrypath,
+            diffs,
+        )
+        _requireproperty!(
+            entry,
+            "value",
+            x -> x isa AbstractString,
+            "string",
+            entrypath,
+            diffs,
+        )
+    end
+    return
+end
+
+function _validatejsontype!(type, path::String, diffs::Vector{String})
+    if !(type isa AbstractDict)
+        _shapediff!(diffs, path, "expected object, got $(_jsonkind(type))")
+        return
+    end
+    _requireproperty!(type, "name", x -> x isa AbstractString, "string", path, diffs) ||
+        return
+    name = type["name"]
+    if name == "int"
+        _requireproperty!(type, "bitWidth", _isjsoninteger, "integer", path, diffs)
+        _requireproperty!(type, "isSigned", x -> x isa Bool, "Bool", path, diffs)
+    elseif name == "floatingpoint"
+        _requireproperty!(
+            type,
+            "precision",
+            x -> x isa AbstractString,
+            "string",
+            path,
+            diffs,
+        )
+    elseif name == "fixedsizebinary"
+        _requireproperty!(type, "byteWidth", _isjsoninteger, "integer", path, diffs)
+    elseif name == "decimal"
+        _requireproperty!(type, "precision", _isjsoninteger, "integer", path, diffs)
+        _requireproperty!(type, "scale", _isjsoninteger, "integer", path, diffs)
+        haskey(type, "bitWidth") &&
+            !_isjsoninteger(type["bitWidth"]) &&
+            _shapediff!(
+                diffs,
+                "$path.bitWidth",
+                "expected integer, got $(_jsonkind(type["bitWidth"]))",
+            )
+    elseif name in ("date", "duration", "interval")
+        _requireproperty!(type, "unit", x -> x isa AbstractString, "string", path, diffs)
+    elseif name == "time"
+        _requireproperty!(type, "unit", x -> x isa AbstractString, "string", path, diffs)
+        _requireproperty!(type, "bitWidth", _isjsoninteger, "integer", path, diffs)
+    elseif name == "timestamp"
+        _requireproperty!(type, "unit", x -> x isa AbstractString, "string", path, diffs)
+        haskey(type, "timezone") &&
+            !(type["timezone"] isa AbstractString) &&
+            _shapediff!(
+                diffs,
+                "$path.timezone",
+                "expected string, got $(_jsonkind(type["timezone"]))",
+            )
+    elseif name == "fixedsizelist"
+        _requireproperty!(type, "listSize", _isjsoninteger, "integer", path, diffs)
+    elseif name == "map"
+        _requireproperty!(type, "keysSorted", x -> x isa Bool, "Bool", path, diffs)
+    elseif name == "union"
+        _requireproperty!(type, "mode", x -> x isa AbstractString, "string", path, diffs)
+        if _requireproperty!(
+            type,
+            "typeIds",
+            x -> x isa AbstractVector,
+            "array",
+            path,
+            diffs,
+        )
+            for (index, id) in enumerate(type["typeIds"])
+                _isjsoninteger(id) || _shapediff!(
+                    diffs,
+                    "$path.typeIds[$index]",
+                    "expected integer, got $(_jsonkind(id))",
+                )
+            end
+        end
+    elseif !(
+        name in (
+            "null",
+            "bool",
+            "utf8",
+            "largeutf8",
+            "binary",
+            "largebinary",
+            "utf8view",
+            "binaryview",
+            "list",
+            "largelist",
+            "listview",
+            "largelistview",
+            "struct",
+            "runendencoded",
+        )
+    )
+        _shapediff!(diffs, "$path.name", "unknown Arrow type $(repr(name))")
+    end
+    return
+end
+
+const _NO_CHILD_TYPES = Set((
+    "null",
+    "bool",
+    "int",
+    "floatingpoint",
+    "utf8",
+    "largeutf8",
+    "binary",
+    "largebinary",
+    "utf8view",
+    "binaryview",
+    "fixedsizebinary",
+    "decimal",
+    "date",
+    "time",
+    "timestamp",
+    "duration",
+    "interval",
+))
+const _ONE_CHILD_TYPES =
+    Set(("list", "largelist", "listview", "largelistview", "fixedsizelist", "map"))
+
+function _validatefieldarity!(
+    field::AbstractDict,
+    children::AbstractVector,
+    path::String,
+    diffs::Vector{String},
+)
+    type = get(field, "type", nothing)
+    type isa AbstractDict || return
+    name = get(type, "name", nothing)
+    name isa AbstractString || return
+    expected =
+        name in _NO_CHILD_TYPES ? 0 :
+        name in _ONE_CHILD_TYPES ? 1 : name == "runendencoded" ? 2 : nothing
+    if name == "union" && get(type, "typeIds", nothing) isa AbstractVector
+        expected = length(type["typeIds"])
+    end
+    expected === nothing ||
+        length(children) == expected ||
+        _shapediff!(
+            diffs,
+            "$path.children",
+            "$name requires $expected schema children, got $(length(children))",
+        )
+    if name == "map" && length(children) == 1 && children[1] isa AbstractDict
+        entries = children[1]
+        entrytype = get(entries, "type", nothing)
+        get(entrytype isa AbstractDict ? entrytype : Dict(), "name", nothing) == "struct" ||
+            _shapediff!(diffs, "$path.children[1].type", "map entries must be a struct")
+        entrychildren = get(entries, "children", Any[])
+        entrychildren isa AbstractVector && length(entrychildren) == 2 || _shapediff!(
+            diffs,
+            "$path.children[1].children",
+            "map entries struct must have key and value children",
+        )
+    end
+    return
+end
+
+function _validatefield!(
+    field,
+    path::String,
+    dictionaries::Dict{Int64,Tuple{Any,String}},
+    diffs::Vector{String},
+)
+    if !(field isa AbstractDict)
+        _shapediff!(diffs, path, "expected object, got $(_jsonkind(field))")
+        return
+    end
+    _requireproperty!(field, "name", x -> x isa AbstractString, "string", path, diffs)
+    _requireproperty!(field, "nullable", x -> x isa Bool, "Bool", path, diffs)
+    if _requireproperty!(field, "type", x -> x isa AbstractDict, "object", path, diffs)
+        _validatejsontype!(field["type"], "$path.type", diffs)
+    end
+    _validatemetadata!(field, path, diffs)
+
+    children = get(field, "children", Any[])
+    if !(children isa AbstractVector)
+        _shapediff!(diffs, "$path.children", "expected array, got $(_jsonkind(children))")
+        children = Any[]
+    end
+    _validatefieldarity!(field, children, path, diffs)
+    for (index, child) in enumerate(children)
+        _validatefield!(child, "$path.children[$index]", dictionaries, diffs)
+    end
+
+    haskey(field, "dictionary") || return
+    dictionary = field["dictionary"]
+    if !(dictionary isa AbstractDict)
+        _shapediff!(
+            diffs,
+            "$path.dictionary",
+            "expected object, got $(_jsonkind(dictionary))",
+        )
+        return
+    end
+    idok = _requireproperty!(
+        dictionary,
+        "id",
+        _isjsoninteger,
+        "integer",
+        "$path.dictionary",
+        diffs,
+    )
+    if _requireproperty!(
+        dictionary,
+        "indexType",
+        x -> x isa AbstractDict,
+        "object",
+        "$path.dictionary",
+        diffs,
+    )
+        indextype = dictionary["indexType"]
+        _validatejsontype!(indextype, "$path.dictionary.indexType", diffs)
+        get(indextype, "name", nothing) == "int" || _shapediff!(
+            diffs,
+            "$path.dictionary.indexType.name",
+            "dictionary index type must be int",
+        )
+    end
+    _requireproperty!(
+        dictionary,
+        "isOrdered",
+        x -> x isa Bool,
+        "Bool",
+        "$path.dictionary",
+        diffs,
+    )
+    idok || return
+    id = try
+        Int64(dictionary["id"])
+    catch
+        _shapediff!(diffs, "$path.dictionary.id", "integer is outside Int64 range")
+        return
+    end
+    get!(dictionaries, id, (field, path))
+    return
+end
+
+const _COLUMN_ARRAY_PROPERTIES = ("DATA", "OFFSET", "SIZE", "TYPE_ID", "VIEWS")
+const _DATA_TYPES = Set((
+    "bool",
+    "int",
+    "floatingpoint",
+    "decimal",
+    "date",
+    "time",
+    "timestamp",
+    "duration",
+    "interval",
+    "fixedsizebinary",
+))
+
+function _validatearraylength!(
+    column::AbstractDict,
+    key::String,
+    expected::Int,
+    path::String,
+    diffs::Vector{String};
+    required::Bool=true,
+)
+    if !haskey(column, key)
+        required && _shapediff!(diffs, "$path.$key", "missing required array")
+        return
+    end
+    values = column[key]
+    if !(values isa AbstractVector)
+        _shapediff!(diffs, "$path.$key", "expected array, got $(_jsonkind(values))")
+        return
+    end
+    length(values) == expected || _shapediff!(
+        diffs,
+        "$path.$key",
+        "expected $expected entries from count, got $(length(values))",
+    )
+    return
+end
+
+function _validatecolumnarrays!(
+    field::AbstractDict,
+    column::AbstractDict,
+    count,
+    path::String,
+    diffs::Vector{String};
+    dictionaryvalue::Bool=false,
+)
+    count isa Integer || return
+    count < 0 && (_shapediff!(diffs, "$path.count", "must be non-negative"); return)
+    n = try
+        Int(count)
+    catch
+        _shapediff!(diffs, "$path.count", "integer is outside Int range")
+        return
+    end
+    if haskey(column, "VALIDITY")
+        _validatearraylength!(column, "VALIDITY", n, path, diffs)
+    end
+
+    type = get(field, "type", nothing)
+    type isa AbstractDict || return
+    name =
+        !dictionaryvalue && haskey(field, "dictionary") ? "dictionary" :
+        get(type, "name", nothing)
+    name isa AbstractString || return
+    lengths = Dict{String,Int}()
+    if name == "dictionary" || name in _DATA_TYPES
+        lengths["DATA"] = n
+    elseif name in ("utf8", "largeutf8", "binary", "largebinary")
+        lengths["DATA"] = n
+        lengths["OFFSET"] = n + 1
+    elseif name in ("utf8view", "binaryview")
+        lengths["VIEWS"] = n
+        if haskey(column, "VARIADIC_DATA_BUFFERS") &&
+           !(column["VARIADIC_DATA_BUFFERS"] isa AbstractVector)
+            _shapediff!(
+                diffs,
+                "$path.VARIADIC_DATA_BUFFERS",
+                "expected array, got $(_jsonkind(column["VARIADIC_DATA_BUFFERS"]))",
+            )
+        end
+    elseif name in ("list", "largelist", "map")
+        lengths["OFFSET"] = n + 1
+    elseif name in ("listview", "largelistview")
+        lengths["OFFSET"] = n
+        lengths["SIZE"] = n
+    elseif name == "union"
+        lengths["TYPE_ID"] = n
+        get(type, "mode", nothing) == "DENSE" && (lengths["OFFSET"] = n)
+    end
+    for (key, expected) in lengths
+        _validatearraylength!(column, key, expected, path, diffs)
+    end
+    for key in _COLUMN_ARRAY_PROPERTIES
+        haskey(column, key) &&
+            !haskey(lengths, key) &&
+            _shapediff!(diffs, "$path.$key", "unexpected array for $name")
+    end
+    if name != "utf8view" && name != "binaryview" && haskey(column, "VARIADIC_DATA_BUFFERS")
+        _shapediff!(diffs, "$path.VARIADIC_DATA_BUFFERS", "unexpected array for $name")
+    end
+    return
+end
+
+function _validatecolumn!(
+    field::AbstractDict,
+    column,
+    path::String,
+    diffs::Vector{String};
+    checkname::Bool=true,
+    dictionaryvalue::Bool=false,
+)
+    if !(column isa AbstractDict)
+        _shapediff!(diffs, path, "expected object, got $(_jsonkind(column))")
+        return nothing
+    end
+    nameok =
+        _requireproperty!(column, "name", x -> x isa AbstractString, "string", path, diffs)
+    fieldname = get(field, "name", nothing)
+    if checkname && nameok && fieldname isa AbstractString && fieldname != column["name"]
+        _shapediff!(
+            diffs,
+            "$path.name",
+            "$(repr(column["name"])) does not match schema field $(repr(fieldname))",
+        )
+    end
+    countok = _requireproperty!(column, "count", _isjsoninteger, "integer", path, diffs)
+    countok &&
+        _validatecolumnarrays!(field, column, column["count"], path, diffs; dictionaryvalue)
+    children = get(column, "children", Any[])
+    if !(children isa AbstractVector)
+        _shapediff!(diffs, "$path.children", "expected array, got $(_jsonkind(children))")
+        children = Any[]
+    end
+    fieldchildren =
+        !dictionaryvalue && haskey(field, "dictionary") ? Any[] :
+        get(field, "children", Any[])
+    if fieldchildren isa AbstractVector
+        length(children) == length(fieldchildren) || _shapediff!(
+            diffs,
+            "$path.children",
+            "expected $(length(fieldchildren)) child columns, got $(length(children))",
+        )
+        for index = 1:min(length(children), length(fieldchildren))
+            childfield = fieldchildren[index]
+            childfield isa AbstractDict || continue
+            _validatecolumn!(childfield, children[index], "$path.children[$index]", diffs)
+        end
+    end
+    return countok ? column["count"] : nothing
+end
+
+function _validatedocument!(document, path::String, diffs::Vector{String})
+    if !(document isa AbstractDict)
+        _shapediff!(diffs, path, "expected object, got $(_jsonkind(document))")
+        return
+    end
+    if !_requireproperty!(
+        document,
+        "schema",
+        x -> x isa AbstractDict,
+        "object",
+        path,
+        diffs,
+    )
+        return
+    end
+    schema = document["schema"]
+    _validatemetadata!(schema, "$path.schema", diffs)
+    if !_requireproperty!(
+        schema,
+        "fields",
+        x -> x isa AbstractVector,
+        "array",
+        "$path.schema",
+        diffs,
+    )
+        return
+    end
+    fields = schema["fields"]
+    dictionaryfields = Dict{Int64,Tuple{Any,String}}()
+    for (index, field) in enumerate(fields)
+        _validatefield!(field, "$path.schema.fields[$index]", dictionaryfields, diffs)
+    end
+
+    if _requireproperty!(
+        document,
+        "batches",
+        x -> x isa AbstractVector,
+        "array",
+        path,
+        diffs,
+    )
+        for (batchindex, batch) in enumerate(document["batches"])
+            batchpath = "$path.batches[$batchindex]"
+            if !(batch isa AbstractDict)
+                _shapediff!(diffs, batchpath, "expected object, got $(_jsonkind(batch))")
+                continue
+            end
+            countok = _requireproperty!(
+                batch,
+                "count",
+                _isjsoninteger,
+                "integer",
+                batchpath,
+                diffs,
+            )
+            if !_requireproperty!(
+                batch,
+                "columns",
+                x -> x isa AbstractVector,
+                "array",
+                batchpath,
+                diffs,
+            )
+                continue
+            end
+            columns = batch["columns"]
+            length(columns) == length(fields) || _shapediff!(
+                diffs,
+                "$batchpath.columns",
+                "expected $(length(fields)) columns, got $(length(columns))",
+            )
+            for index = 1:min(length(columns), length(fields))
+                field = fields[index]
+                field isa AbstractDict || continue
+                columncount = _validatecolumn!(
+                    field,
+                    columns[index],
+                    "$batchpath.columns[$index]",
+                    diffs,
+                )
+                if countok && columncount !== nothing && columncount != batch["count"]
+                    _shapediff!(
+                        diffs,
+                        "$batchpath.columns[$index].count",
+                        "$columncount does not match batch count $(batch["count"])",
+                    )
+                end
+            end
+        end
+    end
+
+    entries = get(document, "dictionaries", Any[])
+    if !(entries isa AbstractVector)
+        _shapediff!(
+            diffs,
+            "$path.dictionaries",
+            "expected array, got $(_jsonkind(entries))",
+        )
+        return
+    end
+    seen = Set{Int64}()
+    for (entryindex, entry) in enumerate(entries)
+        entrypath = "$path.dictionaries[$entryindex]"
+        if !(entry isa AbstractDict)
+            _shapediff!(diffs, entrypath, "expected object, got $(_jsonkind(entry))")
+            continue
+        end
+        idok = _requireproperty!(entry, "id", _isjsoninteger, "integer", entrypath, diffs)
+        dataok = _requireproperty!(
+            entry,
+            "data",
+            x -> x isa AbstractDict,
+            "object",
+            entrypath,
+            diffs,
+        )
+        (idok && dataok) || continue
+        id = try
+            Int64(entry["id"])
+        catch
+            _shapediff!(diffs, "$entrypath.id", "integer is outside Int64 range")
+            continue
+        end
+        id in seen && _shapediff!(diffs, "$entrypath.id", "duplicate dictionary id $id")
+        push!(seen, id)
+        if !haskey(dictionaryfields, id)
+            _shapediff!(
+                diffs,
+                "$entrypath.id",
+                "dictionary id $id is not used by the schema",
+            )
+            continue
+        end
+        data = entry["data"]
+        countok = _requireproperty!(
+            data,
+            "count",
+            _isjsoninteger,
+            "integer",
+            "$entrypath.data",
+            diffs,
+        )
+        if !_requireproperty!(
+            data,
+            "columns",
+            x -> x isa AbstractVector,
+            "array",
+            "$entrypath.data",
+            diffs,
+        )
+            continue
+        end
+        columns = data["columns"]
+        length(columns) == 1 || _shapediff!(
+            diffs,
+            "$entrypath.data.columns",
+            "expected one dictionary value column, got $(length(columns))",
+        )
+        isempty(columns) && continue
+        field, _ = dictionaryfields[id]
+        columncount = _validatecolumn!(
+            field,
+            columns[1],
+            "$entrypath.data.columns[1]",
+            diffs;
+            checkname=false,
+            dictionaryvalue=true,
+        )
+        if countok && columncount !== nothing && columncount != data["count"]
+            _shapediff!(
+                diffs,
+                "$entrypath.data.columns[1].count",
+                "$columncount does not match dictionary batch count $(data["count"])",
+            )
+        end
+    end
+    for (id, (_, fieldpath)) in dictionaryfields
+        id in seen || _shapediff!(
+            diffs,
+            "$fieldpath.dictionary.id",
+            "dictionary id $id has no value batch",
+        )
+    end
+    return
+end
+
+function _eq(a, b, path::String, diffs::Vector{String}; strict::Bool=false)
+    if a isa _PublicUnion || b isa _PublicUnion
+        if !(a isa _PublicUnion && b isa _PublicUnion)
+            push!(diffs, "$path: Union value vs non-Union value")
+        elseif a.typeid != b.typeid
+            push!(diffs, "$path: Union type id $(a.typeid) vs $(b.typeid)")
+        else
+            _eq(a.value, b.value, path * ".value", diffs; strict)
+        end
+    elseif a isa AbstractDict && b isa AbstractDict
+        ka, kb = Set(keys(a)), Set(keys(b))
+        for k in union(ka, kb)
+            childpath = path * "." * String(k)
+            if !haskey(a, k)
+                push!(diffs, "$childpath: missing from actual document")
+            elseif !haskey(b, k)
+                push!(diffs, "$childpath: missing from expected document")
+            else
+                _eq(a[k], b[k], childpath, diffs; strict)
+            end
+            length(diffs) > 20 && return
+        end
+    elseif a isa AbstractVector && b isa AbstractVector
+        length(a) == length(b) ||
+            (push!(diffs, "$path: length $(length(a)) vs $(length(b))"); return)
+        for (i, (x, y)) in enumerate(zip(a, b))
+            _eq(x, y, path * "[$i]", diffs; strict)
+            length(diffs) > 20 && return
+        end
+    elseif strict
+        equal =
+            a isa Bool || b isa Bool ? (a isa Bool && b isa Bool && a == b) :
+            _isjsoninteger(a) || _isjsoninteger(b) ?
+            (_isjsoninteger(a) && _isjsoninteger(b) && a == b) :
+            a isa AbstractFloat || b isa AbstractFloat ?
+            (a isa AbstractFloat && b isa AbstractFloat && isequal(a, b)) : isequal(a, b)
+        equal || push!(
+            diffs,
+            "$path: $(repr(a)) ($(_jsonkind(a))) vs $(repr(b)) ($(_jsonkind(b)))",
+        )
+    elseif a isa AbstractFloat || b isa AbstractFloat
+        # EXACT equality (± zero unified, NaN equal): a tolerance here would
+        # bless changed values. Core materialization has already canonicalized
+        # sub-double columns through their declared physical precision.
+        equal =
+            a isa AbstractFloat && b isa AbstractFloat && ((isnan(a) && isnan(b)) || a == b)
+        equal || push!(diffs, "$path: $(repr(a)) vs $(repr(b))")
+    elseif a isa Bool || b isa Bool
+        (a isa Bool && b isa Bool && a == b) ||
+            push!(diffs, "$path: $(repr(a)) vs $(repr(b))")
+    elseif a isa Integer || b isa Integer
+        (a isa Integer && b isa Integer && Int128(a) == Int128(b)) ||
+            push!(diffs, "$path: $(repr(a)) vs $(repr(b))")
+    else
+        isequal(a, b) || push!(diffs, "$path: $(repr(a)) vs $(repr(b))")
+    end
+    return
+end
+
+# Dictionary ids are adapter bookkeeping, and the gold corpus is not id-stable
+# across its own representations. Canonicalize ids by dictionary-typed field
+# position. `_logicaldocument` rebuilds the pools in the same traversal order.
+function _normalizedictionaryids!(fields)
+    nextid = Ref(0)
+    function renumber!(f)
+        f isa AbstractDict || return
+        if get(f, "dictionary", nothing) isa AbstractDict
+            f["dictionary"]["id"] = nextid[]
+            nextid[] += 1
+        end
+        foreach(renumber!, get(f, "children", Any[]))
+    end
+    foreach(renumber!, fields)
+    return fields
+end
+
+# Map entries-struct names are not round-trip stable in the corpus itself.
+# Compare map children structurally by position.
+function _normalizemapschema!(fields)
+    for field in fields
+        field isa AbstractDict || continue
+        if get(get(field, "type", Dict()), "name", "") == "map" && haskey(field, "children")
+            for child in field["children"]
+                child["name"] = "entries"
+                for (index, keyvalue) in enumerate(get(child, "children", Any[]))
+                    keyvalue["name"] = index == 1 ? "key" : "value"
+                end
+            end
+        end
+        haskey(field, "children") && _normalizemapschema!(field["children"])
+    end
+    return
+end
+
+function _normalizemetadata!(value)
+    if value isa AbstractDict
+        if haskey(value, "metadata")
+            metadata = value["metadata"]
+            if metadata === nothing || (metadata isa AbstractVector && isempty(metadata))
+                delete!(value, "metadata")
+            elseif metadata isa AbstractVector
+                value["metadata"] = sort(
+                    metadata;
+                    by=keyvalue -> (String(keyvalue["key"]), String(keyvalue["value"])),
+                )
+            end
+        end
+        foreach(_normalizemetadata!, values(value))
+    elseif value isa AbstractVector
+        foreach(_normalizemetadata!, value)
+    end
+    return value
+end
+
+# Decimal bitWidth is optional with a default of 128 in integration JSON.
+function _normalizedecimals!(value)
+    if value isa AbstractDict
+        if get(value, "name", "") == "decimal" && haskey(value, "precision")
+            width = get(value, "bitWidth", 128)
+            _isjsoninteger(width) && width == 128 && delete!(value, "bitWidth")
+        end
+        foreach(_normalizedecimals!, values(value))
+    elseif value isa AbstractVector
+        foreach(_normalizedecimals!, value)
+    end
+    return value
+end
+
+# Normalize only the schema. `_logicaldocument` replaces the raw batch and
+# dictionary envelopes after it materializes their storage-domain values.
+function _normalize!(doc::AbstractDict)
+    schema = get(doc, "schema", Dict())
+    fields = get(schema, "fields", Any[])
+    _normalizedictionaryids!(fields)
+    _normalizemapschema!(fields)
+    _normalizemetadata!(schema)
+    _normalizedecimals!(schema)
+    return doc
+end
+
+_publicvalue(::Missing) = nothing
+_publicvalue(value::Pair) = Any[_publicvalue(first(value)), _publicvalue(last(value))]
+_publicvalue(value::NamedTuple) =
+    Any[Any[String(name), _publicvalue(item)] for (name, item) in pairs(value)]
+_publicvalue(value::Tuple) = Any[_publicvalue(item) for item in value]
+_publicvalue(value::AbstractVector) = Any[_publicvalue(item) for item in value]
+_publicvalue(value) = value
+
+_typecontainsunion(::AC.ArrowType) = false
+_typecontainsunion(::AC.UnionType) = true
+_typecontainsunion(type::AC.DictionaryType) = _typecontainsunion(type.valuetype)
+_fieldcontainsunion(field) =
+    _typecontainsunion(field.type) || any(_fieldcontainsunion, field.children)
+
+# Core's ordinary materializer intentionally exposes only the selected Union
+# child's Julia value. Conformance comparison additionally needs the selected
+# Arrow type id. Walk only fields that contain a Union, preserving that id at
+# every depth while applying the same logical masking rules as Core: storage
+# below a null parent does not participate in the value.
+function _publicvalueat(field, data, index::Int64)
+    1 <= index <= data.len || throw(BoundsError(data, index))
+    type = data.type
+
+    if type isa AC.UnionType
+        typeid =
+            AC.loadat(AC.rolebuffer(data, AC.TYPE_IDS), Int8, AC._slotindex0(data, index))
+        childfield, childdata, childindex = AC._union_child(field, data, index)
+        return _PublicUnion(typeid, _publicvalueat(childfield, childdata, childindex))
+    elseif type isa AC.RunEndEncodedType
+        run = AC._ree_runindex(data, index)
+        return _publicvalueat(field.children[2], data.children[2], run)
+    elseif type isa AC.NullType
+        return nothing
+    end
+
+    AC.isvalid_at(data, index) || return nothing
+
+    if type isa AC.DictionaryType
+        width = AC.primwidth(type.indextype)
+        dictionaryindex = AC._load_int(
+            AC.rolebuffer(data, AC.DATA),
+            type.indextype,
+            AC._slotbyteoff(data, index, width),
+        )
+        dictionary = data.dictionary
+        dictionary === nothing &&
+            throw(AC.ValidationError("dictionary-encoded array without a dictionary"))
+        valuefield = AC.dictvaluefield(field, type)
+        return _publicvalueat(
+            valuefield,
+            dictionary,
+            AC.checked_add(Int64(dictionaryindex), Int64(1)),
+        )
+    elseif type isa AC.ListType
+        low, high = AC._offsets_at(data, index, type.large)
+        childfield, childdata = field.children[1], data.children[1]
+        values = Vector{Any}(undef, Int(high - low))
+        for item = 1:length(values)
+            values[item] =
+                _publicvalueat(childfield, childdata, AC.checked_add(low, Int64(item)))
+        end
+        return values
+    elseif type isa AC.FixedSizeListType
+        childfield, childdata = field.children[1], data.children[1]
+        base = AC.checked_mul(AC._slotindex0(data, index), Int64(type.listsize))
+        values = Vector{Any}(undef, type.listsize)
+        for item = 1:(type.listsize)
+            values[item] =
+                _publicvalueat(childfield, childdata, AC.checked_add(base, Int64(item)))
+        end
+        return values
+    elseif type isa AC.StructType
+        childindex = AC.checked_add(data.offset, index)
+        return Any[
+            Any[String(childfield.name), _publicvalueat(childfield, childdata, childindex)]
+            for (childfield, childdata) in zip(field.children, data.children)
+        ]
+    elseif type isa AC.MapType
+        low, high = AC._offsets_at(data, index, false)
+        entriesfield, entriesdata = field.children[1], data.children[1]
+        keyfield, valuefield = entriesfield.children
+        keydata, valuedata = entriesdata.children
+        values = Vector{Any}(undef, Int(high - low))
+        for item = 1:length(values)
+            entryindex =
+                AC.checked_add(entriesdata.offset, AC.checked_add(low, Int64(item)))
+            values[item] = Any[
+                _publicvalueat(keyfield, keydata, entryindex),
+                _publicvalueat(valuefield, valuedata, entryindex),
+            ]
+        end
+        return values
+    elseif type isa AC.ListViewType
+        offset, size = AC._listview_range(type, data, index)
+        childfield, childdata = field.children[1], data.children[1]
+        values = Vector{Any}(undef, Int(size))
+        for item = 1:length(values)
+            values[item] =
+                _publicvalueat(childfield, childdata, AC.checked_add(offset, Int64(item)))
+        end
+        return values
+    end
+
+    return _publicvalue(AC.getvalue(field, data, index))
+end
+
+function _logicalcolumn(field, data; name=field.name)
+    values = if _fieldcontainsunion(field)
+        Any[_publicvalueat(field, data, Int64(index)) for index = 1:(data.len)]
+    else
+        Any[_publicvalue(value) for value in AC.materialize(field, data)]
+    end
+    return Dict{String,Any}(
+        "name" => String(name),
+        "count" => Int(data.len),
+        "VALUES" => values,
+    )
+end
+
+function _logicaldictionaries(fields, dictids, dictionaries)
+    result = Any[]
+    function visit(field)
+        if field.type isa AC.DictionaryType
+            id = length(result)
+            values = dictionaries[dictids[field]]
+            valuefield = AC.dictvaluefield(field, field.type)
+            push!(
+                result,
+                Dict{String,Any}(
+                    "id" => id,
+                    "data" => Dict{String,Any}(
+                        "count" => Int(values.len),
+                        "columns" =>
+                            Any[_logicalcolumn(valuefield, values; name="DICT")],
+                    ),
+                ),
+            )
+        end
+        foreach(visit, field.children)
+        return
+    end
+    foreach(visit, fields)
+    return result
+end
+
+# Integration JSON exposes physical buffers, but every conformance route is a
+# value comparison. Materializing through Core gives one canonical form for
+# primitive and nested values. In particular, a null List or Map may own an
+# arbitrary non-empty child segment, and a null Struct or FixedSizeList hides
+# the corresponding child slots. A recursive DATA mask cannot normalize those
+# legal layouts because their child lengths and offsets can differ.
+function _logicaldocument(doc::AbstractDict, normalized::AbstractDict)
+    schema, batches, dictids, dictionaries = ArrowJSON._fromjson(doc)
+    result = normalized
+    result["batches"] = Any[
+        Dict{String,Any}(
+            "count" => Int(batch.nrows),
+            "columns" => Any[
+                _logicalcolumn(field, data) for
+                (field, data) in zip(schema.fields, batch.columns)
+            ],
+        ) for batch in batches
+    ]
+    pools = _logicaldictionaries(schema.fields, dictids, dictionaries)
+    if isempty(pools)
+        delete!(result, "dictionaries")
+    else
+        result["dictionaries"] = pools
+    end
+    return result
+end
+
+function _normalizedschema(schema)
+    rendered = ArrowJSON.tojson(schema, AC.RecordBatch[])["schema"]
+    _normalizemapschema!(get(rendered, "fields", Any[]))
+    _normalizemetadata!(rendered)
+    _normalizedecimals!(rendered)
+    return rendered
+end
+
+function _logicalwindow(field, data, offset::Int, rows::Int)
+    if _fieldcontainsunion(field)
+        return Any[_publicvalueat(field, data, Int64(offset + index)) for index = 1:rows]
+    end
+    return Any[_publicvalue(AC.getvalue(field, data, offset + index)) for index = 1:rows]
+end
+
+"""
+Compare two Core record-batch row windows by schema and normalized values.
+
+This is the canonical comparison for nonzero-offset C Data slices. Rendering
+such an array as standalone integration JSON loses its physical base offset;
+for nested arrays it can also expose child rows outside the logical window.
+The actual and expected offsets are zero-based row offsets within each batch.
+"""
+function corebatchdiffs(
+    actual,
+    expected;
+    actualoffset::Integer=0,
+    expectedoffset::Integer=0,
+    rows::Integer=actual.nrows - actualoffset,
+)
+    ao, eo, n = Int(actualoffset), Int(expectedoffset), Int(rows)
+    ao >= 0 || throw(ArgumentError("actual row offset must be non-negative"))
+    eo >= 0 || throw(ArgumentError("expected row offset must be non-negative"))
+    n >= 0 || throw(ArgumentError("row count must be non-negative"))
+    ao + n <= actual.nrows || throw(BoundsError(actual, (ao + 1):(ao + n)))
+    eo + n <= expected.nrows || throw(BoundsError(expected, (eo + 1):(eo + n)))
+
+    diffs = String[]
+    _eq(
+        _normalizedschema(actual.schema),
+        _normalizedschema(expected.schema),
+        ".schema",
+        diffs;
+        strict=true,
+    )
+    isempty(diffs) || return diffs
+    for (index, (actualfield, actualdata, expectedfield, expecteddata)) in enumerate(
+        zip(actual.schema.fields, actual.columns, expected.schema.fields, expected.columns),
+    )
+        _eq(
+            _logicalwindow(actualfield, actualdata, ao, n),
+            _logicalwindow(expectedfield, expecteddata, eo, n),
+            ".columns[$index]",
+            diffs,
+        )
+        length(diffs) > 20 && break
+    end
+    return diffs
+end
+
+"""
+Return logical-value differences between two integration-JSON documents.
+
+The operation owns schema normalization and Core materialization. It compares
+schema before materialization so a missing required schema property remains a
+precise difference instead of becoming a parser error. Callers keep their
+documents unchanged and do not depend on the comparison implementation.
+"""
+function documentdiffs(actual, expected)
+    diffs = String[]
+    _validatedocument!(actual, ".actual", diffs)
+    _validatedocument!(expected, ".expected", diffs)
+    isempty(diffs) || return diffs
+    gotnormalized = _normalize!(deepcopy(actual))
+    wantnormalized = _normalize!(deepcopy(expected))
+    _eq(
+        get(gotnormalized, "schema", nothing),
+        get(wantnormalized, "schema", nothing),
+        ".schema",
+        diffs,
+        strict=true,
+    )
+    isempty(diffs) || return diffs
+    got = _logicaldocument(actual, gotnormalized)
+    want = _logicaldocument(expected, wantnormalized)
+    _eq(got, want, "", diffs)
+    return diffs
+end
+
+const VERDICT_STATUSES = (:pass, :fail, :skip)
+
+struct Verdict
+    family::String
+    check::String
+    status::Symbol
+    detail::String
+
+    function Verdict(family, check, status::Symbol, detail="")
+        status in VERDICT_STATUSES ||
+            throw(ArgumentError("invalid conformance status: $(repr(status))"))
+        return new(String(family), String(check), status, String(detail))
+    end
+end
+
+function errorverdict(family, check, err)
+    if err isa InterruptException || err isa OutOfMemoryError
+        throw(err)
+    end
+    detail = sprint(showerror, err)
+    return Verdict(family, check, :fail, first(detail, 200))
+end
+
+"""
+Run one document producer and convert its result or error to one verdict.
+"""
+function documentcheck(producer::F, family, check, expected) where {F}
+    try
+        diffs = documentdiffs(producer(), expected)
+        return Verdict(
+            family,
+            check,
+            isempty(diffs) ? :pass : :fail,
+            isempty(diffs) ? "" : first(diffs),
+        )
+    catch err
+        return errorverdict(family, check, err)
+    end
+end
+
+function readjson(path::AbstractString)
+    bytes = read(path)
+    endswith(path, ".gz") && (bytes = transcode(GzipDecompressor, bytes))
+    return JSON.parse(String(bytes))
+end
+
+function streamdocument(bytes::Vector{UInt8})
+    stream = Arrow.readstream(bytes)
+    # Use the reader's id table so shared and nested pool ids survive.
+    return ArrowJSON.tojson(stream.schema, stream.batches; dictids=stream.fielddictids)
+end
+
+function filedocument(bytes::Vector{UInt8})
+    file = Arrow.readfile(bytes)
+    batches = AC.RecordBatch[file[i] for i = 1:length(file)]
+    return ArrowJSON.tojson(file.schema, batches; dictids=file.fielddictids)
+end
+
+function report(
+    header::AbstractString,
+    verdicts::AbstractVector{Verdict};
+    io::IO=stdout,
+    checkwidth::Integer=24,
+)
+    isempty(verdicts) && throw(
+        ArgumentError("$header produced no conformance verdicts; refusing an empty pass"),
+    )
+    npass = count(v -> v.status == :pass, verdicts)
+    nfail = count(v -> v.status == :fail, verdicts)
+    nskip = count(v -> v.status == :skip, verdicts)
+    println(io, "$header: $npass pass, $nfail fail, $nskip skip")
+    println(io)
+    for item in verdicts
+        item.status == :pass && continue
+        tag = item.status == :fail ? "FAIL" : "skip"
+        println(
+            io,
+            rpad(tag, 5),
+            rpad(item.family, 58),
+            rpad(item.check, checkwidth),
+            item.detail,
+        )
+    end
+    return nfail
+end
+
+end # module ConformanceSupport
diff --git a/conformance/Dockerfile b/conformance/Dockerfile
new file mode 100644
index 00000000..eb47c165
--- /dev/null
+++ b/conformance/Dockerfile
@@ -0,0 +1,95 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The Arrow.jl conformance image: everything the conformance suites need,
+# in one container, so that "docker present" is the only host requirement.
+#
+#   * Julia (the base image) — the suites run IN the container, because the
+#     C data and C stream interfaces hand pointers across an in-process
+#     boundary; only IPC bytes could cross a container boundary.
+#   * A Python with pyarrow and nanoarrow — the oracles. PythonCall binds to
+#     it (JULIA_PYTHONCALL_EXE; the CondaPkg backend is disabled).
+#   * The apache/arrow-testing gold corpus.
+#   * A warm Julia depot with the registered dependencies, in a named volume
+#     at run time so precompilation caches survive between runs.
+#
+# The repository is bind-mounted at /work at run time (never copied in), so
+# the image is independent of the source tree; conformance/run.jl builds it
+# once and drives it. Build context: the conformance/ directory.
+#
+#     docker build -t arrow-julia-conformance:latest -f conformance/Dockerfile conformance/
+
+# Pinned direct tool and corpus revisions make conformance runs repeatable
+# against those inputs. The base-image digest, apt packages, and transitive
+# Julia/Python dependencies are not fully locked. The package itself supports
+# Julia 1.10 and later; Julia 1.12 is also the trim-test floor.
+FROM julia:1.12.6-bookworm
+
+ARG PIP_VERSION=26.2.1
+ARG PYARROW_VERSION=25.0.1
+ARG NANOARROW_VERSION=0.9.0
+ARG ARROW_TESTING_REV=9ff285c88565f0f6abc855918c6a342e70e4909c
+
+# python3-dev brings the shared libpython that PythonCall embeds; Debian's
+# interpreter binary is statically linked and does not ship it otherwise.
+RUN apt-get update \
+ && apt-get install -y --no-install-recommends python3 python3-venv python3-dev git ca-certificates \
+ && rm -rf /var/lib/apt/lists/*
+
+# The oracle interpreter. A venv keeps the Debian system Python untouched.
+RUN python3 -m venv /opt/pyarrow \
+ && /opt/pyarrow/bin/pip install --no-cache-dir "pip==${PIP_VERSION}" \
+ && /opt/pyarrow/bin/pip install --no-cache-dir \
+      "pyarrow==${PYARROW_VERSION}" "nanoarrow==${NANOARROW_VERSION}"
+
+RUN git init /opt/arrow-testing \
+ && git -C /opt/arrow-testing remote add origin https://github.com/apache/arrow-testing.git \
+ && git -C /opt/arrow-testing fetch --depth 1 origin "${ARROW_TESTING_REV}" \
+ && git -C /opt/arrow-testing checkout --detach FETCH_HEAD
+
+ENV ARROW_TESTING_DIR=/opt/arrow-testing \
+    ARROW_ORACLE_PYTHON=/opt/pyarrow/bin/python \
+    ARROW_CDATA_ORACLE_PYTHON=/opt/pyarrow/bin/python \
+    JULIA_PYTHONCALL_EXE=/opt/pyarrow/bin/python \
+    JULIA_CONDAPKG_BACKEND=Null \
+    JULIA_DEPOT_PATH=/opt/julia-depot \
+    JULIA_PROJECT=/opt/env
+# JULIA_PROJECT serves interactive `docker exec ... julia`; the driver passes
+# --project explicitly.
+
+# Warm the depot: every registered dependency the package and the conformance
+# environment resolve to (keep in step with Project.toml and
+# conformance/Project.toml — the run-time instantiate is authoritative and
+# fetches any delta), plus PythonCall precompiled against the oracle Python.
+RUN julia -e 'using Pkg; Pkg.activate("/opt/warm"); \
+    Pkg.add([PackageSpec(name="CodecLz4", version="0.4.6"), \
+             PackageSpec(name="CodecZstd", version="0.8.7"), \
+             PackageSpec(name="DataAPI", version="1.16.0"), \
+             PackageSpec(name="EnumX", version="1.0.7"), \
+             PackageSpec(name="TranscodingStreams", version="0.11.3"), \
+             PackageSpec(name="JSON", version="1.7.1"), \
+             PackageSpec(name="CodecZlib", version="0.7.9"), \
+             PackageSpec(name="Tables", version="1.14.0"), \
+             PackageSpec(name="PythonCall", version="0.9.35")]); \
+    Pkg.precompile()'
+
+# The suite environment is created from the mounted repository's
+# conformance/Project.toml by conformance/run.jl (developing /work into it),
+# so a Manifest never lives in the repository checkout.
+RUN mkdir -p /opt/env /work
+WORKDIR /work
+# The driver keeps its container alive the same way.
+CMD ["sleep", "infinity"]
diff --git a/conformance/Project.toml b/conformance/Project.toml
new file mode 100644
index 00000000..c94a7eea
--- /dev/null
+++ b/conformance/Project.toml
@@ -0,0 +1,44 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+[deps]
+Arrow = "69666777-d1a9-59fb-9406-91d4454c9d45"
+DataStrings = "48204bd6-5611-42ea-b167-fc1d713f9be2"
+ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd"
+CodecLz4 = "5ba52731-8f18-5e0d-9241-30f10d1ec561"
+CodecZlib = "944b1d66-785c-5afd-91f1-9de20f533193"
+CodecZstd = "6b39b394-51ab-5f42-8807-6242bab2b4c2"
+DataAPI = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
+EnumX = "4e289a0a-7415-4d19-859d-a7e5c4648b56"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d"
+Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
+TranscodingStreams = "3bb67fe8-82b1-5028-8e26-92a6c54297fa"
+
+[compat]
+DataStrings = "=1.0.0"
+ArrowTypes = "=2.4.0"
+CodecLz4 = "=0.4.6"
+CodecZlib = "=0.7.9"
+CodecZstd = "=0.8.7"
+DataAPI = "=1.16.0"
+EnumX = "=1.0.7"
+JSON = "=1.7.1"
+PythonCall = "=0.9.35"
+Tables = "=1.14.0"
+TranscodingStreams = "=0.11.3"
+julia = "1.12.6"
diff --git a/conformance/arrowjson.jl b/conformance/arrowjson.jl
new file mode 100644
index 00000000..2ebad812
--- /dev/null
+++ b/conformance/arrowjson.jl
@@ -0,0 +1,801 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# Arrow integration JSON ("arrowjson") <-> ArrowCore.
+#
+# The integration JSON format is the cross-implementation conformance
+# interchange used by apache/arrow-testing gold files and by archery. This
+# module maps it to and from Core `Schema`/`RecordBatch` values so the corpus
+# can be tested in every direction (JSON -> Core -> IPC vs gold bytes; gold
+# IPC -> Core -> JSON vs gold JSON) and so our own writer output can be
+# expressed as JSON for third-party consumers.
+#
+# Value conventions, pinned from real gold files (arrow-testing
+# 1.0.0-littleendian and cpp-21.0.0):
+#   * every batch column: {name, count, VALIDITY?, DATA?/OFFSET?/... , children?}
+#   * VALIDITY is 0/1 ints; DATA for 8..32-bit ints, floats, bool are JSON
+#     scalars; 64-bit ints, decimals, large offsets/sizes are STRINGS
+#   * binary/fixedsizebinary/large binary DATA are UPPERCASE HEX strings
+#   * views: VIEWS entries {SIZE, INLINED} (hex for binary, utf8 for strings)
+#     or {SIZE, PREFIX_HEX, BUFFER_INDEX, OFFSET}, plus VARIADIC_DATA_BUFFERS
+#     as hex strings
+#   * list-view: OFFSET + SIZE per slot (strings when 64-bit)
+#   * REE: no buffers; children run_ends + values
+#   * unions: TYPE_ID (+ OFFSET for dense); no VALIDITY
+#   * interval MONTH_DAY_NANO: {months, days, nanoseconds} objects;
+#     DAY_TIME: {days, milliseconds}; YEAR_MONTH: ints
+#   * dictionaries: top-level `dictionaries: [{id, data: {count, columns}}]`,
+#     field carries `dictionary: {id, indexType, isOrdered}` and its `type` is
+#     the VALUE type
+#   * metadata: [{key, value}] lists on schema and fields
+# =============================================================================
+
+module ArrowJSON
+
+using JSON
+using ..ArrowCore
+const AC = ArrowCore
+
+# --- type descriptors -------------------------------------------------------
+
+_timeunit(s) =
+    s == "SECOND" ? AC.SECOND :
+    s == "MILLISECOND" ? AC.MILLISECOND :
+    s == "MICROSECOND" ? AC.MICROSECOND :
+    s == "NANOSECOND" ? AC.NANOSECOND : error("unknown time unit $s")
+_timeunitname(u) =
+    u == AC.SECOND ? "SECOND" :
+    u == AC.MILLISECOND ? "MILLISECOND" : u == AC.MICROSECOND ? "MICROSECOND" : "NANOSECOND"
+
+function fromjsontype(t::AbstractDict)::ArrowType
+    n = t["name"]
+    n == "null" && return NullType()
+    n == "bool" && return BoolType()
+    n == "int" && return IntType(Int(t["bitWidth"]), Bool(t["isSigned"]))
+    n == "floatingpoint" && return FloatType(
+        t["precision"] == "HALF" ? 16 : t["precision"] == "SINGLE" ? 32 : 64,
+    )
+    n == "utf8" && return Utf8Type(false)
+    n == "largeutf8" && return Utf8Type(true)
+    n == "binary" && return BinaryType(false)
+    n == "largebinary" && return BinaryType(true)
+    n == "utf8view" && return ViewType(true)
+    n == "binaryview" && return ViewType(false)
+    n == "fixedsizebinary" && return FixedSizeBinaryType(Int(t["byteWidth"]))
+    n == "decimal" && return DecimalType(
+        Int(t["precision"]),
+        Int(t["scale"]),
+        Int(get(t, "bitWidth", 128)),
+    )
+    n == "date" && return DateType(t["unit"] == "DAY" ? AC.DAY : AC.MILLISECOND_DATE)
+    n == "time" && return TimeType(_timeunit(t["unit"]), Int(t["bitWidth"]))
+    n == "timestamp" && return TimestampType(
+        _timeunit(t["unit"]),
+        haskey(t, "timezone") ? String(t["timezone"]) : nothing,
+    )
+    n == "duration" && return DurationType(_timeunit(t["unit"]))
+    n == "interval" && return IntervalType(
+        t["unit"] == "YEAR_MONTH" ? AC.YEAR_MONTH :
+        t["unit"] == "DAY_TIME" ? AC.DAY_TIME : AC.MONTH_DAY_NANO,
+    )
+    n == "list" && return ListType(false)
+    n == "largelist" && return ListType(true)
+    n == "listview" && return ListViewType(false)
+    n == "largelistview" && return ListViewType(true)
+    n == "fixedsizelist" && return FixedSizeListType(Int(t["listSize"]))
+    n == "struct" && return StructType()
+    n == "map" && return MapType(Bool(get(t, "keysSorted", false)))
+    n == "union" && return UnionType(
+        t["mode"] == "SPARSE" ? AC.SparseMode : AC.DenseMode,
+        Int8[Int8(x) for x in t["typeIds"]],
+    )
+    n == "runendencoded" && return RunEndEncodedType()
+    error("arrowjson: unmapped type $n")
+end
+
+function tojsontype(t::ArrowType)
+    t isa NullType && return Dict("name" => "null")
+    t isa BoolType && return Dict("name" => "bool")
+    t isa IntType &&
+        return Dict("name" => "int", "bitWidth" => t.bits, "isSigned" => t.signed)
+    t isa FloatType && return Dict(
+        "name" => "floatingpoint",
+        "precision" => t.bits == 16 ? "HALF" : t.bits == 32 ? "SINGLE" : "DOUBLE",
+    )
+    t isa Utf8Type && return Dict("name" => t.large ? "largeutf8" : "utf8")
+    t isa BinaryType && return Dict("name" => t.large ? "largebinary" : "binary")
+    t isa ViewType && return Dict("name" => t.utf8 ? "utf8view" : "binaryview")
+    t isa FixedSizeBinaryType &&
+        return Dict("name" => "fixedsizebinary", "byteWidth" => t.nbytes)
+    t isa DecimalType && return Dict(
+        "name" => "decimal",
+        "precision" => t.precision,
+        "scale" => t.scale,
+        "bitWidth" => t.bits,
+    )
+    t isa DateType &&
+        return Dict("name" => "date", "unit" => t.unit == AC.DAY ? "DAY" : "MILLISECOND")
+    t isa TimeType &&
+        return Dict("name" => "time", "unit" => _timeunitname(t.unit), "bitWidth" => t.bits)
+    if t isa TimestampType
+        d = Dict{String,Any}("name" => "timestamp", "unit" => _timeunitname(t.unit))
+        t.timezone === nothing || (d["timezone"] = t.timezone)
+        return d
+    end
+    t isa DurationType && return Dict("name" => "duration", "unit" => _timeunitname(t.unit))
+    t isa IntervalType && return Dict(
+        "name" => "interval",
+        "unit" =>
+            t.unit == AC.YEAR_MONTH ? "YEAR_MONTH" :
+            t.unit == AC.DAY_TIME ? "DAY_TIME" : "MONTH_DAY_NANO",
+    )
+    t isa ListType && return Dict("name" => t.large ? "largelist" : "list")
+    t isa ListViewType && return Dict("name" => t.large ? "largelistview" : "listview")
+    t isa FixedSizeListType &&
+        return Dict("name" => "fixedsizelist", "listSize" => t.listsize)
+    t isa StructType && return Dict("name" => "struct")
+    t isa MapType && return Dict("name" => "map", "keysSorted" => t.keyssorted)
+    t isa UnionType && return Dict(
+        "name" => "union",
+        "mode" => t.mode == AC.SparseMode ? "SPARSE" : "DENSE",
+        "typeIds" => Int.(t.typeids),
+    )
+    t isa RunEndEncodedType && return Dict("name" => "runendencoded")
+    error("arrowjson: unmapped descriptor $(AC.descriptorname(t))")
+end
+
+_metadict(m) =
+    m === nothing ? nothing :
+    Dict{String,String}(String(kv["key"]) => String(kv["value"]) for kv in m)
+_metalist(m) =
+    m === nothing ? nothing :
+    [Dict("key" => k, "value" => v) for (k, v) in sort!(collect(m); by=first)]
+
+"""
+Parse one JSON field into a Core `Field`. Dictionary-encoded fields become
+`DictionaryType(indextype, valuetype, ordered)`; the JSON id is recorded in
+`dictids` (an adapter-side table, exactly as the IPC adapter keeps ids).
+"""
+function fromjsonfield(f::AbstractDict, dictids::IdDict{Field,Int64})::Field
+    children = Field[fromjsonfield(c, dictids) for c in get(f, "children", Any[])]
+    t = fromjsontype(f["type"])
+    meta = _metadict(get(f, "metadata", nothing))
+    if haskey(f, "dictionary")
+        d = f["dictionary"]
+        idx = fromjsontype(d["indexType"])::IntType
+        cf = Field(
+            String(f["name"]),
+            DictionaryType(idx, t, Bool(get(d, "isOrdered", false)));
+            nullable=Bool(f["nullable"]),
+            metadata=meta,
+            children=children,
+        )
+        dictids[cf] = Int64(d["id"])
+        return cf
+    end
+    return Field(
+        String(f["name"]),
+        t;
+        nullable=Bool(f["nullable"]),
+        metadata=meta,
+        children=children,
+    )
+end
+
+function tojsonfield(f::Field, dictids::IdDict{Field,Int64})
+    t = f.type
+    d = Dict{String,Any}(
+        "name" => f.name,
+        "nullable" => f.nullable,
+        "children" => Any[tojsonfield(c, dictids) for c in f.children],
+    )
+    if t isa DictionaryType
+        d["type"] = tojsontype(t.valuetype)
+        d["dictionary"] = Dict(
+            "id" => dictids[f],
+            "indexType" => tojsontype(t.indextype),
+            "isOrdered" => t.ordered,
+        )
+    else
+        d["type"] = tojsontype(t)
+    end
+    f.metadata === nothing || (d["metadata"] = _metalist(f.metadata))
+    return d
+end
+
+# --- values: JSON -> buffers --------------------------------------------------
+
+_hex(bytes) = uppercase(bytes2hex(bytes))
+_unhex(s::AbstractString) = hex2bytes(s)
+_i64(x) = x isa AbstractString ? parse(Int64, x) : Int64(x)
+
+function _validity(col, n::Int)
+    v = get(col, "VALIDITY", nothing)
+    (v === nothing || n == 0) && return BufferSlice()
+    bytes = zeros(UInt8, cld(n, 8))
+    for i = 1:n
+        v[i] != 0 && (bytes[(i - 1) ÷ 8 + 1] |= UInt8(1) << ((i - 1) % 8))
+    end
+    return AC._databuffer(bytes)
+end
+
+function _bitmap(vals::AbstractVector{Bool})
+    n = length(vals)
+    bytes = zeros(UInt8, cld(n, 8))
+    for i = 1:n
+        vals[i] && (bytes[(i - 1) ÷ 8 + 1] |= UInt8(1) << ((i - 1) % 8))
+    end
+    return AC._databuffer(bytes)
+end
+
+function _intdata(t::IntType, data)
+    T =
+        t.signed ?
+        (t.bits == 8 ? Int8 : t.bits == 16 ? Int16 : t.bits == 32 ? Int32 : Int64) :
+        (t.bits == 8 ? UInt8 : t.bits == 16 ? UInt16 : t.bits == 32 ? UInt32 : UInt64)
+    vals = T[T(x isa AbstractString ? parse(T, x) : x) for x in data]
+    return AC._databuffer(vals)
+end
+
+_decimalint(s, bits) =
+    bits == 32 ? Int32(parse(Int128, s)) :
+    bits == 64 ? Int64(parse(Int128, s)) :
+    bits == 128 ? parse(Int128, s) : error("unsupported decimal width $bits")
+
+function _decimal256bytes(s::AbstractString)
+    value = parse(BigInt, s)
+    half = BigInt(1) << 255
+    -half <= value < half ||
+        throw(ArgumentError("decimal256 value is outside the signed 256-bit range: $s"))
+    unsigned = value < 0 ? value + (BigInt(1) << 256) : value
+    bytes = Vector{UInt8}(undef, 32)
+    for i = 1:32
+        bytes[i] = UInt8(unsigned & 0xff)
+        unsigned >>= 8
+    end
+    return bytes
+end
+
+function _decimal256value(bytes::AbstractVector{UInt8})
+    length(bytes) == 32 ||
+        throw(ArgumentError("a decimal256 value must contain exactly 32 bytes"))
+    value = BigInt(0)
+    for byte in Iterators.reverse(bytes)
+        value = (value << 8) | byte
+    end
+    (bytes[end] & 0x80) == 0 || (value -= BigInt(1) << 256)
+    return value
+end
+
+"""
+Build one Core `ArrayData` from a JSON column. `f` supplies the layout;
+`dicts` resolves dictionary ids to already-built pools.
+"""
+function fromjsoncolumn(
+    f::Field,
+    col::AbstractDict,
+    dicts::Dict{Int64,ArrayData},
+    dictids::IdDict{Field,Int64},
+)::ArrayData
+    t = f.type
+    n = Int(col["count"])
+    data = get(col, "DATA", nothing)
+    validity = _validity(col, n)
+    nulls =
+        get(col, "VALIDITY", nothing) === nothing ? 0 : count(==(0), col["VALIDITY"][1:n])
+    if t isa DictionaryType
+        idx = _intdata(t.indextype, data)
+        return ArrayData(
+            t,
+            n,
+            [validity, idx];
+            dictionary=dicts[dictids[f]],
+            nullcount=nulls,
+        )
+    elseif t isa NullType
+        return ArrayData(t, n, BufferSlice[]; nullcount=n)
+    elseif t isa BoolType
+        return ArrayData(
+            t,
+            n,
+            [validity, _bitmap(Bool[Bool(x) for x in data])];
+            nullcount=nulls,
+        )
+    elseif t isa IntType
+        return ArrayData(t, n, [validity, _intdata(t, data)]; nullcount=nulls)
+    elseif t isa FloatType
+        vals =
+            t.bits == 16 ? Float16[Float16(x) for x in data] :
+            t.bits == 32 ? Float32[Float32(x) for x in data] :
+            Float64[Float64(x) for x in data]
+        return ArrayData(t, n, [validity, AC._databuffer(vals)]; nullcount=nulls)
+    elseif t isa DecimalType
+        raw = if t.bits == 256
+            bytes = UInt8[]
+            sizehint!(bytes, 32 * length(data))
+            for value in data
+                append!(bytes, _decimal256bytes(String(value)))
+            end
+            bytes
+        else
+            vals = [_decimalint(String(x), t.bits) for x in data]
+            t.bits == 32 ? Int32.(vals) : t.bits == 64 ? Int64.(vals) : Int128.(vals)
+        end
+        return ArrayData(t, n, [validity, AC._databuffer(raw)]; nullcount=nulls)
+    elseif t isa DateType
+        vals =
+            t.unit == AC.DAY ? Int32[Int32(_i64(x)) for x in data] :
+            Int64[_i64(x) for x in data]
+        return ArrayData(t, n, [validity, AC._databuffer(vals)]; nullcount=nulls)
+    elseif t isa TimeType
+        vals =
+            t.bits == 32 ? Int32[Int32(_i64(x)) for x in data] :
+            Int64[_i64(x) for x in data]
+        return ArrayData(t, n, [validity, AC._databuffer(vals)]; nullcount=nulls)
+    elseif t isa TimestampType || t isa DurationType
+        return ArrayData(
+            t,
+            n,
+            [validity, AC._databuffer(Int64[_i64(x) for x in data])];
+            nullcount=nulls,
+        )
+    elseif t isa IntervalType
+        raw = if t.unit == AC.YEAR_MONTH
+            reinterpret(UInt8, Int32[Int32(_i64(x)) for x in data])
+        elseif t.unit == AC.DAY_TIME
+            reinterpret(
+                UInt8,
+                Int32[Int32(_i64(v)) for x in data for v in (x["days"], x["milliseconds"])],
+            )
+        else
+            out = UInt8[]
+            for x in data
+                append!(
+                    out,
+                    reinterpret(
+                        UInt8,
+                        Int32[Int32(_i64(x["months"])), Int32(_i64(x["days"]))],
+                    ),
+                )
+                append!(out, reinterpret(UInt8, Int64[_i64(x["nanoseconds"])]))
+            end
+            out
+        end
+        return ArrayData(
+            t,
+            n,
+            [validity, AC._databuffer(collect(UInt8, raw))];
+            nullcount=nulls,
+        )
+    elseif t isa FixedSizeBinaryType
+        bytes = UInt8[]
+        for x in data
+            b = _unhex(x)
+            length(b) == t.nbytes || error("fixedsizebinary width mismatch")
+            append!(bytes, b)
+        end
+        return ArrayData(t, n, [validity, AC._databuffer(bytes)]; nullcount=nulls)
+    elseif t isa Utf8Type || t isa BinaryType
+        offs = [_i64(x) for x in col["OFFSET"]]
+        bytes = UInt8[]
+        for x in data
+            append!(bytes, t isa Utf8Type ? codeunits(String(x)) : _unhex(x))
+        end
+        offbuf = t.large ? AC._databuffer(Int64.(offs)) : AC._databuffer(Int32.(offs))
+        return ArrayData(t, n, [validity, offbuf, AC._databuffer(bytes)]; nullcount=nulls)
+    elseif t isa ViewType
+        views = UInt8[]
+        for v in col["VIEWS"]
+            sz = Int32(v["SIZE"])
+            append!(views, reinterpret(UInt8, Int32[sz]))
+            if haskey(v, "INLINED")
+                inl =
+                    t.utf8 ? collect(codeunits(String(v["INLINED"]))) : _unhex(v["INLINED"])
+                append!(views, inl)
+                append!(views, zeros(UInt8, 12 - length(inl)))
+            else
+                append!(views, _unhex(v["PREFIX_HEX"]))
+                append!(
+                    views,
+                    reinterpret(UInt8, Int32[Int32(v["BUFFER_INDEX"]), Int32(v["OFFSET"])]),
+                )
+            end
+        end
+        bufs = BufferSlice[validity, AC._databuffer(views)]
+        for h in get(col, "VARIADIC_DATA_BUFFERS", Any[])
+            b = _unhex(h)
+            push!(bufs, isempty(b) ? BufferSlice() : AC._databuffer(b))
+        end
+        return ArrayData(t, n, bufs; nullcount=nulls)
+    elseif t isa ListType || t isa MapType
+        offs = [_i64(x) for x in col["OFFSET"]]
+        offbuf =
+            (t isa ListType && t.large) ? AC._databuffer(Int64.(offs)) :
+            AC._databuffer(Int32.(offs))
+        child = fromjsoncolumn(f.children[1], col["children"][1], dicts, dictids)
+        return ArrayData(t, n, [validity, offbuf]; children=[child], nullcount=nulls)
+    elseif t isa ListViewType
+        offs = [_i64(x) for x in col["OFFSET"]]
+        sizes = [_i64(x) for x in col["SIZE"]]
+        ob = t.large ? AC._databuffer(Int64.(offs)) : AC._databuffer(Int32.(offs))
+        sb = t.large ? AC._databuffer(Int64.(sizes)) : AC._databuffer(Int32.(sizes))
+        child = fromjsoncolumn(f.children[1], col["children"][1], dicts, dictids)
+        return ArrayData(t, n, [validity, ob, sb]; children=[child], nullcount=nulls)
+    elseif t isa FixedSizeListType
+        child = fromjsoncolumn(f.children[1], col["children"][1], dicts, dictids)
+        return ArrayData(t, n, [validity]; children=[child], nullcount=nulls)
+    elseif t isa StructType
+        children = ArrayData[
+            fromjsoncolumn(cf, cc, dicts, dictids) for
+            (cf, cc) in zip(f.children, col["children"])
+        ]
+        return ArrayData(t, n, [validity]; children=children, nullcount=nulls)
+    elseif t isa UnionType
+        ids = AC._databuffer(Int8[Int8(x) for x in col["TYPE_ID"]])
+        children = ArrayData[
+            fromjsoncolumn(cf, cc, dicts, dictids) for
+            (cf, cc) in zip(f.children, col["children"])
+        ]
+        if t.mode == AC.DenseMode
+            offs = AC._databuffer(Int32[Int32(x) for x in col["OFFSET"]])
+            return ArrayData(t, n, [ids, offs]; children=children, nullcount=0)
+        end
+        return ArrayData(t, n, [ids]; children=children, nullcount=0)
+    elseif t isa RunEndEncodedType
+        children = ArrayData[
+            fromjsoncolumn(cf, cc, dicts, dictids) for
+            (cf, cc) in zip(f.children, col["children"])
+        ]
+        return ArrayData(t, n, BufferSlice[]; children=children, nullcount=0)
+    end
+    error("arrowjson: unmapped layout $(AC.descriptorname(t))")
+end
+
+# --- values: Core -> JSON --------------------------------------------------------
+
+_validitylist(d::ArrayData) = Int[AC.isvalid_at(d, i) ? 1 : 0 for i = 1:d.len]
+
+function _rawvals(d::ArrayData, ::Type{T}) where {T}
+    b = AC.rolebuffer(d, AC.DATA)
+    return T[AC.loadat(b, T, AC._slotbyteoff(d, Int64(i), sizeof(T))) for i = 1:d.len]
+end
+
+function _offsetlist(d::ArrayData, wide::Bool)
+    b = AC.rolebuffer(d, AC.OFFSETS)
+    n = d.len
+    # A zero-length UNSLICED array may carry Core's canonical empty offsets
+    # buffer (nanoarrow and C++ write that form); the JSON column still
+    # declares the single terminal zero. A sliced empty array must carry the
+    # physical prefix its offset addresses, so it takes the loadat path (and
+    # its absence stays a visible error, not a fabricated zero).
+    b.len == 0 && n == 0 && d.offset == 0 && return wide ? Int64[0] : Int32[0]
+    if wide
+        return Int64[AC.loadat(b, Int64, (d.offset + i) * 8) for i = 0:n]
+    end
+    return Int32[AC.loadat(b, Int32, (d.offset + i) * 4) for i = 0:n]
+end
+
+"""
+Render one Core column as an integration-JSON column object. Values are
+read through raw buffers (not `getvalue`) so null slots keep their physical
+DATA — the gold files carry data under nulls and diff tools compare it.
+"""
+function tojsoncolumn(f::Field, d::ArrayData)
+    t = f.type
+    n = Int(d.len)
+    col = Dict{String,Any}("name" => f.name, "count" => n)
+    hasvalidity(t) = !(t isa NullType || t isa UnionType || t isa RunEndEncodedType)
+    hasvalidity(t) && (col["VALIDITY"] = _validitylist(d))
+    if t isa DictionaryType
+        it = t.indextype
+        col["DATA"] = _intjson(it, d)
+    elseif t isa NullType
+        # nothing
+    elseif t isa BoolType
+        b = AC.rolebuffer(d, AC.DATA)
+        col["DATA"] = Bool[AC.getbit(b, AC._slotindex0(d, Int64(i))) for i = 1:n]
+    elseif t isa IntType
+        col["DATA"] = _intjson(t, d)
+    elseif t isa FloatType
+        col["DATA"] =
+            t.bits == 16 ? Float64.(_rawvals(d, Float16)) :
+            t.bits == 32 ? _rawvals(d, Float32) : _rawvals(d, Float64)
+    elseif t isa DecimalType
+        vals = if t.bits == 256
+            buffer = AC.rolebuffer(d, AC.DATA)
+            [
+                _decimal256value(
+                    AC.slicebytes(
+                        AC.subslice(buffer, AC._slotbyteoff(d, Int64(i), 32), 32),
+                    ),
+                ) for i = 1:n
+            ]
+        else
+            t.bits == 32 ? _rawvals(d, Int32) :
+            t.bits == 64 ? _rawvals(d, Int64) : _rawvals(d, Int128)
+        end
+        col["DATA"] = string.(vals)
+    elseif t isa DateType
+        col["DATA"] = t.unit == AC.DAY ? _rawvals(d, Int32) : string.(_rawvals(d, Int64))
+    elseif t isa TimeType
+        col["DATA"] = t.bits == 32 ? _rawvals(d, Int32) : string.(_rawvals(d, Int64))
+    elseif t isa TimestampType || t isa DurationType
+        col["DATA"] = string.(_rawvals(d, Int64))
+    elseif t isa IntervalType
+        b = AC.rolebuffer(d, AC.DATA)
+        if t.unit == AC.YEAR_MONTH
+            col["DATA"] = _rawvals(d, Int32)
+        elseif t.unit == AC.DAY_TIME
+            col["DATA"] = [
+                Dict(
+                    "days" => AC.loadat(b, Int32, AC._slotbyteoff(d, Int64(i), 8)),
+                    "milliseconds" =>
+                        AC.loadat(b, Int32, AC._slotbyteoff(d, Int64(i), 8) + 4),
+                ) for i = 1:n
+            ]
+        else
+            col["DATA"] = [
+                Dict(
+                    "months" => AC.loadat(b, Int32, AC._slotbyteoff(d, Int64(i), 16)),
+                    "days" => AC.loadat(b, Int32, AC._slotbyteoff(d, Int64(i), 16) + 4),
+                    "nanoseconds" => string(
+                        AC.loadat(b, Int64, AC._slotbyteoff(d, Int64(i), 16) + 8),
+                    ),
+                ) for i = 1:n
+            ]
+        end
+    elseif t isa FixedSizeBinaryType
+        b = AC.rolebuffer(d, AC.DATA)
+        col["DATA"] = [
+            _hex(
+                AC.slicebytes(
+                    AC.subslice(b, AC._slotbyteoff(d, Int64(i), t.nbytes), t.nbytes),
+                ),
+            ) for i = 1:n
+        ]
+    elseif t isa Utf8Type || t isa BinaryType
+        offs = _offsetlist(d, t.large)
+        col["OFFSET"] = t.large ? string.(offs) : offs
+        b = AC.rolebuffer(d, AC.DATA)
+        col["DATA"] = [
+            begin
+                lo, hi = Int64(offs[i]), Int64(offs[i + 1])
+                bytes = hi > lo ? AC.slicebytes(AC.subslice(b, lo, hi - lo)) : UInt8[]
+                t isa Utf8Type ? String(bytes) : _hex(bytes)
+            end for i = 1:n
+        ]
+    elseif t isa ViewType
+        views = AC.rolebuffer(d, AC.VIEWS)
+        entries = Any[]
+        for i = 1:n
+            base = AC._viewbase(d, Int64(i))
+            sz = AC.loadat(views, Int32, base)
+            if sz <= AC.VIEW_INLINE_MAX
+                inl = AC.slicebytes(AC.subslice(views, base + 4, Int64(sz)))
+                push!(
+                    entries,
+                    Dict("SIZE" => sz, "INLINED" => t.utf8 ? String(inl) : _hex(inl)),
+                )
+            else
+                push!(
+                    entries,
+                    Dict(
+                        "SIZE" => sz,
+                        "PREFIX_HEX" =>
+                            _hex(AC.slicebytes(AC.subslice(views, base + 4, 4))),
+                        "BUFFER_INDEX" => AC.loadat(views, Int32, base + 8),
+                        "OFFSET" => AC.loadat(views, Int32, base + 12),
+                    ),
+                )
+            end
+        end
+        col["VIEWS"] = entries
+        col["VARIADIC_DATA_BUFFERS"] = [_hex(AC.slicebytes(b)) for b in d.buffers[3:end]]
+    elseif t isa ListType || t isa MapType
+        wide = t isa ListType && t.large
+        offs = _offsetlist(d, wide)
+        col["OFFSET"] = wide ? string.(offs) : offs
+        col["children"] = Any[tojsoncolumn(f.children[1], d.children[1])]
+    elseif t isa ListViewType
+        ob = AC.rolebuffer(d, AC.ELEMENT_OFFSETS)
+        sb = AC.rolebuffer(d, AC.SIZES)
+        w = t.large ? 8 : 4
+        offs = [
+            t.large ? AC.loadat(ob, Int64, AC._slotbyteoff(d, Int64(i), w)) :
+            AC.loadat(ob, Int32, AC._slotbyteoff(d, Int64(i), w)) for i = 1:n
+        ]
+        sizes = [
+            t.large ? AC.loadat(sb, Int64, AC._slotbyteoff(d, Int64(i), w)) :
+            AC.loadat(sb, Int32, AC._slotbyteoff(d, Int64(i), w)) for i = 1:n
+        ]
+        col["OFFSET"] = t.large ? string.(offs) : offs
+        col["SIZE"] = t.large ? string.(sizes) : sizes
+        col["children"] = Any[tojsoncolumn(f.children[1], d.children[1])]
+    elseif t isa FixedSizeListType || t isa StructType
+        col["children"] =
+            Any[tojsoncolumn(cf, cd) for (cf, cd) in zip(f.children, d.children)]
+    elseif t isa UnionType
+        ids = AC.rolebuffer(d, AC.TYPE_IDS)
+        col["TYPE_ID"] = Int[AC.loadat(ids, Int8, AC._slotindex0(d, Int64(i))) for i = 1:n]
+        if t.mode == AC.DenseMode
+            ob = AC.rolebuffer(d, AC.ELEMENT_OFFSETS)
+            col["OFFSET"] =
+                Int32[AC.loadat(ob, Int32, AC._slotbyteoff(d, Int64(i), 4)) for i = 1:n]
+        end
+        col["children"] =
+            Any[tojsoncolumn(cf, cd) for (cf, cd) in zip(f.children, d.children)]
+    elseif t isa RunEndEncodedType
+        col["children"] =
+            Any[tojsoncolumn(cf, cd) for (cf, cd) in zip(f.children, d.children)]
+    else
+        error("arrowjson: unmapped layout $(AC.descriptorname(t))")
+    end
+    return col
+end
+
+function _intjson(t::IntType, d::ArrayData)
+    if t.bits == 64
+        return t.signed ? string.(_rawvals(d, Int64)) : string.(_rawvals(d, UInt64))
+    end
+    return t.signed ?
+           (
+        t.bits == 8 ? _rawvals(d, Int8) :
+        t.bits == 16 ? _rawvals(d, Int16) : _rawvals(d, Int32)
+    ) :
+           (
+        t.bits == 8 ? _rawvals(d, UInt8) :
+        t.bits == 16 ? _rawvals(d, UInt16) : _rawvals(d, UInt32)
+    )
+end
+
+# --- documents ---------------------------------------------------------------------
+
+"""
+    fromjson(doc) -> (schema::Schema, batches::Vector{RecordBatch}, dictids)
+
+Parse an integration-JSON document (already `JSON.parse`d) into Core values.
+Dictionaries are built first (in id order) so batch columns can reference
+them; the returned `dictids` maps each dictionary-typed Field to its JSON id
+for writers that must preserve ids.
+"""
+function fromjson(doc::AbstractDict)
+    sch, batches, dictids, _ = _fromjson(doc)
+    return sch, batches, dictids
+end
+
+# Internal form used by the value comparator. The dictionary arrays are part
+# of the logical document even when no batch index currently references every
+# pool value, so the comparator must retain them separately from the batches.
+function _fromjson(doc::AbstractDict)
+    dictids = IdDict{Field,Int64}()
+    fields = Field[fromjsonfield(f, dictids) for f in doc["schema"]["fields"]]
+    sch = Schema(
+        fields;
+        metadata=_metadict(get(doc["schema"], "metadata", nothing)),
+        endianness=AC.LittleEndian,
+    )
+    dicts = Dict{Int64,ArrayData}()
+    # dictionaries may depend on other dictionaries (nested); resolve by
+    # repeated passes until all build
+    pending = collect(get(doc, "dictionaries", Any[]))
+    valuefield = Dict{Int64,Field}()
+    function walk(f::Field)
+        if f.type isa DictionaryType
+            valuefield[dictids[f]] = AC.dictvaluefield(f, f.type)
+        end
+        foreach(walk, f.children)
+        f.type isa DictionaryType && walk(AC.dictvaluefield(f, f.type))
+    end
+    foreach(walk, fields)
+    while !isempty(pending)
+        progressed = false
+        for (k, entry) in enumerate(pending)
+            id = Int64(entry["id"])
+            vf = valuefield[id]
+            try
+                col = entry["data"]["columns"][1]
+                dicts[id] = fromjsoncolumn(vf, col, dicts, dictids)
+                deleteat!(pending, k)
+                progressed = true
+                break
+            catch e
+                e isa KeyError || rethrow()
+            end
+        end
+        progressed || error("arrowjson: unresolvable dictionary dependencies")
+    end
+    batches = AC.RecordBatch[]
+    for b in doc["batches"]
+        cols = ArrayData[
+            fromjsoncolumn(f, c, dicts, dictids) for (f, c) in zip(fields, b["columns"])
+        ]
+        push!(batches, AC.RecordBatch(sch, cols, Int(b["count"])))
+    end
+    return sch, batches, dictids, dicts
+end
+
+"""
+    tojson(schema, batches; dictids) -> Dict
+
+Render Core values as an integration-JSON document. Dictionary pools are
+emitted once per id from the first batch that carries them (the file-format
+convention; replacement streams need per-batch dictionaries and are outside
+this writer).
+"""
+function tojson(
+    sch::Schema,
+    batches::AbstractVector{AC.RecordBatch};
+    dictids::IdDict{Field,Int64}=IdDict{Field,Int64}(),
+)
+    if isempty(dictids)
+        next = Int64(0)
+        function assign(f::Field)
+            if f.type isa DictionaryType
+                dictids[f] = next
+                next += 1
+            end
+            foreach(assign, f.children)
+        end
+        foreach(assign, sch.fields)
+    end
+    doc = Dict{String,Any}()
+    schemadoc =
+        Dict{String,Any}("fields" => Any[tojsonfield(f, dictids) for f in sch.fields])
+    sch.metadata === nothing || (schemadoc["metadata"] = _metalist(sch.metadata))
+    doc["schema"] = schemadoc
+    dictdocs = Any[]
+    seen = Set{Int64}()
+    function collectpools(f::Field, d::ArrayData)
+        if f.type isa DictionaryType
+            id = dictids[f]
+            if !(id in seen)
+                push!(seen, id)
+                vf = AC.dictvaluefield(f, f.type)
+                pool = d.dictionary::ArrayData
+                push!(
+                    dictdocs,
+                    Dict(
+                        "id" => id,
+                        "data" => Dict(
+                            "count" => Int(pool.len),
+                            "columns" => Any[tojsoncolumn(vf, pool)],
+                        ),
+                    ),
+                )
+                collectpools(vf, pool)
+            end
+            return
+        end
+        for (cf, cd) in zip(f.children, d.children)
+            collectpools(cf, cd)
+        end
+    end
+    for b in batches, (f, d) in zip(sch.fields, b.columns)
+        collectpools(f, d)
+    end
+    isempty(dictdocs) || (doc["dictionaries"] = dictdocs)
+    doc["batches"] = Any[
+        Dict(
+            "count" => Int(b.nrows),
+            "columns" =>
+                Any[tojsoncolumn(f, d) for (f, d) in zip(sch.fields, b.columns)],
+        ) for b in batches
+    ]
+    return doc
+end
+
+end # module ArrowJSON
diff --git a/conformance/cdata_oracle.jl b/conformance/cdata_oracle.jl
new file mode 100644
index 00000000..95690b1c
--- /dev/null
+++ b/conformance/cdata_oracle.jl
@@ -0,0 +1,481 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# C Data / C Stream oracle: OUR C-interface structures through pyarrow, in
+# one process, over the whole gold data matrix.
+#
+#     julia conformance/run.jl cdata
+#
+# `oracle.jl` proves our IPC BYTES against pyarrow and nanoarrow. This suite
+# proves our C DATA INTERFACE and C STREAM INTERFACE the same way: pyarrow
+# runs in-process (PythonCall) so real ArrowSchema/ArrowArray/ArrowArrayStream
+# pointers cross the boundary in both directions with real ownership moves.
+# The gold corpus supplies the data (every layout the format defines), parsed
+# to Core through the corpus's JSON reader; comparison is the corpus's own
+# value-level document comparison. For every gold family:
+#
+#   ours→pyarrow(C)→ours   each batch is exported as one struct-typed
+#                          ArrowArray + ArrowSchema; pyarrow imports it as a
+#                          RecordBatch, FULLY validates it (its independent
+#                          judgment of our export), and exports it back; our
+#                          importer reads pyarrow's structures. Values must
+#                          equal the gold JSON. Proves both directions of the
+#                          C Data interface, including field names and
+#                          nullability. (Metadata VALUES ride along; exact
+#                          metadata ORDER and duplicate keys are the
+#                          synthetic sentinel's job below — the corpus
+#                          comparison normalizes them away.)
+#   pyarrow-native→ours    pyarrow rebuilds the batch through its OWN IPC
+#                          reader (its allocator, its buffer choices, its
+#                          dictionary memo) and exports that; we import it.
+#                          Proves our importer against pyarrow-produced memory,
+#                          not just our own memory reflected back.
+#   pyarrow slice→ours     pyarrow exports a SLICED batch (nonzero per-node
+#                          offsets); we import it and compare against our own
+#                          logical slice of the source. Proves offset handling
+#                          on both sides.
+#   ours→pyarrow(stream)→ours
+#                          the whole family as one C stream: pyarrow imports
+#                          our ArrowArrayStream as a RecordBatchReader and
+#                          re-exports it; we pull batches through pyarrow's
+#                          stream (a re-entrant Julia→C→Julia pull path).
+#
+# The suite ends by draining the export registries: every C structure handed
+# to pyarrow must have been released back exactly once.
+#
+# The interpreter is ARROW_CDATA_ORACLE_PYTHON — a Python with pyarrow
+# importable; the conformance image (conformance/Dockerfile) sets it. The
+# parent process re-launches this file as a child with PythonCall bound to
+# that interpreter (PythonCall reads its interpreter at load, so the parent
+# never loads it).
+# =============================================================================
+
+import Arrow
+
+if !isdefined(@__MODULE__, :ConformanceSupport)
+    include(joinpath(@__DIR__, "ConformanceSupport.jl"))
+end
+using .ConformanceSupport:
+    ArrowJSON,
+    DEFAULT_CORPUS,
+    Verdict,
+    corebatchdiffs,
+    documentcheck,
+    errorverdict,
+    readjson
+
+const AC = Arrow.ArrowCore
+
+const _CDATA_ORACLE_CHILD = "--child"
+const _CDATA_ORACLE_STANDALONE = abspath(PROGRAM_FILE) == abspath(@__FILE__)
+
+# --- parent: environment preparation + relaunch ------------------------------
+
+function _oracle_python()
+    py = get(ENV, "ARROW_CDATA_ORACLE_PYTHON", "")
+    isempty(py) && error(
+        "ARROW_CDATA_ORACLE_PYTHON is not set: run this suite " *
+        "through `julia conformance/run.jl cdata` (the " *
+        "conformance image), or point ARROW_CDATA_ORACLE_PYTHON at a Python with pyarrow",
+    )
+    return py
+end
+
+function _oracle_parent(args)
+    py = _oracle_python()
+    ver = readchomp(`$py -c "import pyarrow; print(pyarrow.__version__)"`)
+    println("cdata oracle: pyarrow $ver at $py")
+    env = copy(ENV)
+    env["JULIA_PYTHONCALL_EXE"] = py
+    env["JULIA_CONDAPKG_BACKEND"] = "Null"
+    cmd = `$(Base.julia_cmd()) --project=$(dirname(Base.active_project()))
+        --startup-file=no $(@__FILE__) $_CDATA_ORACLE_CHILD $args`
+    proc = run(ignorestatus(setenv(cmd, env)))
+    exit(proc.exitcode)
+end
+
+function _run_cdata_oracle(args)
+    corpus = isempty(args) ? DEFAULT_CORPUS : args[1]
+    verdicts = runcdataoracle(corpus)
+    nfail = ConformanceSupport.report("C Data / C Stream oracle", verdicts)
+    println()
+    println("PASS families by check:")
+    for check in unique(v.check for v in verdicts if v.check != "all")
+        n = count(v -> v.check == check && v.status == :pass, verdicts)
+        m = count(v -> v.check == check && v.status != :skip, verdicts)
+        println("  ", rpad(check, 28), n, "/", m)
+    end
+    exit(nfail == 0 ? 0 : 1)
+end
+
+# Everything below is only defined in the PythonCall child.
+if _CDATA_ORACLE_STANDALONE && length(ARGS) >= 1 && ARGS[1] == _CDATA_ORACLE_CHILD
+    using PythonCall
+
+    const pa = pyimport("pyarrow")
+    const paipc = pyimport("pyarrow.ipc")
+    const CS = Arrow.CArrowSchema
+    const CA = Arrow.CArrowArray
+    const CAS = Arrow.CArrowArrayStream
+
+    # One RecordBatch is one struct-typed column: the schema-level metadata rides
+    # the struct Field, the fields are its children, the columns its child arrays.
+    function _structwrap(sch::AC.Schema, columns, nrows::Integer)
+        f = AC.Field(
+            "",
+            AC.StructType();
+            nullable=false,
+            metadata=sch.metadata,
+            children=collect(AC.Field, sch.fields),
+        )
+        d = AC.ArrayData(
+            AC.StructType(),
+            nrows,
+            [AC.BufferSlice()];
+            children=collect(AC.ArrayData, columns),
+            nullcount=0,
+        )
+        return f, d
+    end
+
+    function _unwrap(f2::AC.Field, d2::AC.ArrayData)
+        sch2 = AC.Schema(
+            collect(AC.Field, f2.children);
+            metadata=f2.metadata,
+            endianness=AC.LittleEndian,
+        )
+        return sch2, AC.RecordBatch(sch2, collect(AC.ArrayData, d2.children), d2.len)
+    end
+
+    # Export one struct-wrapped batch to pyarrow; pyarrow validates fully.
+    function _to_pyarrow(sch::AC.Schema, b::AC.RecordBatch)
+        f, d = _structwrap(sch, b.columns, b.nrows)
+        sp, ap = Arrow.to_c_data(f, d)
+        pyb = pa.RecordBatch._import_from_c(UInt(ap), UInt(sp))
+        unsafe_load(sp).release == C_NULL ||
+            error("pyarrow did not mark the imported schema released")
+        unsafe_load(ap).release == C_NULL ||
+            error("pyarrow did not mark the imported array released")
+        pyb.validate(full=true)
+        return pyb
+    end
+
+    # Import a pyarrow RecordBatch through the C interface into Core.
+    function _from_pyarrow(pyb)
+        aref = Ref{CA}()
+        sref = Ref{CS}()
+        return GC.@preserve aref sref begin
+            ap = Base.unsafe_convert(Ptr{CA}, aref)
+            sp = Base.unsafe_convert(Ptr{CS}, sref)
+            pyb._export_to_c(UInt(ap), UInt(sp))
+            f2, d2 = Arrow.from_c_data(sp, ap)
+            _unwrap(f2, d2)
+        end
+    end
+
+    # pyarrow rebuilds a batch through its own IPC reader: pyarrow-owned memory.
+    function _pyarrow_rebuild(pyb)
+        sink = pa.BufferOutputStream()
+        w = paipc.new_stream(sink, pyb.schema)
+        w.write_batch(pyb)
+        w.close()
+        r = paipc.open_stream(sink.getvalue())
+        return r.read_next_batch()
+    end
+
+    _releasebatch!(b::AC.RecordBatch) =
+        isempty(b.columns) || Arrow.release!(b.columns[1].owner::Arrow.ForeignOwner)
+
+    function runcdatafamily(dir::String, family::String, verdicts::Vector{Verdict})
+        gold = readjson(joinpath(dir, family * ".json.gz"))
+        sch, batches, _ = ArrowJSON.fromjson(gold)
+
+        # 1. ours → pyarrow (validate full) → ours ; 2. pyarrow-native → ours
+        check1 = "ours→pyarrow(C)→ours"
+        check2 = "pyarrow-native→ours"
+        sch1 = sch
+        b1s = AC.RecordBatch[]
+        sch2 = sch
+        b2s = AC.RecordBatch[]
+        ok1 = ok2 = true
+        for b in batches
+            local pyb
+            try
+                pyb = _to_pyarrow(sch, b)
+            catch e
+                ok1 && push!(verdicts, errorverdict(family, check1, e))
+                ok2 && push!(verdicts, errorverdict(family, check2, e))
+                ok1 = ok2 = false
+                break
+            end
+            if ok1
+                try
+                    sch1, b1 = _from_pyarrow(pyb)
+                    push!(b1s, b1)
+                catch e
+                    push!(verdicts, errorverdict(family, check1, e))
+                    ok1 = false
+                end
+            end
+            if ok2
+                try
+                    native = _pyarrow_rebuild(pyb)
+                    sch2, b2 = _from_pyarrow(native)
+                    push!(b2s, b2)
+                    PythonCall.pydel!(native)
+                catch e
+                    push!(verdicts, errorverdict(family, check2, e))
+                    ok2 = false
+                end
+            end
+            PythonCall.pydel!(pyb)
+        end
+        ok1 && push!(verdicts, documentcheck(family, check1, gold) do
+            ArrowJSON.tojson(sch1, b1s)
+        end)
+        ok2 && push!(verdicts, documentcheck(family, check2, gold) do
+            ArrowJSON.tojson(sch2, b2s)
+        end)
+        foreach(_releasebatch!, b1s)
+        foreach(_releasebatch!, b2s)
+
+        # 3. pyarrow slice → ours, against our own logical slice
+        check3 = "pyarrow slice→ours"
+        sliceable = [b for b in batches if b.nrows >= 3]
+        if isempty(sliceable)
+            push!(verdicts, Verdict(family, check3, :skip, "no batch with ≥3 rows"))
+        else
+            try
+                diffs = String[]
+                for b in sliceable
+                    off, len = 1, b.nrows - 2
+                    pyb = _to_pyarrow(sch, b)
+                    sliced = pyb.slice(off, len)
+                    schs, bs = _from_pyarrow(sliced)
+                    PythonCall.pydel!(sliced)
+                    PythonCall.pydel!(pyb)
+                    append!(diffs, corebatchdiffs(bs, b; expectedoffset=off, rows=len))
+                    _releasebatch!(bs)
+                    isempty(diffs) || break
+                end
+                push!(
+                    verdicts,
+                    Verdict(
+                        family,
+                        check3,
+                        isempty(diffs) ? :pass : :fail,
+                        isempty(diffs) ? "" : first(diffs),
+                    ),
+                )
+            catch e
+                push!(verdicts, errorverdict(family, check3, e))
+            end
+        end
+
+        # 4. ours → pyarrow RecordBatchReader → ours, over the C stream interface
+        check4 = "ours→pyarrow(stream)→ours"
+        try
+            outref = Ref{CAS}()
+            inref = Ref{CAS}()
+            sch4, b4s = GC.@preserve outref inref begin
+                outp = Base.unsafe_convert(Ptr{CAS}, outref)
+                Arrow.export_stream!(outp, sch, batches)
+                reader = pa.RecordBatchReader._import_from_c(UInt(outp))
+                unsafe_load(outp).release == C_NULL ||
+                    error("pyarrow did not mark the imported stream released")
+                inp = Base.unsafe_convert(Ptr{CAS}, inref)
+                reader._export_to_c(UInt(inp))
+                s = Arrow.from_c_stream(inp)
+                got = AC.RecordBatch[]
+                while (b = AC.nextbatch!(s)) !== nothing
+                    push!(got, b)
+                end
+                Arrow.release!(s)
+                PythonCall.pydel!(reader)
+                s.schema, got
+            end
+            push!(verdicts, documentcheck(family, check4, gold) do
+                ArrowJSON.tojson(sch4, b4s)
+            end)
+            foreach(_releasebatch!, b4s)
+        catch e
+            push!(verdicts, errorverdict(family, check4, e))
+        end
+        return
+    end
+
+    # Metadata SEQUENCE fidelity: the corpus comparison normalizes metadata (it
+    # sorts pairs and the integration JSON collapses duplicate keys into a Dict),
+    # so it cannot see order or duplicate-key corruption. This synthetic sentinel
+    # compares the ORDERED pair sequences exactly — schema level, a leaf field,
+    # a nested child, and a dictionary field — through both the C data path and
+    # the C stream path.
+    const SENTINEL_META = ["z" => "1", "a" => "2", "z" => "3", "m" => ""]
+
+    function _metadata_sentinel!(verdicts::Vector{Verdict})
+        lf, ld = AC.fromjulia("leaf", Int64[1, 2, 3])
+        leaf = AC.Field(lf.name, lf.type; nullable=lf.nullable, metadata=SENTINEL_META)
+        cf, cd = AC.fromjulia("item", Int64[7, 8, 9])
+        child = AC.Field(
+            cf.name,
+            cf.type;
+            nullable=cf.nullable,
+            metadata=reverse(SENTINEL_META),
+        )
+        lstf, lstd = AC.fromjulia("lst", [Int64[7], Int64[8], Int64[9]])
+        lst = AC.Field(
+            lstf.name,
+            lstf.type;
+            nullable=lstf.nullable,
+            metadata=SENTINEL_META,
+            children=[child],
+        )
+        df0, dd = AC.fromjulia_dict("dict", ["lo", "hi"], [0, 1, 0])
+        dict = AC.Field(
+            df0.name,
+            df0.type;
+            nullable=df0.nullable,
+            metadata=SENTINEL_META,
+            children=collect(AC.Field, df0.children),
+        )
+        sch = AC.Schema(AC.Field[leaf, lst, dict]; metadata=reverse(SENTINEL_META))
+        b = AC.RecordBatch(sch, AC.ArrayData[ld, lstd, dd], 3)
+        seqs(schema) = Any[
+            collect(schema.metadata),
+            [collect(f.metadata) for f in schema.fields]...,
+            collect(schema.fields[2].children[1].metadata),
+        ]
+        want = seqs(sch)
+        for (check, roundtrip) in (
+            ("metadata sequence (C data)", () -> begin
+                pyb = _to_pyarrow(sch, b)
+                s2, b2 = _from_pyarrow(pyb)
+                PythonCall.pydel!(pyb)
+                _releasebatch!(b2)
+                s2
+            end),
+            (
+                "metadata sequence (C stream)",
+                () -> begin
+                    outref = Ref{CAS}()
+                    inref = Ref{CAS}()
+                    GC.@preserve outref inref begin
+                        outp = Base.unsafe_convert(Ptr{CAS}, outref)
+                        Arrow.export_stream!(outp, sch, AC.RecordBatch[b])
+                        reader = pa.RecordBatchReader._import_from_c(UInt(outp))
+                        inp = Base.unsafe_convert(Ptr{CAS}, inref)
+                        reader._export_to_c(UInt(inp))
+                        st = Arrow.from_c_stream(inp)
+                        got = AC.nextbatch!(st)
+                        got === nothing || _releasebatch!(got)
+                        Arrow.release!(st)
+                        PythonCall.pydel!(reader)
+                        st.schema
+                    end
+                end,
+            ),
+        )
+            try
+                got = seqs(roundtrip())
+                push!(
+                    verdicts,
+                    Verdict(
+                        "(sentinel)",
+                        check,
+                        got == want ? :pass : :fail,
+                        got == want ? "" :
+                        "ordered metadata sequences differ: $got vs $want",
+                    ),
+                )
+            catch e
+                push!(verdicts, errorverdict("(sentinel)", check, e))
+            end
+        end
+        return
+    end
+
+    # The C interfaces carry data, not IPC framing, so a family's JSON is the
+    # same test whichever corpus version directory it lives in: run each family
+    # once, from the newest directory that has it.
+    function _familydirs(corpus::String)
+        root = joinpath(corpus, "data", "arrow-ipc-stream", "integration")
+        isdir(root) || error("corpus not found at $root (set ARROW_TESTING_DIR)")
+        vdirs = filter(d -> isdir(joinpath(root, d)), readdir(root))
+        sort!(vdirs; by=d -> (startswith(d, "cpp-"), d), rev=true)
+        chosen = Pair{String,String}[]   # family => version dir
+        seen = Set{String}()
+        for v in vdirs
+            dir = joinpath(root, v)
+            for f in sort!(readdir(dir))
+                endswith(f, ".json.gz") || continue
+                fam = replace(f, r"\.json\.gz$" => "")
+                fam in seen && continue
+                push!(seen, fam)
+                push!(chosen, fam => v)
+            end
+        end
+        return root, chosen
+    end
+
+    function runcdataoracle(corpus::String=DEFAULT_CORPUS)
+        root, chosen = _familydirs(corpus)
+        println(
+            "cdata oracle: pyarrow ",
+            pa.__version__,
+            " over ",
+            length(chosen),
+            " families",
+        )
+        verdicts = Verdict[]
+        for (fam, v) in chosen
+            before = length(verdicts)
+            runcdatafamily(joinpath(root, v), fam, verdicts)
+            for i = (before + 1):length(verdicts)
+                vd = verdicts[i]
+                verdicts[i] = Verdict(v * "/" * vd.family, vd.check, vd.status, vd.detail)
+            end
+        end
+        isempty(verdicts) &&
+            error("arrow-testing corpus contains no runnable C Data families under $root")
+        _metadata_sentinel!(verdicts)
+        # Every structure handed to pyarrow must have come back exactly once.
+        PythonCall.GC.gc()
+        GC.gc()
+        GC.gc()
+        Arrow._reap!()
+        Arrow._reap!()
+        leaked = length(Arrow.EXPORTS)
+        push!(
+            verdicts,
+            Verdict(
+                "(all)",
+                "export registries drained",
+                leaked == 0 ? :pass : :fail,
+                leaked == 0 ? "" : "$leaked export root(s) still registered",
+            ),
+        )
+        return verdicts
+    end
+end # child definitions
+
+if _CDATA_ORACLE_STANDALONE
+    if length(ARGS) >= 1 && ARGS[1] == _CDATA_ORACLE_CHILD
+        _run_cdata_oracle(ARGS[2:end])
+    else
+        _oracle_parent(ARGS)
+    end
+end
diff --git a/conformance/corpus.jl b/conformance/corpus.jl
new file mode 100644
index 00000000..f13b6215
--- /dev/null
+++ b/conformance/corpus.jl
@@ -0,0 +1,165 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# Corpus conformance: the apache/arrow-testing integration gold files.
+#
+#     julia conformance/run.jl corpus      # in the conformance image
+#
+# For every gold family (a `.json.gz` with sibling `.stream` and
+# `.arrow_file`), run the four checks that make up cross-implementation
+# conformance and report a per-file verdict:
+#
+#   JSON→Core→JSON   parse the gold JSON into Core, render it back, compare
+#                    documents (proves the JSON mapping is lossless);
+#   gold stream→JSON read the gold .stream through our IPC reader, render as
+#                    JSON, compare to the gold JSON (proves READ conformance);
+#   gold file→JSON   same through the file reader (footer path);
+#   JSON→our IPC→gold values
+#                    write the gold JSON's Core values with OUR writer (stream
+#                    + file), read back through OUR reader, compare values to
+#                    the gold JSON (proves WRITE round-trip). Byte-identity
+#                    with the gold IPC is NOT required — writers legitimately
+#                    differ in padding, dictionary ordering, and metadata.
+#
+# Comparison is value-level over the JSON documents (schema, dictionaries,
+# batches) with numeric normalization (floats compared EXACTLY after
+# half/single columns are canonicalized through their physical precision;
+# 64-bit strings vs numbers unified). Skips are explicit and categorized so
+# the report reads as coverage, not silence.
+# =============================================================================
+
+import Arrow
+
+if !isdefined(@__MODULE__, :ConformanceSupport)
+    include(joinpath(@__DIR__, "ConformanceSupport.jl"))
+end
+using .ConformanceSupport:
+    ArrowJSON,
+    DEFAULT_CORPUS,
+    Verdict,
+    documentcheck,
+    familyskipreason,
+    filedocument,
+    goldipcskipreason,
+    readjson,
+    streamdocument
+
+function runfamily(dir::String, family::String, verdicts::Vector{Verdict})
+    why = familyskipreason(family, basename(dir))
+    if !isempty(why)
+        push!(verdicts, Verdict(family, "all", :skip, why))
+        return
+    end
+
+    gold = readjson(joinpath(dir, family * ".json.gz"))
+
+    # 1. JSON -> Core -> JSON
+    check = "json→core→json"
+    push!(verdicts, documentcheck(family, check, gold) do
+        sch, batches, dictids = ArrowJSON.fromjson(gold)
+        ArrowJSON.tojson(sch, batches; dictids=dictids)
+    end)
+
+    # 2. gold stream -> JSON ; 3. gold file -> JSON
+    for (check, path, reader) in (
+        ("gold stream→json", joinpath(dir, family * ".stream"), streamdocument),
+        ("gold file→json", joinpath(dir, family * ".arrow_file"), filedocument),
+    )
+        why = goldipcskipreason(family, basename(dir))
+        if !isempty(why)
+            push!(verdicts, Verdict(family, check, :skip, why))
+            continue
+        end
+        if !isfile(path)
+            push!(verdicts, Verdict(family, check, :skip, "no gold file"))
+            continue
+        end
+        push!(verdicts, documentcheck(family, check, gold) do
+            reader(read(path))
+        end)
+    end
+
+    # 4. JSON -> our IPC (stream + file) -> our reader -> JSON vs gold
+    for (check, writer, reader) in (
+        (
+            "json→our stream→json",
+            (s, b, ids) -> Arrow.writestream(s, b; dictids=ids),
+            streamdocument,
+        ),
+        (
+            "json→our file→json",
+            (s, b, ids) -> Arrow.writefile(s, b; dictids=ids),
+            filedocument,
+        ),
+    )
+        push!(verdicts, documentcheck(family, check, gold) do
+            sch, batches, dictids = ArrowJSON.fromjson(gold)
+            reader(writer(sch, batches, dictids))
+        end)
+    end
+    return
+end
+
+function runcorpus(corpus::String=DEFAULT_CORPUS; versions=nothing)
+    isempty(corpus) && error(
+        "ARROW_TESTING_DIR is not set: run this suite " *
+        "through `julia conformance/run.jl corpus`",
+    )
+    root = joinpath(corpus, "data", "arrow-ipc-stream", "integration")
+    isdir(root) || error("corpus not found at $root (set ARROW_TESTING_DIR)")
+    verdicts = Verdict[]
+    vdirs =
+        versions === nothing ? filter(d -> isdir(joinpath(root, d)), readdir(root)) :
+        versions
+    for v in sort(vdirs)
+        dir = joinpath(root, v)
+        families = sort!(
+            unique!([
+                replace(f, r"\.json\.gz$" => "") for
+                f in readdir(dir) if endswith(f, ".json.gz")
+            ]),
+        )
+        for fam in families
+            before = length(verdicts)
+            runfamily(dir, fam, verdicts)
+            for i = (before + 1):length(verdicts)
+                vd = verdicts[i]
+                verdicts[i] = Verdict(v * "/" * vd.family, vd.check, vd.status, vd.detail)
+            end
+        end
+    end
+    (isempty(verdicts) || all(v -> v.status == :skip, verdicts)) &&
+        error("arrow-testing corpus contains no runnable cases under $root")
+    return verdicts
+end
+
+report(verdicts::Vector{Verdict}; io=stdout) =
+    ConformanceSupport.report("arrow-testing corpus", verdicts; io=io)
+
+if abspath(PROGRAM_FILE) == abspath(@__FILE__)
+    corpus = isempty(ARGS) ? DEFAULT_CORPUS : ARGS[1]
+    verdicts = runcorpus(corpus)
+    nfail = report(verdicts)
+    println()
+    println("PASS families by check:")
+    for check in unique(v.check for v in verdicts if v.check != "all")
+        n = count(v -> v.check == check && v.status == :pass, verdicts)
+        m = count(v -> v.check == check && v.status != :skip, verdicts)
+        println("  ", rpad(check, 24), n, "/", m)
+    end
+    exit(nfail == 0 ? 0 : 1)
+end
diff --git a/conformance/host/Project.toml b/conformance/host/Project.toml
new file mode 100644
index 00000000..597a8b27
--- /dev/null
+++ b/conformance/host/Project.toml
@@ -0,0 +1,26 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The HOST side of the conformance driver: only what conformance/run.jl
+# needs to build the image and drive the container. run.jl activates and
+# instantiates this environment itself. (conformance/Project.toml is the
+# in-container suite environment.)
+[deps]
+Harbor = "af79dbb9-1a80-47ad-8928-192a4af69376"
+
+[compat]
+Harbor = "=1.1.0"
+julia = "1.10"
diff --git a/conformance/oracle.jl b/conformance/oracle.jl
new file mode 100644
index 00000000..8249f25a
--- /dev/null
+++ b/conformance/oracle.jl
@@ -0,0 +1,336 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# Oracle round-trips: OUR IPC bytes through pyarrow and nanoarrow.
+#
+#     julia conformance/run.jl oracle      # in the conformance image
+#
+# The gold corpus proves us against files C++ wrote years ago; this suite
+# proves us against implementations running today. The corpus supplies the
+# data matrix (every layout the format defines), the conformance image
+# (conformance/Dockerfile) supplies the oracles — a Python with pyarrow and
+# nanoarrow named by ARROW_ORACLE_PYTHON (ORACLE_WORKDIR keeps the generated
+# cases and oracle output in a fixed directory instead of a temp dir) — and
+# for every gold family we run:
+#
+#   ours→pyarrow stream   parse the gold JSON into Core, write OUR stream
+#                         bytes; pyarrow reads them, structurally validates,
+#                         rewrites its own stream; OUR reader reads that
+#                         back and the values must equal the gold JSON.
+#                         Proves pyarrow accepts our bytes and we accept
+#                         pyarrow's, value-losslessly.
+#   ours→pyarrow file     the same through the file format (footer path).
+#   ours→nanoarrow stream nanoarrow's IPC reader consumes our stream and
+#                         hands the arrays over the C-stream capsule;
+#                         nanoarrow's writer (or pyarrow's, on releases
+#                         without one) produces the return stream. Proves
+#                         the nanoarrow reader accepts our bytes.
+#   +lz4 / +zstd          compressed-body variants of primitive,
+#                         nested-dictionary, and binary-view families,
+#                         proving our compressed framing against C++.
+#
+# Comparison is the corpus's own value-level document comparison, so id
+# reassignment, pool unification, and padding differences by the oracle
+# writers are already normalized away.
+# =============================================================================
+
+using JSON
+import Arrow
+
+if !isdefined(@__MODULE__, :ConformanceSupport)
+    include(joinpath(@__DIR__, "ConformanceSupport.jl"))
+end
+using .ConformanceSupport:
+    ArrowJSON,
+    DEFAULT_CORPUS,
+    Verdict,
+    documentcheck,
+    familyskipreason,
+    filedocument,
+    readjson,
+    streamdocument
+
+# The oracle interpreter: a Python with pyarrow (and nanoarrow) importable.
+# The conformance image sets it; on a host, point it at any such interpreter.
+function _oraclepython()
+    py = get(ENV, "ARROW_ORACLE_PYTHON", "")
+    isempty(py) && error(
+        "ARROW_ORACLE_PYTHON is not set: run this suite through " *
+        "`julia conformance/run.jl oracle` (the conformance " *
+        "image), or point ARROW_ORACLE_PYTHON at a Python with pyarrow and nanoarrow",
+    )
+    return py
+end
+
+# The in-container driver. One process over all cases: reads each of our
+# streams/files, structurally validates them, and writes the return bytes plus a
+# results.json of per-case statuses (an oracle refusing our bytes is a
+# finding, not a crash).
+const PYDRIVER = raw"""
+import json, os, sys
+import pyarrow as pa
+import pyarrow.ipc as ipc
+import nanoarrow as na
+import nanoarrow.ipc as naipc
+
+def na_stream(path):
+    # nanoarrow's IPC entry point moved across releases; probe.
+    if hasattr(na, "ArrayStream") and hasattr(na.ArrayStream, "from_path"):
+        return na.ArrayStream.from_path(path)
+    return na.ArrayStream(naipc.InputStream.from_path(path))
+
+def classify(e):
+    # Raw error text only — the Julia side decides skip-vs-fail against an
+    # explicit whitelist of known oracle capability gaps, so a NEW
+    # interoperability failure can never classify itself into a skip.
+    return f"{type(e).__name__}: {e}"[:200]
+
+def rewrite(batches, schema, open_sink):
+    # Per-batch rewrite: read_all()/write_table merges chunks and drops
+    # zero-length batches, which breaks batch-boundary comparison against
+    # the gold JSON. Structural validate only: full validation enforces the
+    # advisory contracts (date64 divisibility, decimal precision) that the
+    # gold corpus itself violates and default C++ reads accept.
+    for b in batches:
+        b.validate()
+    with open_sink(schema) as w:
+        for b in batches:
+            w.write_batch(b)
+
+work = sys.argv[1]
+cases = json.load(open(os.path.join(work, "cases.json")))
+outdir = os.path.join(work, "out")
+os.makedirs(outdir, exist_ok=True)
+results = {"pyarrow": pa.__version__,
+           "nanoarrow": na.__version__,
+           "cases": {}}
+for case in cases:
+    name = case["name"]
+    r = {}
+    spath = os.path.join(work, "cases", name + ".stream")
+    fpath = os.path.join(work, "cases", name + ".arrow")
+    try:
+        reader = ipc.open_stream(spath)
+        rewrite(list(reader), reader.schema, lambda s: ipc.new_stream(
+            os.path.join(outdir, name + ".pyarrow.stream"), s))
+        r["pyarrow_stream"] = "ok"
+    except Exception as e:
+        r["pyarrow_stream"] = classify(e)
+    try:
+        f = ipc.open_file(fpath)
+        rewrite([f.get_batch(i) for i in range(f.num_record_batches)],
+                f.schema, lambda s: ipc.new_file(
+                    os.path.join(outdir, name + ".pyarrow.arrow"), s))
+        r["pyarrow_file"] = "ok"
+    except Exception as e:
+        r["pyarrow_file"] = classify(e)
+    try:
+        reader = pa.RecordBatchReader.from_stream(na_stream(spath))
+        batches = list(reader)   # nanoarrow reads OUR bytes
+        outpath = os.path.join(outdir, name + ".nanoarrow.stream")
+        try:    # prefer nanoarrow's own writer for the return trip
+            back = pa.RecordBatchReader.from_batches(reader.schema, batches)
+            with naipc.StreamWriter.from_path(outpath) as w:
+                w.write_stream(na.c_array_stream(back))
+        except Exception:
+            rewrite(batches, reader.schema,
+                    lambda s: ipc.new_stream(outpath, s))
+        r["nanoarrow_stream"] = "ok"
+    except Exception as e:
+        r["nanoarrow_stream"] = classify(e)
+    results["cases"][name] = r
+json.dump(results, open(os.path.join(work, "results.json"), "w"))
+print(f"driver: {len(cases)} cases")
+"""
+
+struct OracleCase
+    name::String        # <versiondir>__<family>[+codec], also the file stem
+    label::String       # <versiondir>/<family>[+codec], for the report
+    goldpath::String
+end
+
+# These families cover primitive buffers, dictionary batches with nested child
+# buffers, and variadic view buffers without multiplying every corpus case.
+const COMPRESSED_ORACLE_FAMILIES =
+    ("generated_primitive", "generated_nested_dictionary", "generated_binary_view")
+const TARGETED_ORACLE_VARIANTS = Tuple(
+    (family, codec) for family in COMPRESSED_ORACLE_FAMILIES for codec in (:lz4, :zstd)
+)
+
+function _requiretargetedoracles(cases)
+    missing = Tuple{String,Symbol}[]
+    for (family, variant) in TARGETED_ORACLE_VARIANTS
+        suffix = "__" * family * "+" * String(variant)
+        any(case -> endswith(case.name, suffix), cases) || push!(missing, (family, variant))
+    end
+    isempty(missing) ||
+        error("pinned corpus did not prepare targeted oracle cases: $missing")
+    return nothing
+end
+
+"""
+Write OUR stream + file bytes for every non-skipped gold family (plus targeted
+compressed families) into workdir/cases, and the case manifest the python
+driver walks.
+"""
+function preparecases(corpus::String, workdir::String; require_targeted::Bool=false)
+    root = joinpath(corpus, "data", "arrow-ipc-stream", "integration")
+    isdir(root) || error("corpus not found at $root (set ARROW_TESTING_DIR)")
+    casedir = joinpath(workdir, "cases")
+    mkpath(casedir)
+    cases = OracleCase[]
+    skips = Tuple{String,String}[]
+    for v in sort(filter(d -> isdir(joinpath(root, d)), readdir(root)))
+        dir = joinpath(root, v)
+        families = sort!(
+            unique!([
+                replace(f, r"\.json\.gz$" => "") for
+                f in readdir(dir) if endswith(f, ".json.gz")
+            ]),
+        )
+        for fam in families
+            why = familyskipreason(fam, v)
+            isempty(why) || (push!(skips, (v * "/" * fam, why)); continue)
+            goldpath = joinpath(dir, fam * ".json.gz")
+            sch, batches, dictids = ArrowJSON.fromjson(readjson(goldpath))
+            variants = fam in COMPRESSED_ORACLE_FAMILIES ? (:none, :lz4, :zstd) : (:none,)
+            for compress in variants
+                suffix = compress == :none ? "" : "+" * String(compress)
+                name = v * "__" * fam * suffix
+                write(
+                    joinpath(casedir, name * ".stream"),
+                    Arrow.writestream(sch, batches; compress=compress, dictids=dictids),
+                )
+                write(
+                    joinpath(casedir, name * ".arrow"),
+                    Arrow.writefile(sch, batches; compress=compress, dictids=dictids),
+                )
+                push!(cases, OracleCase(name, v * "/" * fam * suffix, goldpath))
+            end
+        end
+    end
+    require_targeted && _requiretargetedoracles(cases)
+    open(joinpath(workdir, "cases.json"), "w") do io
+        JSON.print(io, [Dict("name" => c.name) for c in cases])
+    end
+    isempty(cases) &&
+        error("arrow-testing corpus contains no runnable oracle cases under $root")
+    return cases, skips
+end
+
+"""
+Run the python driver over workdir with the oracle interpreter and return
+the parsed results.json (an oracle refusing our bytes is a finding, not a
+crash: the driver records per-case statuses and exits 0).
+"""
+function runoracles(workdir::String)
+    driver = joinpath(workdir, "driver.py")
+    write(driver, PYDRIVER)
+    py = _oraclepython()
+    Base.run(`$py $driver $workdir`)
+    return JSON.parsefile(joinpath(workdir, "results.json"))
+end
+
+const ORACLE_CHECKS = (
+    ("ours→pyarrow stream", "pyarrow_stream", ".pyarrow.stream", streamdocument),
+    ("ours→pyarrow file", "pyarrow_file", ".pyarrow.arrow", filedocument),
+    ("ours→nanoarrow stream", "nanoarrow_stream", ".nanoarrow.stream", streamdocument),
+)
+
+# The ONLY oracle errors this suite treats as skips: known capability gaps,
+# whitelisted by check, case, and error text. Anything else — including a
+# feature error on a case not listed here — is a failure to investigate.
+const ORACLE_EXPECTED_GAPS = (
+    (
+        "nanoarrow_stream",
+        n -> endswith(n, "+lz4") || endswith(n, "+zstd"),
+        "unsupported feature COMPRESSED_BODY",
+    ),
+    (
+        "nanoarrow_stream",
+        n -> occursin("generated_binary_view", n),
+        "BinaryView not yet supported",
+    ),
+    (
+        "nanoarrow_stream",
+        n -> occursin("generated_list_view", n),
+        "ListView/LargeListView not yet supported",
+    ),
+    (
+        "nanoarrow_stream",
+        n -> occursin("generated_run_end_encoded", n),
+        "RunEndEncoded not yet supported",
+    ),
+)
+
+_expectedgap(key::String, name::String, status::String) = any(
+    k == key && pred(name) && occursin(text, status) for
+    (k, pred, text) in ORACLE_EXPECTED_GAPS
+)
+
+function runoracle(
+    corpus::String=DEFAULT_CORPUS;
+    workdir::String=get(ENV, "ORACLE_WORKDIR", mktempdir(prefix="arrow-oracle-")),
+)
+    cases, skips = preparecases(corpus, workdir; require_targeted=true)
+    println("oracle: ", length(cases), " cases prepared in ", workdir)
+    results = runoracles(workdir)
+    return compareresults(cases, skips, results, workdir), results
+end
+
+"""
+Judge the oracle outputs: for every case the driver reported "ok", read the
+return bytes with OUR reader and compare values against the gold JSON.
+"""
+function compareresults(cases::Vector{OracleCase}, skips, results, workdir::String)
+    verdicts = Verdict[]
+    for (label, why) in skips
+        push!(verdicts, Verdict(label, "all", :skip, why))
+    end
+    for case in cases
+        gold = readjson(case.goldpath)
+        r = get(results["cases"], case.name, Dict{String,Any}())
+        for (check, key, suffix, reader) in ORACLE_CHECKS
+            status = get(r, key, "driver produced no result")
+            if status != "ok"
+                # Capability errors skip only through the explicit whitelist.
+                # A missing required oracle or result is a conformance failure.
+                kind = _expectedgap(key, case.name, status) ? :skip : :fail
+                push!(verdicts, Verdict(case.label, check, kind, status))
+                continue
+            end
+            push!(verdicts, documentcheck(case.label, check, gold) do
+                reader(read(joinpath(workdir, "out", case.name * suffix)))
+            end)
+        end
+    end
+    return verdicts
+end
+
+function oraclereport(verdicts::Vector{Verdict}, results; io=stdout)
+    header =
+        "oracle round-trips (pyarrow $(get(results, "pyarrow", "?")), " *
+        "nanoarrow $(get(results, "nanoarrow", "?")))"
+    return ConformanceSupport.report(header, verdicts; io=io)
+end
+
+if abspath(PROGRAM_FILE) == abspath(@__FILE__)
+    corpus = isempty(ARGS) ? DEFAULT_CORPUS : ARGS[1]
+    verdicts, results = runoracle(corpus)
+    nfail = oraclereport(verdicts, results)
+    exit(nfail == 0 ? 0 : 1)
+end
diff --git a/conformance/run.jl b/conformance/run.jl
new file mode 100644
index 00000000..afbddbc2
--- /dev/null
+++ b/conformance/run.jl
@@ -0,0 +1,127 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# The conformance driver: run the suites inside the conformance image.
+#
+#     julia conformance/run.jl [suite ...] [--rebuild]
+#
+# Suites: `corpus` (arrow-testing gold files), `oracle` (our IPC bytes
+# through pyarrow and nanoarrow), `cdata` (C Data / C Stream through an
+# in-process pyarrow); no argument runs all three. Docker is the only host
+# requirement (plus network the first time, to fetch Harbor.jl and build the
+# image): the image (conformance/Dockerfile) carries Julia, the oracle
+# Python, and the gold corpus, and the repository is bind-mounted at /work. The image is built once (`--rebuild` forces it) and
+# a named volume keeps the Julia depot — precompilation caches — between
+# runs. Harbor.jl manages the container; suite output streams live.
+#
+# This script needs no `--project`: it activates and instantiates its own
+# host environment (conformance/host/, Harbor only). conformance/Project.toml
+# is the IN-CONTAINER suite environment and is prepared inside the image.
+#
+# Exit code: 0 iff every requested suite passed.
+# =============================================================================
+
+import Pkg
+Pkg.activate(joinpath(@__DIR__, "host"); io=devnull)
+Pkg.instantiate(; io=devnull)
+using Harbor
+
+const IMAGE = "arrow-julia-conformance:latest"
+const DEPOT_VOLUME = "arrow-julia-conformance-depot"
+const REPO = normpath(joinpath(@__DIR__, ".."))
+const SUITES = Dict(
+    "corpus" => "conformance/corpus.jl",
+    "oracle" => "conformance/oracle.jl",
+    "cdata" => "conformance/cdata_oracle.jl",
+)
+const SUITE_ORDER = ["corpus", "oracle", "cdata"]
+
+_haveimage() =
+    success(pipeline(`docker image inspect $IMAGE`; stdout=devnull, stderr=devnull))
+
+function buildimage()
+    println("conformance: building $IMAGE (once; --rebuild forces)")
+    Base.run(`docker build -t $IMAGE -f $(joinpath(REPO, "conformance", "Dockerfile"))
+        $(joinpath(REPO, "conformance"))`)
+    return nothing
+end
+
+# `docker exec` directly (not Harbor.exec, which captures output): the suites
+# run for minutes and their progress belongs on the terminal.
+function execstream(container, cmd::Vector{String})
+    proc = Base.run(ignorestatus(`docker exec $(container.id) $cmd`))
+    return proc.exitcode
+end
+
+function main(args)
+    rebuild = "--rebuild" in args
+    requested = filter(a -> a != "--rebuild", args)
+    isempty(requested) && (requested = SUITE_ORDER)
+    for s in requested
+        haskey(SUITES, s) ||
+            error("unknown suite $(repr(s)); choose from $(join(SUITE_ORDER, ", "))")
+    end
+    (rebuild || !_haveimage()) && buildimage()
+
+    container = Harbor.run!(
+        IMAGE;
+        command=["sleep", "infinity"],
+        detach=true,
+        volumes=Dict("/work" => REPO, "/opt/julia-depot" => DEPOT_VOLUME),
+    )
+    results = Dict{String,Int}()
+    try
+        # The suite environment: the repository's conformance project with
+        # the mounted checkout developed in.
+        # Cheap when the depot volume is warm; fetches only what changed.
+        println("conformance: preparing the suite environment")
+        rc = execstream(
+            container,
+            [
+                "julia",
+                "--project=/opt/env",
+                "--startup-file=no",
+                "-e",
+                """using Pkg
+                   cp("/work/conformance/Project.toml", "/opt/env/Project.toml"; force=true)
+                   Pkg.develop([
+                       PackageSpec(path="/work/src/ArrowTypes"),
+                       PackageSpec(path="/work"),
+                   ])
+                   Pkg.instantiate(); Pkg.precompile()""",
+            ],
+        )
+        rc == 0 || error("suite environment preparation failed (exit $rc)")
+        for s in requested
+            println()
+            println("conformance: ===== $s =====")
+            results[s] = execstream(
+                container,
+                ["julia", "--project=/opt/env", "--startup-file=no", SUITES[s]],
+            )
+        end
+    finally
+        Harbor.cleanup!(container)
+    end
+    println()
+    for s in requested
+        println(rpad(s, 8), results[s] == 0 ? "PASS" : "FAIL (exit $(results[s]))")
+    end
+    exit(all(==(0), values(results)) ? 0 : 1)
+end
+
+main(ARGS)
diff --git a/dev/release/README.md b/dev/release/README.md
index 0ed3d9b2..cdcc01a4 100644
--- a/dev/release/README.md
+++ b/dev/release/README.md
@@ -45,6 +45,12 @@ $ dev/release/release_rc.sh 1
 
 The argument of `release_rc.sh` is the RC number. If RC1 has a problem, we'll increment the RC number such as RC2, RC3 and so on.
 
+Keep the vote open for at least 72 hours. A release requires at least three
+binding `+1` votes from PMC members and more binding positive votes than
+binding negative votes. See the [ASF voting
+rules](https://www.apache.org/foundation/voting.html) and the [Arrow release
+guide](https://arrow.apache.org/docs/dev/developers/release.html).
+
 Requirements to run `release_rc.sh`:
 
   * You must be an Apache Arrow committer or PMC member
@@ -103,6 +109,8 @@ If ArrowTypes is also registered, we also need to post a comment on the commit w
 @JuliaRegistrator register subdir=src/ArrowTypes
 ```
 
+DataStrings is registered separately in [JuliaData/DataStrings.jl](https://github.com/JuliaData/DataStrings.jl).
+
 ### Verify
 
 We have a script to verify a RC.
diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index 6e32d072..af00dc93 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -19,4 +19,3 @@ Manifest.toml
 dev/release/apache-rat-*.jar
 dev/release/filtered_rat.txt
 dev/release/rat.xml
-test/arrowjson/*.json
diff --git a/dev/release/release_rc.sh b/dev/release/release_rc.sh
index bae1997b..a5996df7 100755
--- a/dev/release/release_rc.sh
+++ b/dev/release/release_rc.sh
@@ -136,7 +136,7 @@ The source release rc${rc} is hosted at [2].
 Please download, verify checksums and signatures, run the unit tests,
 and vote on the release. See [3] for how to validate a release candidate.
 
-The vote will be open for at least 24 hours.
+The vote will be open for at least 72 hours.
 
 [ ] +1 Release this as Apache Arrow Julia ${version}
 [ ] +0
diff --git a/docs/Project.toml b/docs/Project.toml
index ebc6a27f..d339ba6c 100644
--- a/docs/Project.toml
+++ b/docs/Project.toml
@@ -17,7 +17,26 @@
 
 [deps]
 Arrow = "69666777-d1a9-59fb-9406-91d4454c9d45"
+ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd"
+CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597"
+DataAPI = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
+DataDecimals = "3e2245cb-6932-498d-a7cf-39d39de8bde3"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+DataStrings = "48204bd6-5611-42ea-b167-fc1d713f9be2"
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"
+Durations = "41ac09f5-0a95-4810-aa18-c88bf48ee130"
+PooledArrays = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
+Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
 
 [compat]
-Documenter = "1"
+ArrowTypes = "2"
+CategoricalArrays = "0.10, 1"
+DataAPI = "1"
+DataDecimals = "1"
+DataFrames = "1"
+DataStrings = "1"
+Documenter = "1.17"
+Durations = "1.4"
+PooledArrays = "1"
+Tables = "1.14"
+julia = "1.10"
diff --git a/docs/dev/DESIGN-incremental-writer.md b/docs/dev/DESIGN-incremental-writer.md
new file mode 100644
index 00000000..b7a15911
--- /dev/null
+++ b/docs/dev/DESIGN-incremental-writer.md
@@ -0,0 +1,209 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+--->
+
+# Design: the Arrow 3.x incremental writer
+
+Status: implemented, and the implementation differs from this proposal:
+`Arrow.write` also streams (one partition in memory at a time), the Writer
+declares every field nullable by default and widens later tables losslessly,
+and dictionaries grow by delta batches in both formats. The manual
+(`docs/src/manual.md`) and the docstrings describe the current behavior.
+Motivating issues: #237, #244, #247, #413 (write memory), #485/#501
+(Writer/append removal fallout), Pioneer.jl and SpineOpt.jl migration
+blockers.
+
+## Problem
+
+Arrow 3.0's writer is eager: `Arrow.write` materializes every partition,
+constructs every column across all partitions at once, validates, and then
+publishes the complete IPC output. That buys whole-table schema inference
+(cross-partition pool unification, Union routes, abstract narrowing) and
+validation-before-publish, but it removes the two 2.x capabilities people
+actually used: writing batches as they are produced (`Arrow.Writer`), and
+adding batches to an existing sink (`Arrow.append`). It also makes every
+write hold the whole table plus the whole output in memory.
+
+## What the internals already give us
+
+Both IPC writers are batch-sequential loops over a byte accumulator:
+
+- `writestream`: `_schemamessage!` once → per batch `_dictionarymessage!`
+  (replacement supported: a pool identity change re-emits under the same id)
+  + `_recordmessage!` → EOS marker.
+- `writefile`: leading magic → the same message loop with per-message Block
+  bookkeeping (offsets measured against the accumulator length) → EOS →
+  Footer (schema + dictionary/record Block vectors) + length + magic.
+
+Nothing in the loop needs the batch *vector*; only three things are
+whole-table today: the `out::Vector{UInt8}` accumulator, the upfront
+`_validatewriterbatches(sch, batches, ids)` sweep, and the facade's
+materialize-all-partitions phase in `_writebytes`.
+
+The second ingredient already exists too: **retained-schema column
+construction**. `_constructcolumn(name, parts; retained=field)` builds a
+column against a FIXED `Field` and fails closed with clear errors when the
+data does not conform — the engine a fixed-schema incremental writer needs,
+already tested by every facade rewrite.
+
+## Proposal
+
+### Layer 1 (internal): `IPCWriteState`
+
+Extract the shared loop into a state struct in `ipc_write.jl`:
+
+```julia
+mutable struct IPCWriteState
+    io::IO                      # the sink; batch bytes publish per batch
+    file::Bool                  # footer bookkeeping on close?
+    schema::Schema
+    fielddictids::IdDict{Field,Int64}
+    ids                         # assigndictids result
+    codec::UInt8
+    state::Union{Nothing,EncodeState}
+    current::Dict{Int64,ArrayData}      # stream: last pool per id
+    emitted::Set{Int64}                 # file: ids already written
+    dictblocks::Vector{NTuple{3,Int64}} # file only
+    recordblocks::Vector{NTuple{3,Int64}}
+    written::Int64              # bytes published (replaces length(out))
+    closed::Bool
+end
+
+beginwrite!(io, sch; file, compress, dictids) -> IPCWriteState
+writebatch!(st, batch::AC.RecordBatch)   # validate THIS batch, stage its
+                                         # bytes, publish once
+finishwrite!(st)                         # EOS; file: footer + magic
+```
+
+Each `writebatch!` stages one batch's messages into a scratch buffer,
+validates before touching `io`, then publishes — the eager writer's
+validate-before-publish invariant holds per batch instead of per file.
+`writestream`/`writefile` become `beginwrite!` + a loop + `finishwrite!`
+over an in-memory sink, so the eager paths are byte-identical and the whole
+existing battery/conformance/oracle surface proves the refactor.
+
+Dictionary rules fall out of the existing checks:
+
+- Stream format: a later batch with a different pool identity re-emits a
+  replacement dictionary message (already the loop's behavior).
+- File format: one dictionary batch per id; `writebatch!` refuses a pool
+  identity change with the same wording `writefile` uses today. (A future
+  option is accumulating pools and emitting dictionary blocks just before
+  the footer — the Footer's Block index makes position irrelevant to
+  conforming readers — but that changes pool-growth semantics and is out of
+  scope for v1.)
+
+### Layer 2 (facade): `Arrow.Writer`
+
+The current `Arrow.Writer` tombstone becomes the real thing again:
+
+```julia
+w = Arrow.Writer(sink; file=true, compress=nothing,
+                 metadata=nothing, colmetadata=nothing)
+Arrow.write(w, table)   # one record batch per Tables.partitions partition
+close(w)                # idempotent; EOS or footer; then close(io) iff we opened it
+Arrow.Writer(sink; kw...) do w ... end
+```
+
+- The FIRST `Arrow.write(w, table)` runs today's full column construction on
+  that table alone, fixing the `Schema`, and emits the schema message plus
+  the first batches.
+- Every LATER write constructs each column with `retained=` that fixed
+  schema — exactly the rewrite path — so conformance failures reuse the
+  existing, well-worded errors.
+- Nullability is declared, not data-driven, matching the 3.0 write rule:
+  a field is nullable iff the first table's column eltype admits `Missing`.
+  A later batch with missing values under a non-nullable field is refused
+  with a fix-forward message ("make the first table's column eltype
+  missing-capable, or write an empty typed table first"). Writing a
+  zero-row table with a fully typed `Tables.Schema` as the first write is
+  the supported way to pin a schema explicitly — no new kwarg needed.
+- `sink` is a path (opened at construction; the handle owns and closes it)
+  or an `IO` (borrowed; `close(w)` finishes the IPC output but leaves the
+  `IO` open). A mid-stream error leaves a torn sink — documented, like any
+  incremental format writer; `Arrow.write` remains the atomic option.
+- Single-owner cursor, like the read side: overlapping `write`/`close`
+  calls on one handle throw; an `@atomic closed` flag backs idempotent
+  close and use-after-close errors.
+- Memory: O(current table) plus retained pool references. This is the
+  documented answer to #237/#244/#247/#413.
+
+### Layer 3 (facade): `Arrow.append`
+
+```julia
+Arrow.append(path_or_io, table; compress=nothing)
+```
+
+v1 supports the STREAM format only — the format where append is natural and
+the format 2.x users actually appended to (SpineOpt, Agents.jl):
+
+1. Read the existing schema: open the sink, `readstream` the schema message
+   (and dictionary ids) — validation of the existing prefix is the reader's
+   normal framing pass over what it consumes; append does not re-verify
+   every historical batch body.
+2. Construct the new table's columns with `retained=` the existing schema.
+3. Seek to the trailing EOS marker (last 8 bytes), truncate/overwrite it,
+   `writebatch!` the new batches (dictionary replacement messages allowed),
+   re-emit EOS.
+
+A file-format sink gets a clean refusal pointing at `Arrow.Writer` or a
+whole-file rewrite. (File-format append — footer read, truncate, extend the
+Block lists, rewrite the footer — is mechanically possible with
+`verify_footer` + the Block machinery, but it rewrites trailing bytes in
+place and v1 should not normalize that risk. Revisit on demand.)
+
+## What this deliberately does not do
+
+- No cross-batch schema inference: the first write (or an explicit typed
+  empty first write) is the schema authority. This is the semantic price of
+  incrementality, stated loudly in the docstrings: the eager
+  `Arrow.write` can infer a Union across partitions; the Writer cannot.
+- No `ntasks`-style pipelining: `writebatch!` is serial. The 2.x
+  concurrency was a large share of its bug surface; add measured
+  parallelism later if benchmarks demand it.
+- No delta emission (the reader accepts deltas from other producers) and no
+  file-format pool growth.
+- No append-to-file-format in v1.
+
+## Testing
+
+- Refactor equivalence: eager `writestream`/`writefile` outputs are
+  byte-identical before/after Layer 1 (golden comparison in the battery).
+- Writer suites: multi-write stream and file outputs are byte-identical to
+  the equivalent eager `Tables.partitioner` write for conforming inputs;
+  schema-conformance refusals (type drift, missing under non-nullable,
+  file-format pool change) assert the error wording; torn-sink behavior on
+  a mid-write error; do-block; close idempotence; use-after-close.
+- Append suites: append to a 3.0-written stream, a 2.x-written stream
+  fixture (fixtures2x), and an appended-to-appended stream; read back with
+  `Arrow.Stream` and pyarrow (conformance oracle case); dictionary
+  replacement across appends; refusal on schema drift and on file-format
+  sinks.
+- Fuzz: extend the deterministic fuzzer with a Writer route (random batch
+  splits of each corpus table must read back equal to the eager write).
+
+## Sizing and sequencing
+
+Layer 1 is a contained refactor of two functions that already have the
+right loop shape. Layer 2's hard half (fixed-schema construction) already
+exists as the retained path; the new code is the handle, first-write
+bootstrapping, and errors. Layer 3 reuses both. Ship order: Layer 1+2
+(Writer, both formats) before the 3.0 release — it converts the release's
+one structural regression into a headline feature and unblocks Pioneer;
+Layer 3 (stream append) with it if review goes smoothly, else in 3.0.x
+(SpineOpt/Agents migrate to `Arrow.Writer` either way).
diff --git a/docs/dev/DESIGN-nested-public-values.md b/docs/dev/DESIGN-nested-public-values.md
new file mode 100644
index 00000000..93b1c625
--- /dev/null
+++ b/docs/dev/DESIGN-nested-public-values.md
@@ -0,0 +1,146 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+--->
+
+# Nested public values
+
+## The rule
+
+The public value domain is uniform at every depth. A facade-converted leaf
+— Date32/Date64, Time, Timestamp (zone-naive and zone-declared), Duration,
+supported Decimal, Interval — materializes as the same public Julia value
+whether it is a top-level column, a dictionary pool, a run-end-encoded
+values child, a union branch, a struct field, or a list/map element. The
+same holds in reverse: the writer accepts those public values at every
+depth, fresh and retained.
+
+This replaces the pre-3.0-release rule where only the top level and
+dictionary encoding converted, and nested temporal leaves stayed raw
+storage integers inside `Vector{Pair{String,Any}}` / `Vector{Any}` rows
+(the `converted::Bool` threading through `_declaredeltype`, and
+`_rawdeclaredbasetype`). That asymmetry — and the write-side refusal of
+nested public values that mirrored it — is removed.
+
+## Layering
+
+* **ArrowCore stays the storage authority, untouched.** `AC._value`,
+  `AC.materialize`, and `AC.fromjulia` keep the storage domain: raw counts
+  for temporals, raw coefficients for decimals. They serve the C interface
+  and conformance. Core
+  keeps zero knowledge of Dates/Durations/DataDecimals public types and
+  remains trim-compileable on its own.
+
+* **One leaf-conversion authority in the facade.** A single mapping per
+  convertible leaf descriptor supplies the triple (public element type,
+  storage→public scalar, public→storage scalar). `_facadebasetype` (types),
+  `_publicleafvalue` (storage→public; the per-element body `_postconvert`
+  loops), and `_exactfacadescalar`/`_facadetoken` (public→storage) are that
+  authority. Every reader, writer, and scan-planner rule reads it; no
+  second copy of any conversion exists.
+
+* **The facade owns a recursive public row builder.** For composite and
+  wrapper roots the facade builds rows itself (`_publicvalue`), mirroring
+  Core's `_value` shapes — `Vector{Pair{String,Any}}` struct rows,
+  `Vector{Any}` list rows, `Pair{Any,Any}` map rows — but converting leaf
+  values through the authority AS the row is built. Union branches convert
+  at build time, while the type id is in hand (a built row cannot recover
+  its branch, so post-hoc conversion is impossible; this is why conversion
+  moved into row construction). Top-level scalar columns keep the typed
+  bulk path plus one whole-column conversion pass; run-end-encoded and
+  dictionary roots keep their flat expansion plus one whole-column pass
+  over the values domain (the expansion output is governed by one
+  descriptor, so the one-pass rewrite stays valid and fast).
+
+* **Declared types have no `converted` flag.** `_declaredeltype(f)` walks
+  the field tree and every leaf answers with its public type. Empty,
+  all-missing, and populated columns of one field agree by construction.
+
+* **The writer is symmetric.** Fresh composite columns accept public leaf
+  values (a `NamedTuple` field of `DateTime` or `Timestamp{P}` lowers
+  through the authority instead of refusing), and retained write-back
+  lowers nested public values through the same public-to-storage authority
+  the top level uses (`_retainedstorage`/`_facadetostorage` over
+  `_exactfacadevalue`). A value that cannot lower exactly refuses,
+  exactly as at the top level.
+
+* **ArrowTypes-labeled subtrees are a different domain on purpose.** An
+  extension-labeled field routes through the ArrowTypes contract
+  (`ArrowType(T)`-declared storage views); registered mappings written
+  against that interface keep working unchanged. The boundary is the
+  extension label, as before.
+
+* **The allocation budget covers the dynamic rows' overhead, not just their
+  payload.** The per-row builders run dynamically typed, so each value
+  leaves transient boxes beside the payload Core's budgeted `getvalue`
+  reserves. The facade charges a fixed measured-worst-case reserve at each
+  seam: per converted leaf (facade and raw-domain restoration), per
+  shared-decimal `_postconvert` element (the one type-unstable `_mapcol`
+  body — the stable bodies charge nothing extra), per routed-walker leaf
+  (Core's transient estimate object), per value lifted through a
+  registered `fromarrow` hook (fixed reserves split three ways: childless
+  scalar storage, width-charged container storage, and union or
+  transparent-wrapper storage), per struct-hook child (the `applicable`
+  probe and the variadic hook call re-splat and re-box every child
+  value) plus the row's inline payload size (reconstruction copies isbits
+  storage wholesale at each seam, so struct charges scale with
+  `sizeof` of the constructed row — heap children count as pointer
+  slots), per lifted string's byte length (the default ArrowTypes pointer
+  adapter copies it), and per nested restoration call
+  (`_chargerestoredelements!`, the dynamic keyword-call tuple, with an
+  extra share on the raw-domain struct tail). The other
+  half of the model is staying allocation-free where no reserve exists:
+  null slots return `missing` before the budgeted extraction (NullType
+  first — its layout has no validity buffer), every per-value cache
+  lookup (`_arrowtypestarget`, `_hasarrowtypesextension`, the eltype,
+  dictionary-field and storage-type memos) returns hits without
+  constructing the memoization thunk, the wide-decimal scalar conversion
+  runs unboxed behind `_shareddecimalscalar`'s type barrier, restoration
+  loops hand child Fields to dynamic calls through the per-Field
+  `_arrowtypesboxedchildren` cache instead of re-boxing them per row, the
+  struct and map branches read their storage base type from the target
+  and eltype caches instead of rebuilding it per row (an unknown label
+  keeps the direct computation: its cached slot holds the bounded
+  fallback shape), and the row-lifting loop boxes its `Field` once behind
+  `_boxonce`, which the optimizer cannot fold away. The reserves were
+  sized by measuring
+  flat/union/REE/struct/list roots × timestamp/decimal/date leaves ×
+  unlabeled/unknown-label/registered-label shapes; a nestedvalues testset
+  pins per-value charge floors for each seam and (on current Julia) that a
+  warmed read allocates no more than it charges.
+
+## Trim contract
+
+Two tiers, by what the caller knows statically:
+
+* **Dynamic schema** (runtime-discovered): the recursive builder is
+  dynamic dispatch over `Any`-shaped rows and is NOT trim-guaranteed.
+* **Static schema**: two surfaces. Core's typed `getvalue(::Type{T}, ...)`
+  and `materialize(::Type{T}, ...)` claims stay the storage-domain
+  monomorphic tier and remain part of the trim workload, unchanged. The
+  facade's typed select override (`:col => NamedTuple{...}`, recursively,
+  including `Vector{...}` targets) converts each value with `convert`, as
+  `Tables.scan` does. It is a convenience over the dynamic rows and is not
+  trim-audited; making the whole facade trim-compileable stays future work.
+
+The typed tiers share no code with the dynamic row shapes, so the dynamic
+`Pair{String,Any}` containers cost them nothing.
+
+## Scans
+
+Scan filters evaluate on the public values a full read returns, composite
+columns included: plain Julia `==` over public rows is the semantics.
diff --git a/docs/dev/DESIGN-scan-ranges-trim.md b/docs/dev/DESIGN-scan-ranges-trim.md
new file mode 100644
index 00000000..44f877b5
--- /dev/null
+++ b/docs/dev/DESIGN-scan-ranges-trim.md
@@ -0,0 +1,323 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# Design: Tables.Scan pushdown, cloud byte-range reads, and the trim contract
+
+Implemented in `src/scan.jl` and `src/source.jl` and exposed through the
+facade (`Arrow.Table(source; scan=…)`, the `select`/`drop`/`filter`/`limit`/
+`offset` keywords, and `Arrow.Stream`); §4 lists what is and is not built.
+The pieces share one mechanism: **a bound column set drives both what gets
+decoded and what gets fetched, and every request value is plain data intended
+to remain visible to the trim verifier.** Section 3 separates that design
+intent from what the trim harness actually compiles.
+
+---
+
+## 1. Tables.Scan support
+
+`Tables.Scan` (Tables.jl 1.14) is a plain-data scan request: select, rename,
+and type items, a closed predicate algebra (`Cmp`/`In`/`IsNull`/`StrPred`/
+`And`/`Or`/`Not`, with `OpNode` as the growth channel), and `limit`/`offset`.
+Arrow resolves each request once against the source schema with
+`Tables.resolve` (`_ScanPlan`) and executes the bound request itself. Key
+contract points this design leans on:
+
+- a pushed result must equal the generic executor's over the same scan, row
+  for row (the differential battery pins this for every source kind);
+- `limit`/`offset` may be consumed **only** over exactly filtered rows;
+- no `Function` values in `Scan` or predicate data: the request algebra is
+  closed and value-only.
+
+### One planner, one executor
+
+Every read goes through one planner and one executor, whatever the source:
+a memory-mapped file, a byte vector, an `IO` read whole, a byte-range source
+such as a cloud object, or stream-format input. A whole read is the scan that
+selects every column.
+
+    plan(scan, fields) = resolve once against the schema names →
+      check literal kinds against their columns (`_checkliterals`) →
+      give zone-free time literals a UTC column's zone (`_zonedbound`)
+
+    _scanfile(src, footer, plan) =
+      one pass over every Block's metadata (a region serves it in place; a
+      byte-range source fetches it in coalesced ranges that also cover the
+      start of each body) →
+      row counts → the batch window when there is no filter →
+      the decode set's dictionaries, in footer order →
+      a decode plan per batch in the window → _runscan
+
+    _scanstream(stream) =
+      frame the messages, apply dictionaries in stream order, and plan each
+      record batch against the dictionaries in effect for it → _runscan
+
+    _runscan(records, plan) =
+      no filter and no window: decode the decode set of every batch on up to
+      `ntasks` tasks and build the columns a full read builds;
+      otherwise, per batch: decode the filter columns, evaluate the filter on
+      their public values (`Tables.filtermask`) in chunks of rows, then decode
+      the other selected columns only if a row qualifies, and keep copies of
+      the qualifying rows; without `limit` or `offset` batches run on up to
+      `ntasks` tasks, with a window they run in order and stop once it is full
+
+`Arrow.Stream` runs the same executor over one batch at a time.
+
+A region (a mapped file or a byte vector) is its own span provider: one span
+over the whole region serves every range the planner names, without a copy.
+A byte-range source fetches each round's ranges through `readrange`,
+coalesced, and a fetched range is referenced in place by the columns that
+read it, unless a select's columns fill less than half of it: then their
+bytes are copied out, so a few columns do not keep a whole fetched range
+alive. The planner is the same for both; only the fetch differs.
+
+### What Arrow pushes, by axis
+
+| Axis | Mechanism |
+|---|---|
+| `select` | only the decode set (selected ∪ filter columns) is decoded; `skipfield!` advances the node and buffer cursor past every other field with each buffer-table invariant checked, without slicing, decompressing, or validating its body; over a byte-range source no body range is planned for it |
+| `limit`/`offset` | without a filter, `RecordBatch.length` is wire metadata: batches outside the window are never decoded or fetched; with a filter, the window composes over the qualifying rows, in order, and the scan stops once it is full |
+| `filter` | evaluated per batch over the public values of the filter columns, the values a full read returns; the other selected columns are decoded (and over a byte-range source, fetched) only for batches with a qualifying row |
+| `types` (`ref => T`) | an elementwise `convert` after the scan, as the generic executor applies it. Two overrides read stored values for their own output instead: a time of day as a `Dates.Period`, which also reads times outside a day, and a `JuliaLang.Symbol` column as strings, which creates no `Symbol`. Another output of the same column, and a filter on it, read its public values |
+
+The filter is evaluated by the generic evaluator over the batch's public
+values, so pushdown and the executor share one three-valued semantics by
+construction (a `missing` predicate excludes the row), and every predicate a
+user can write pushes down: no literal needs a stored-value form.
+
+Element types do not depend on the source kind or on a filter; container
+types do. A read that keeps every row of the batches it reads builds the
+columns a full read builds: views of the source, `ChainedVector`s across
+batches, and string columns over the source's bytes. A read with a filter or
+a window keeps copies of its rows: `Vector`s for flat and nested values,
+string and binary columns that hold just their values' bytes, and dictionary
+columns that keep their pool, so a filtered flat or string column does not
+keep a batch's decompressed bytes or the mapping alive for a few of its rows.
+Kept nested rows still read their batch's child buffers. An empty result
+column has the type a read of no batches gives it.
+
+Properties the composition holds:
+
+- **Positional filter references resolve to source names** before
+  evaluation (`Tables.resolve` normalizes them).
+- **Wire row counts are trusted only after metadata validation.** Before a
+  `RecordBatch.length` drives a window, it is range-checked and matched to
+  every top-level FieldNode length. The rows of all batches together must fit
+  Tables' `Int` row count, whatever the window keeps.
+- **One scan has one allocation budget,** shared by footer work, metadata,
+  fetched ranges, decompression, and column building.
+- **Windows saturate.** `offset`/`limit` compose with `min` arithmetic over
+  row counts, so `offset + limit` never overflows.
+- **Zero-field sources** read their row counts from metadata; a filter that
+  reads no column evaluates once per batch, and no per-row mask is allocated
+  from an untrusted row count.
+- **A scan checks only what it reads.** Every Block's metadata is verified,
+  but the body of a dictionary outside the decode set, or of a record batch
+  outside the window, is never read, so damage there does not fail the scan.
+
+---
+
+## 2. Cloud byte-range reads
+
+### Why the format already supports this
+
+The IPC **file** format is: magic · messages · Footer(schema, dictionary
+Blocks, record Blocks) · footer-length · magic. Every Block carries
+`(offset, metaDataLength, bodyLength)`; every RecordBatch header carries a
+per-buffer `(offset, length)` table within its body; the registry walk maps
+buffer indices → fields deterministically (the exact mechanism
+`decodefield`/`encodefield!`/`skipfield!` share). So the fetch plan for
+"columns X, Y of batches 3..7" is pure arithmetic over two small metadata
+reads. Compressed buffers are self-contained (per-buffer prefix + frame), so
+they range-fetch identically. The **stream** format has no footer and stays
+sequential — cloud-native access is a file-format feature, stated plainly.
+
+### The fetch protocol
+
+1. **Tail fetch** (one range request, cached on the handle): the last
+   `tailbytes` (default 64 KiB). Its trailing magic decides file vs stream
+   format (a stream object is read whole instead), and it covers
+   footer-length + magic + the whole Footer in almost every real file; if
+   `footerlen + 10 > tailbytes`, one exact follow-up fetch (also cached).
+   → schema and Block indexes. The leading magic is not fetched: the Footer
+   is the sole authority.
+2. **Block metadata fetches**: the metadata of every dictionary and record
+   batch Block, each with the start of its body (all of a body up to four
+   `gapbytes`, else its first `gapbytes`), coalesced across nearby spans. A
+   scan with a row window reads metadata alone. RecordBatch row counts are
+   here, not in the Footer, so the window is chosen after this pass.
+3. **Window and buffer-range plan**: row counts choose the batch window when
+   there is no filter; the decode set then maps to a buffer index set
+   (subtree-inclusive; dictionary Blocks for the decode set's dictionaries,
+   including those a dictionary's values use) → byte ranges → **coalesce**
+   ranges with gaps below `gapbytes` (default 256 KiB — a gap fetch is usually
+   cheaper than a request round-trip).
+4. **Body fetches**: the decode set's dictionary bodies and the record bodies
+   the executor reads first (every decode-set column without a filter; the
+   filter columns with one) in one round. A filter then fetches the other
+   selected columns of the batches that keep rows in one more round; a
+   filtered `limit` fetches batch by batch (a body of at most four `gapbytes`
+   with all its decode-set columns in one round) and stops when it is full,
+   freeing each batch's bytes once it is read. Each coalesced range lands in its own
+   owned heap region; decode resolves each declared buffer `(offset, len)` to
+   its containing fetched range and subslices it: *every buffer must fall
+   inside a fetched range that was itself derived from the verified buffer
+   table*, the message-body authority invariant with sparse backing.
+
+Request-count model (what matters against cloud latency): `1` tail (plus one
+exact Footer follow-up when the tail is too small) + `⌈metadata spans after
+coalescing⌉` + `⌈coalesced body ranges⌉`. A read without a filter makes
+three sequential rounds, a filtered read four. The source can issue a round's
+ranges concurrently. For a 40-column file reading 3 columns of every batch,
+this moves roughly `3/40` of the body bytes plus metadata. Coalescing is an
+explicit over-read policy: a requested span may cross unneeded bytes when the
+configured gap permits it.
+
+`Arrow.Stream` over a byte-range file source reads the footer and the
+dictionaries when it opens. A batch that decodes every column, or whose body is
+at most four `gapbytes`, reads its whole block, and the blocks after it while
+they fit 8 MiB, with one window fetched ahead. A batch that decodes some
+columns of a larger body reads its metadata with the start of its body, then
+the ranges of its decode set it lacks.
+
+### The interface (no HTTP/CloudStore deps in Arrow)
+
+Arrow defines a minimal source contract (`src/source.jl`) and owns the
+planner; transports live in extensions:
+
+    abstract type AbstractArrowSource end
+    sourcelength(src)::Integer                  # total object length, known up front
+    readrange(src, offset, len)::Vector{UInt8}  # one exact range, 0-based offset
+    concurrentreads(src)::Int                   # default 1
+        # Arrow reads a round's planned ranges through readrange with a
+        # handle-wide worker pool, capped by Limits.max_concurrent_reads,
+        # storing every result by request index —
+        # a source's completion order can never permute payloads, and the
+        # reads in flight are bounded whatever the span count.
+
+- `Arrow.Table(src; …)` builds the internal `SourceFile(src; limits,
+  tailbytes, gapbytes)` handle and reads through the planner; the source's
+  length is read once, at handle construction, and the tail once per handle.
+  `Arrow.Table(src)` without a scan, or over a stream-format object, reads
+  the object whole in 8 MiB ranges (one request beyond the cached tail for a
+  source that reads one range at a time).
+- One `SourceFile` samples `concurrentreads` once and shares one semaphore
+  across its operations. Separate handles are independent; a transport that
+  requires one wider cap enforces it in `readrange`.
+- The abstract type is a dynamic call under `--trim` for a source type the
+  trimmed app never mentions; an app that names its concrete source type
+  resolves statically. The planner itself is arithmetic over `Int64`s.
+- Extension: `ext/ArrowCloudStoreExt.jl` (loaded with CloudStore.jl) makes
+  a `CloudStore.Object` a source — its known `size` is the length, one
+  range is one HTTP `Range` GET pinned to the object's ETag with
+  `If-Match`, and `concurrentreads` is 16 — and adds `Arrow.Table(::CloudStore.Object; …)` and
+  `Arrow.Stream(::CloudStore.Object; …)`. An HTTP transport is the same two
+  methods. Zero new hard deps.
+- The differential test: sparse fetch ≡ whole-file read, plus
+  request-count/byte-count/range assertions on a counting test source
+  (`test/scan_battery.jl`, `test/ranged_scan_tests.jl`), and the CloudStore
+  extension end to end against a local S3-compatible server
+  (`test/cloudstore_tests.jl`).
+- Explicitly out of scope, documented: caching/prefetch policy beyond
+  coalescing and `Arrow.Stream`'s read-ahead, retries (the source's job),
+  writers over ranges, stream format (read whole), mutation detection (ETag
+  pinning is the extension's concern).
+
+The ranged reader deliberately uses the Footer schema as its sole schema
+authority. It does not parse or cross-check the leading schema message or
+optional EOS marker, although a head, tail, or coalesced request can physically
+over-read those or other unrequested bytes. The complete Footer Block index is
+bounded and checked for overlap. Required features and message limits are
+global. Per-record metadata/body/buffer limits stay lazy like `ArrowFile`:
+every dictionary and record block's metadata is checked. Message kind,
+version, legacy-compression state, complete node/buffer metadata,
+layout-derived buffer minima, child extents, and fixed or fully-covered
+null-count contracts for planned subtrees, planned codec, and required
+dictionary presence are validated before any planned body range is requested.
+Skipped buffer contents remain unvalidated by design.
+
+---
+
+## 3. The trim contract (staying on the radar, explicitly)
+
+**Trimmability is a standing production gate, not an aspiration.** The
+`--trim=safe` harness (0 errors / 0 warnings / binary exit 0) compiles
+`ArrowCore` plus its value-domain and typed-value workloads and the C-data
+seams, plus a representative DataStrings workload. It does **not** yet compile
+a scan-and-materialize app, so §1–§2 are designed for trim but not yet gated by
+it. The rules in `core-README.md` ("Trim-compile support") constrain their form:
+
+- `Tables.Scan` is trim-aligned by its own charter (no `Function` fields;
+  closed algebra). The evaluator uses the same closed-set `isa` ladder
+  pattern as `layoutspec_of`; `OpNode` rejection keeps the set closed.
+  `resolve` is plain data → plain data.
+- The range planner is arithmetic over `Int64`s; a trimmed app that names
+  its concrete `AbstractArrowSource` type resolves the source calls
+  statically. No dynamic registry on the hot path.
+- **Two-tier public API**: the runtime-tagged
+  core is inherently trim-safe — descriptors are values, accessors use
+  literal load widths, struct scalars are `Vector{Pair{String,Any}}`. So:
+  - **Tier 1 (trim target)**: the value-domain entry points —
+    open/scan/materialize returning value-domain data, plus C-data/stream
+    interop and the typed `getvalue(::Type{T}, …)`/`materialize(::Type{T}, …)`
+    path. A harness compiling a scan-and-materialize app at 0/0/exit-0,
+    kept permanently in CI, is what would make the scan half guaranteed.
+  - **Tier 2 (dynamic, ergonomic)**: the typed facade (`Arrow.Table`
+    property access, NamedTuple rows) — explicitly NOT trim-guaranteed.
+  - **The known-schema bridge**: `Scan`'s `ref => Type` overrides ARE the
+    known-schema declaration. In a trimmed app, a scan with concrete type
+    pins can drive the typed-column path whose element types are statically
+    known (`Vector{Int64}`, `Vector{Union{Missing,Float64}}`, …) through
+    closed-width branches — "provide a known schema and get typed columns,
+    trimmed" falls out of the same plain-data request, no second schema
+    surface needed.
+
+---
+
+## 4. Status
+
+Implemented (`src/scan.jl`, `src/table.jl`, `src/source.jl`):
+
+- **One planner and one executor** for every source, as decided on Aug 19
+  2026: memory-mapped files, byte vectors, an `IO` read whole, byte-range
+  sources, and stream-format input. A region serves the planner's ranges in
+  place, a byte-range source fetches them in coalesced rounds, and
+  `Arrow.Stream` runs the executor over one batch at a time. `skipfield!`
+  skips what the scan does not decode; `_ScanPlan` resolves a request once;
+  `_runscan` reads filter columns first, evaluates filters on public values in
+  chunks of rows on up to `ntasks` tasks, and decodes the other selected
+  columns only for batches that keep rows.
+- **Byte-range sources**: the `AbstractArrowSource` contract, the
+  `SourceFile` fetch protocol, the coalescing planner, `SparseBody` decode,
+  the CloudStore.jl extension, and counting-source proofs (zero planned body
+  ranges for skipped columns, window-excluded batches, and unneeded
+  dictionary bodies, with exact request-log checks under the fixtures'
+  tail/coalescing settings).
+
+Not implemented: an HTTP transport extension (the source contract is the
+extension point; the CloudStore extension is the model) and the
+scan-and-materialize trim harness. `Arrow.Stream` decodes every dictionary
+batch of a file when it opens, including those of columns it does not
+select.
+
+Possible future work: per-batch statistics (row counts, null counts, minimum
+and maximum values) in IPC footers, to prune batches a filter cannot match
+before their metadata is fetched. The Arrow statistics schema standardizes
+the value layout but not a placement in IPC files; without a placement other
+implementations read, a private key would help only Julia readers of files
+Julia wrote, and wrong statistics silently drop rows.
diff --git a/docs/dev/core-README.md b/docs/dev/core-README.md
new file mode 100644
index 00000000..5212f674
--- /dev/null
+++ b/docs/dev/core-README.md
@@ -0,0 +1,234 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# The Arrow.jl engine
+
+Arrow.jl separates the Arrow memory layout from its transports and Julia table
+interface. `ArrowCore` owns descriptors, buffers, and validation. IPC and C data
+adapters consume those values. The table facade presents Julia columns and
+Tables.jl operations; the writer converts those columns back into Arrow buffers.
+`ArrowCore` is an internal module, not a separately versioned package.
+
+The user guides describe the supported [types](../src/types.md),
+[read operations](../src/reading.md), [writes](../src/writing.md),
+[streams](../src/streams.md), and [limits](../src/limits.md). This document explains
+where those contracts are implemented and the constraints on changing them.
+
+## Code map
+
+| File | Responsibility |
+|---|---|
+| `src/ArrowCore.jl` | Ownership regions, checked buffer slices, type descriptors, fields, schemas, array layouts, validation, and low-level builders/accessors |
+| `src/FlatBuffers/`, `src/metadata/` | Vendored FlatBuffers runtime and generated metadata bindings/verifier; `tools/fbsgen.jl` regenerates the latter from the vendored schemas |
+| `src/ipc_read.jl` | Framing, limits, metadata decoding, layout decoding, decompression, the stream reader, and the file reader |
+| `src/ipc_dictionary.jl` | Dictionary snapshots, replacement and delta updates, shared IDs, and dictionary dependencies |
+| `src/ipc_write.jl` | IPC encoding, batch emission, file footers, compression, and incremental writer state |
+| `src/cdata.jl`, `src/cstream.jl` | C data and C stream import/export of Core arrays, release callbacks, and foreign ownership |
+| `src/cdata_table.jl` | `Arrow.Table`, `Arrow.Stream`, and Tables.jl tables across the C data and C stream interfaces |
+| `src/source.jl` | Byte-range sources and read scheduling; `ext/ArrowCloudStoreExt.jl` supplies the CloudStore integration |
+| `src/columns.jl` | Read-only buffer views, typed nested rows, dictionary/run-end columns, and deferred string construction |
+| `src/table.jl` | `Table`/`Stream`, source opening, Tables.jl and DataAPI interfaces, copying, and public value conversion |
+| `src/scan.jl` | Scan binding, the planner and executor every read uses, filters, row windows, and sparse ranged reads |
+| `src/arrowtypes.jl`, `src/sharedvalues.jl` | ArrowTypes mappings and the shared string, decimal, and temporal value domains |
+| `src/columnconstruction.jl` | Native and custom column construction, retained schemas, nested layouts, and dictionary pooling |
+| `src/write.jl` | Public write options, partition iteration, `Writer`, append, and destination ownership |
+| `src/precompile.jl` | Representative public reads and writes used to prepare the package image |
+| `src/ArrowTypes/` | The separately registered ArrowTypes interface package; it is developed with Arrow in this repository |
+
+The only exported compatibility binding is `ArrowTypes`. Public entry points are
+listed in `src/Arrow.jl`; implementation helpers are not part of that API.
+
+## Buffers and lifetime
+
+An `ArrayData` describes a column through checked `BufferSlice`s, child arrays,
+an optional dictionary, and a logical offset and length. Each slice retains an
+`OwnerRegion`: a pointer, extent, alignment, GC root, and shared release cell.
+The layout registry describes buffer roles and child shapes. IPC dictionary IDs
+stay in the adapter; Core dictionaries describe their values and index layout.
+
+Low-level access checks bounds and the region's release cell. Releasing a foreign
+owner revokes its regions and invokes the producer's callback exactly once.
+An export keeps its roots until the consumer has released every C node of it;
+the release callbacks only count the nodes off, and later exports or garbage
+collections free the export. Re-exporting imported data roots the foreign owner
+the same way.
+
+The public table facade has a different lifetime contract. Its numeric and nested
+columns keep their backing storage alive and read without a per-element release
+check. `release!(table)` prevents later column retrieval; `release!(stream)` also
+prevents iteration. Columns already handed out remain valid. Facade memory maps
+are therefore unmapped by GC after the table and its columns become unreachable,
+not eagerly by `release!`. A low-level region can use eager release where its
+caller controls every access. Keep these two contracts separate.
+
+Input byte vectors and borrowed Julia vectors must not be resized or changed
+while a read or low-level view uses them. External truncation of a mapped file
+can cause a process-level bus error; the facade cannot guard against it. The
+reader's `mmap=false` option avoids that dependency. Replacing an existing string
+path through `Arrow.write` uses a temporary file and rename, so existing mappings
+continue to see the old file.
+
+C pointers carry declared extents, not verifiable allocation sizes. The C data
+producer must keep those allocations alive and unchanged until release. Exported
+callbacks run Julia code: call them from Julia-attached threads, and serialize
+calls on one C stream. The interfaces do not supply a foreign-thread trampoline.
+
+## Reading and validation
+
+IPC framing and the generated FlatBuffers verifier check sizes and metadata
+geometry before metadata-directed allocations. Every batch buffer belongs to a
+checked slice of that message's body. Compressed buffers decode into bounded,
+exact-sized outputs; declared lengths and codec consumption are checked. Both
+LZ4_FRAME and ZSTD are supported, including the stored-raw buffer sentinel.
+
+Structural validation checks layout geometry. Semantic validation checks the
+conditions needed to read those layouts safely. `validate_full` adds stricter
+content checks such as UTF-8, decimal precision, time-of-day range, advisory
+nullability, and canonical bitmap padding. These are distinct contracts: do not
+turn an optional content check into an unconditional reader refusal without
+checking interoperability and the public type conversion that follows it.
+
+File reads use the footer's schema and batch index, including files whose data
+section has no leading schema message. Stream reads consume messages in order.
+Dictionary replacements and deltas publish new pools; earlier batches retain
+their own snapshots. File indexes and ranged reads must preserve the same
+values when dictionary updates and record batches occur in different orders.
+
+`Arrow.Table` exposes read-only views for primitive, Boolean, dictionary,
+run-end, list, map, and struct layouts. Multi-batch columns use
+`SentinelArrays.ChainedVector`. Native scalar conversions preserve the shared
+public domains at every depth: Durations timestamps, DataDecimals decimals,
+and the supported date/time/interval values. Custom ArrowTypes mappings may
+require materialization.
+
+String and binary columns use DataStrings. The reader reserves their construction
+budget up front and builds their payloads on first column access. Owned
+decompression buffers can be retained; other input bytes are copied into
+DataStrings buffers. Opening a table alone does not pay all of that work.
+`stringtype=String` instead constructs Julia strings, including nested
+strings. A benchmark that claims to read every column must retrieve every column
+inside its timing. Neither retrieval nor `length(column)` visits every value in
+a numeric or nested view.
+
+`Arrow.Limits` bounds metadata, array sizes, concurrent reads, new Symbol values,
+and allocated output. The allocation allowance depends on input bytes, with a
+minimum of 256 MiB and the caller's `max_total_allocated_bytes` ceiling. Compressed
+input receives allowance for its supported decompressed data. Each stream batch
+has its own budget, so a long stream is not charged against one cumulative cap.
+The accounting bounds package-controlled work; it does not measure arbitrary
+user-defined conversion hooks or the entire process heap.
+
+## Scans and ranged sources
+
+`Tables.Scan` is available from registered Tables.jl 1.14 or later; no source
+revision is required. The facade accepts it directly and translates its simpler
+read keywords into the same plan. Binding and column selection happen once per
+request; filters run on the public values a read returns.
+
+Every read goes through one planner and one executor (`scan.jl`), whatever the
+source: a region in memory (a mapped file, a byte vector, an `IO` read whole), a
+byte-range source, or stream-format input. A scan decodes the selected columns
+and those its filter reads. Without a filter, offsets and limits select batches
+by their row counts. With a filter, the filter columns are read first, the other
+selected columns only for batches with a qualifying row, and qualifying rows are
+counted before applying the result window. Kept rows are copied; a read that
+keeps every row builds a full read's views. Type overrides convert after the
+scan. Repeated top-level names receive unique suffixes before selection and
+metadata lookup.
+
+`SourceFile` uses a byte-range source's footer and index to request needed metadata
+and buffers. Adjacent ranges may be coalesced under `gapbytes`; concurrency is
+bounded by the source and reader limits. `Arrow.Stream` reads one batch at a time
+through the same executor, with read-ahead for whole batches. Do not infer a bound
+on bytes fetched from a bound on rows returned: filtering can still require
+reading buffers for rows that are later rejected.
+
+Schema and field metadata remain ordered pairs so duplicate metadata keys and
+their ordering can survive a retained-schema rewrite.
+
+## Writing and concurrency
+
+`write` and `Writer` share the incremental IPC machinery. They consume one
+partition at a time and divide it into record batches. `batchsize` caps rows;
+overflow of a 32-bit string/list offset splits a batch further. The source
+partition itself remains live while its batches are written. Reused construction
+buffers and dictionary pools also contribute to peak memory, so a row-count cap
+is not a byte quota on arbitrary input iterators.
+
+`ntasks` bounds work on independent columns and compression buffers. Publication
+and dictionary state remain ordered. Output must be independent of the task
+count, and a single caller owns a `Writer`; overlapping writes are unsupported.
+Readers similarly parallelize suitable column construction while preserving
+batch order and ownership.
+
+The first input establishes an incremental writer's schema. Later inputs use
+compatible conversions and the declared nullability policy. Dictionary pools can
+grow: file output normally emits the complete dictionary at close, while stream
+output emits an updated dictionary before the next dependent batch. Delta and
+replacement modes have explicit options and consumer compatibility constraints
+in the [stream guide](../src/streams.md). `append` resumes an existing IPC stream's
+schema and final dictionary state; it does not append to the random-access file
+format.
+
+Fresh Julia columns and retained-schema rewrites use the same recursive column
+constructor. Retained descriptors remain authoritative where values and views
+preserve enough information to reproduce them. Unsupported reconstruction must
+fail instead of silently relabeling values. `dictencode=false` deliberately writes
+pooled columns as plain values, while `DictEncode` remains an explicit encoding
+request. Automatic dictionaries use DataAPI ref pools; optional CategoricalArrays
+methods preserve ordered categories. These hooks avoid making DataFrames or CSV
+runtime dependencies.
+
+## Verification and compilation
+
+On Julia 1.10, develop ArrowTypes explicitly because that Julia version does not
+read `[sources]` entries:
+
+```sh
+julia --project=. -e 'using Pkg; Pkg.develop(path="src/ArrowTypes"); Pkg.instantiate()'
+julia --project=. -e 'using Pkg; Pkg.test()'
+julia --project=. test/fuzz.jl --cases 16 --mutations 64
+julia --startup-file=no test/trim_compile_tests.jl
+julia --startup-file=no conformance/run.jl
+julia --project=. bench/run.jl
+julia tools/fbsgen.jl src/metadata/fbs src/metadata
+```
+
+The package suite includes Core, public interfaces, optional integrations,
+frozen Arrow 2.x fixtures, corruption cases, and four adapter acceptance suites.
+The deterministic fuzzer records seeds and replay artifacts. Conformance compares
+IPC with the pinned Apache corpus and PyArrow/nanoarrow, and exchanges actual
+C data/C stream pointers with PyArrow in one process. `conformance/run.jl` prepares
+a Docker image and its Julia/Python environments; direct tool and corpus versions
+are pinned in the conformance files, while transitive dependencies and the base
+image are not fully locked.
+
+The trim gate exercises a specific low-level Core/C data workload and requires
+zero verifier warnings or errors plus a runnable binary. It does not establish
+that arbitrary table schemas, custom mappings, or the complete facade compile
+under `--trim=safe`. Closed descriptor dispatch, concrete containers, and runtime
+C-function pointers keep that workload compilable. Never store raw `@cfunction`
+pointers in module-level constants: precompilation cannot preserve their runtime
+addresses.
+
+The public precompile workload and invalidation regression test cover a separate
+concern: loading other data packages should not force Arrow's common operations
+to compile again. Abstract extension calls use bounded specialization and
+inference barriers where required. Preserve these boundaries when adding public
+methods, and measure first use separately from warmed throughput.
diff --git a/docs/make.jl b/docs/make.jl
index b26c44bc..0d3c31db 100644
--- a/docs/make.jl
+++ b/docs/make.jl
@@ -22,16 +22,27 @@ makedocs(;
     modules=[Arrow],
     repo=Remotes.GitHub("apache", "arrow-julia"),
     sitename="Arrow.jl",
+    # The reference page documents the public surface explicitly; internal
+    # helpers carry docstrings for maintainers and are not part of the site.
+    checkdocs=:public,
+    checkdocs_ignored_modules=[Arrow.ArrowCore, Arrow.FlatBuffers, Arrow.Meta],
     format=Documenter.HTML(;
-        prettyurls=get(ENV, "CI", "false") == "true",
+        prettyurls=true,
         canonical="https://arrow.apache.org/julia/",
         assets=String[],
     ),
     pages=[
         "Home" => "index.md",
-        "User Manual" => "manual.md",
-        "API Reference" => "reference.md",
+        "Reading" => "reading.md",
+        "Writing" => "writing.md",
+        "Streams and IPC" => "streams.md",
+        "Type mapping" => "types.md",
+        "Limits and errors" => "limits.md",
+        "C data interface" => "cdata.md",
+        "Migrating from Arrow.jl 2.x" => "migration.md",
+        "API reference" => "reference.md",
     ],
+    pagesonly=true,
 )
 
 deploydocs(; repo="github.com/apache/arrow-julia", devbranch="main", branch="asf-site")
diff --git a/docs/src/cdata.md b/docs/src/cdata.md
new file mode 100644
index 00000000..bbf0faa9
--- /dev/null
+++ b/docs/src/cdata.md
@@ -0,0 +1,161 @@
+```@raw html
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+```
+
+# C data interface
+
+The Arrow [C data interface](https://arrow.apache.org/docs/format/CDataInterface.html)
+and [C stream interface](https://arrow.apache.org/docs/format/CStreamInterface.html)
+hand tables to another Arrow implementation in the same process, such as pyarrow, Polars,
+or DuckDB through PythonCall, as pointers to Arrow buffers instead of IPC bytes. The
+producer fills C structs (`ArrowSchema`, `ArrowArray`, `ArrowArrayStream`); the consumer
+moves them out and calls their `release` callbacks when it is done.
+
+[`Arrow.export_stream!`](@ref) exports any Tables.jl table as a stream of record batches
+and [`Arrow.to_c_data`](@ref) as one record batch; [`Arrow.Table`](@ref) and
+[`Arrow.Stream`](@ref) import from pointers to the structs. An exported table is built
+as [`Arrow.write`](@ref) builds it, so the other implementation sees what it would read
+from the IPC bytes, and an imported table has the column types an IPC read gives.
+
+With PythonCall, a `DataFrame` goes to pyarrow and a pyarrow table comes back like this:
+
+```julia
+using Arrow, PythonCall, DataFrames
+pa = pyimport("pyarrow")
+
+# Julia -> pyarrow: any Tables.jl table, as a stream of record batches
+df = DataFrame(id=1:3, name=["a", "b", missing])
+stream = Ref{Arrow.CArrowArrayStream}()
+pytable = GC.@preserve stream begin
+    p = Base.unsafe_convert(Ptr{Arrow.CArrowArrayStream}, stream)
+    Arrow.export_stream!(p, df)
+    pa.RecordBatchReader._import_from_c(UInt(p)).read_all()
+end
+
+# pyarrow -> Julia: pyarrow fills the struct and Arrow.Table moves it out
+stream = Ref{Arrow.CArrowArrayStream}()
+t = GC.@preserve stream begin
+    p = Base.unsafe_convert(Ptr{Arrow.CArrowArrayStream}, stream)
+    pytable.to_reader()._export_to_c(UInt(p))
+    Arrow.Table(p)
+end
+t.name   # the strings and the missing value, as Arrow.Table(bytes) reads them
+```
+
+`read_all()` reads every batch on the calling Julia thread. Polars and DuckDB take the
+pyarrow table it returns: `polars.from_arrow(pytable)`, or DuckDB's
+`connection.register("name", pytable)`. Give DuckDB the table, not the reader: DuckDB
+reads a reader on its own threads, which can deadlock with Julia's garbage collector
+(see [Threads](@ref cdata-threads)). The `Ref`, `GC.@preserve`, and `unsafe_convert`
+lines are the C ABI: the caller owns the struct's memory while the other side fills or
+empties it.
+
+One record batch crosses as two structs that Arrow.jl allocates, and comes back from
+structs the caller allocates:
+
+```julia
+schemaptr, arrayptr = Arrow.to_c_data(df)
+batch = pa.RecordBatch._import_from_c(UInt(arrayptr), UInt(schemaptr))
+
+aref = Ref{Arrow.CArrowArray}()
+sref = Ref{Arrow.CArrowSchema}()
+t = GC.@preserve aref sref begin
+    ap = Base.unsafe_convert(Ptr{Arrow.CArrowArray}, aref)
+    sp = Base.unsafe_convert(Ptr{Arrow.CArrowSchema}, sref)
+    batch._export_to_c(UInt(ap), UInt(sp))
+    Arrow.Table(sp, ap)   # a struct array is a table; any other array is one column
+end
+```
+
+[`Arrow.Stream(streamptr)`](@ref Arrow.Stream) pulls one record batch per iteration
+instead of reading the whole stream, for a DuckDB or Polars result larger than memory.
+
+## What crosses, and what is copied
+
+- Exports use [`Arrow.write`](@ref)'s column construction and keywords: `dictencode`,
+  `stringview`, `largelists`, `metadata`, and `colmetadata` mean what they mean there,
+  and the consumer sees the same schema and values as from the IPC bytes. A `Vector` of
+  `Int8` to `Int64`, `UInt8` to `UInt64`, or `Float16` to `Float64` crosses without
+  copying, and so do an [`Arrow.Table`](@ref) column's integer, float, and boolean
+  values and validity bitmaps, in struct fields and list values too. Everything else is
+  built into new Arrow buffers, as a write builds it: `Bool` and `missing` values in
+  Julia vectors (a `Vector{Union{Missing,T}}` is copied even when it holds no
+  `missing`), other numbers (`Int128`, `Complex`, `Rational`, and decimals, except a
+  `Vector` of 128-bit decimals), dates, times, timestamps, durations, fixed-size binary
+  and UUID values, string and list offsets, a list's own validity bitmap, fixed-size
+  list values, and dictionary-encoded columns. String bytes may be copied.
+  `export_stream!` sends one record batch per `Tables.partitions` partition (an
+  `Arrow.Stream` is a partition per batch) and splits a batch only when its string data
+  outgrows 32-bit offsets; `to_c_data` refuses a table that needs more than one batch.
+- Imports have the column types an IPC read gives: strings as `DataString`, timestamps
+  as `Timestamp` or `ZonedTimestamp`, decimals as `Decimal`, nested values as the same
+  views, with `stringtype`, `ntasks`, and `limits` as for `Arrow.Table`. Numbers, dates,
+  and other fixed-width values read the producer's memory in place; string and binary
+  values are copied into Julia-owned buffers. A C stream read whole chains its batches
+  into one table. `copy(table)` copies all of it into Julia-owned memory.
+- Exported and imported data is validated as an IPC read is.
+
+## Memory
+
+An export keeps its source reachable until the consumer has released it: the table's
+columns, or the vectors it was built from. The structs Arrow.jl allocated are then freed
+by later exports or garbage collections, with nothing to call. The consumer reads
+exported vectors in place, so modifying one changes what it reads; resizing one is safe
+from Julia 1.11 on, where the exported storage stays alive, and frees the consumer's
+bytes on Julia 1.10.
+
+An imported table's columns read the producer's memory, and the producer's `release`
+callback runs once the table and its columns are garbage collected, as a mapped file is
+unmapped. [`Arrow.release!`](@ref)`(table)` only refuses further column access. On an
+[`Arrow.Stream`](@ref) over a C stream, `Arrow.release!` of the stream or of a table it
+yielded releases the producer's stream at once and refuses further column access, as
+for any stream; columns already taken stay valid. `deepcopy` of imported data shares
+its memory and its release with the original; use `copy`.
+
+## [Threads](@id cdata-threads)
+
+The callbacks Arrow.jl exports are Julia functions. A consumer that calls them from its
+own threads, as DuckDB's and Arrow C++'s thread pools do, makes Julia adopt those
+threads. Such a consumer can deadlock with Julia's garbage collector while the Julia
+thread that called it waits for it: a collection waits for that Julia thread, which
+waits for the consumer, whose threads wait inside the callbacks for the collection.
+DuckDB's scan of a `RecordBatchReader` works this way, so read the stream with
+`read_all()` on the calling thread first and give DuckDB the pyarrow table.
+
+On Julia 1.12 and 1.13 a process in which such a consumer thread ran a callback hangs
+at exit, when the consumer's library joins its threads (a Julia bug; 1.10 and 1.11 exit
+normally). Closing the consumer, as with DuckDB's `connection.close()`, does not avoid
+it, because the threads belong to the library's thread pool. Until Julia fixes it,
+`ccall(:_exit, Cvoid, (Cint,), 0)` ends such a process at once; it skips exit hooks, so
+flush output and close files first.
+
+A producer's `release` callback for imported data runs on the thread that imported
+it, or on thread 1 when another library's thread imported it inside a callback: when a
+garbage collection on another thread finds the data unreachable, that thread runs the
+callback at its next yield. pyarrow's release of memory it shares with NumPy takes
+Python's GIL, which PythonCall's main thread holds, so data imported on the main thread
+is released there without waiting on the GIL.
+
+## Low-level columns
+
+[`Arrow.to_c_data`](@ref)`(field, data)` exports one column given as an `Arrow.Field`
+and an `Arrow.ArrayData`, and [`Arrow.from_c_data`](@ref) imports one, returning that
+pair. These are the forms the conformance suite and a custom producer or consumer use;
+tables need neither.
diff --git a/docs/src/index.md b/docs/src/index.md
index 4f900590..bdb6154a 100644
--- a/docs/src/index.md
+++ b/docs/src/index.md
@@ -21,11 +21,42 @@
 
 # Arrow.jl
 
-```@contents
-Pages = ["manual.md", "reference.md"]
-Depth = 3
+Arrow.jl reads and writes the [Apache Arrow](https://arrow.apache.org) IPC file and
+stream formats in pure Julia. A file reads as Tables.jl columns that view its memory, and
+any Tables.jl table writes. The API is namespaced: `Arrow.Table`, `Arrow.write`, and the
+rest are called with the `Arrow.` prefix, and only `ArrowTypes` is exported.
+
+## Quick start
+
+```@example quickstart
+using Arrow, DataFrames
+
+path = joinpath(mktempdir(), "example.arrow")
+Arrow.write(path, (id=[1, 2, 3], name=["Ada", "Ben", missing]))
+
+table = Arrow.Table(path)
+table.name
 ```
 
-```@docs
-Arrow
+```@example quickstart
+df = DataFrame(table)
 ```
+
+[Reading](@ref) covers tables, columns, filters, threads, and sources;
+[Writing](@ref) covers the writer's options, dictionaries, and incremental writes;
+[Streams and IPC](@ref) covers record batches, pipes, and sockets; [Type mapping](@ref)
+lists the column types in both directions; [Limits and errors](@ref) covers resource
+limits, errors, and what is not supported. Upgrading from Arrow.jl 2.x? Read
+[Migrating from Arrow.jl 2.x](@ref) first. The [API reference](@ref "API reference")
+lists the public types and functions.
+
+## Format
+
+Arrow.jl implements version 1.5 of the Arrow columnar format: the IPC file and stream
+formats, LZ4 frame and Zstandard compression, dictionary encoding with delta and
+replacement dictionaries, extension types, and the [C data interface](@ref "C data
+interface"). It reads every data type of that version, and writes all of them except
+dictionary encoding inside a nested column. A few types have no Julia type of their own,
+such as run-end encoding, list views, sparse unions, and date64; they are written when a
+table read from Arrow is written again ([Rewriting tables](@ref)). It needs no Arrow C++
+library.
diff --git a/docs/src/limits.md b/docs/src/limits.md
new file mode 100644
index 00000000..e213b363
--- /dev/null
+++ b/docs/src/limits.md
@@ -0,0 +1,123 @@
+```@raw html
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+```
+
+# Limits and errors
+
+## Errors
+
+Reads and writes throw one of two package errors, or one of these Base errors:
+
+- [`Arrow.ValidationError`](@ref): the input is not valid Arrow data, such as a truncated
+  file, inconsistent metadata, an offset or dictionary index out of range, or bytes that
+  are not Arrow at all; it uses something this package does not read ([Not
+  supported](@ref)); or it declares a size past one of the [Resource limits](@ref). The
+  message names the problem, and for a limit the field to raise.
+- [`Arrow.AllocationLimitError`](@ref): a read needed more memory than its allocation
+  budget allows ([Resource limits](@ref)); the message names the `Arrow.Limits` fields
+  to raise.
+- `ArgumentError`: an argument that cannot work, such as an unknown keyword, a `select`
+  that matches no column, a filter literal of another kind than its column, or, when
+  writing, a value with no Arrow type, invalid UTF-8, or a table that does not fit an
+  `Arrow.Writer`'s schema. The message names the column.
+- `InvalidStateException`: a table or stream used after [`Arrow.release!`](@ref
+  Arrow.release!(::Arrow.Table)).
+- `SystemError` and `Base.IOError`: the file system, such as a missing file or a
+  read-only one.
+
+```@example limits
+using Arrow
+
+bytes = take!(Arrow.tobuffer((id=collect(1:10_000),)))
+try
+    Arrow.Table(bytes[1:(end - 100)])
+catch err
+    showerror(stdout, err)
+end
+```
+
+## Resource limits
+
+Pass an [`Arrow.Limits`](@ref) as the `limits` keyword of `Arrow.Table` or `Arrow.Stream`:
+
+| field | default | caps |
+|:--|:--|:--|
+| `max_metadata_bytes` | 16 MiB | the metadata of one message |
+| `max_body_bytes` | none | the body of one message |
+| `max_buffer_bytes` | none | one buffer, compressed or not |
+| `max_total_allocated_bytes` | physical memory | the memory one read, or one batch of a stream, allocates |
+| `max_allocation_ratio` | 64 | that memory per byte of input |
+| `max_messages` | 1,000,000 | messages in one file or table |
+| `max_metadata_objects` | 1,000,000 | FlatBuffers objects in one message |
+| `max_nesting_depth` | 64 | nesting of types and metadata |
+| `max_array_length` | 1,000,000,000 | the length of one array |
+| `max_concurrent_reads` | 64 | ranges an `Arrow.AbstractArrowSource` reads at once |
+| `max_new_symbols` | 1,000,000 | new `Symbol` values one read interns |
+
+A read may allocate `max_allocation_ratio` bytes per byte of its input, at least 256 MiB
+and at most `max_total_allocated_bytes`; each batch of an `Arrow.Stream` gets its own
+allowance from its own bytes. A compressed buffer counts at its decompressed size, so
+ordinary files of any size and compression ratio read with the defaults. Lengths that a
+file declares without the bytes to back them fail before memory is reserved for them.
+Data that expands much further than its bytes, such as long runs or a heavily repeated
+dictionary value, can need a larger `max_allocation_ratio`.
+
+```@example limits
+try
+    Arrow.Table(bytes; limits=Arrow.Limits(max_array_length=1_000))
+catch err
+    showerror(stdout, err)
+end
+```
+
+Symbols last for the rest of the process, so a read interns at most `max_new_symbols`
+new `Symbol` values from `Symbol` columns, and refuses a column that needs more before
+interning any. Such a column can be read as strings: `Arrow.Table(path; select=[:id =>
+String])`. A filter on that column still compares `Symbol`s, so it interns them.
+
+Column names and time-zone names become `Symbol`s too. A read refuses, with a
+`ValidationError`, a name longer than 4096 bytes, a schema that would intern more than
+65,536 new column names or 1 MiB of them, and more than 1,024 new time zones.
+
+## Validation
+
+Every record batch is checked before it is used: the metadata by a FlatBuffers
+verifier, then each buffer's size against the schema, offsets, dictionary indices, union
+type ids, and run ends. Corrupt or hostile input therefore fails with a
+`ValidationError` or an `AllocationLimitError` rather than crashing, hanging, or
+allocating without bound; the package's fuzz tests check this. Three things the format
+leaves to the writer are not checked, as other implementations do not check them: that
+strings read are valid UTF-8, that a field declared non-nullable has no nulls (such a
+column reads as `Union{Missing,T}`), and the padding bytes.
+
+Writes validate every record batch before its bytes reach the sink.
+
+## Not supported
+
+These fail with a `ValidationError`, or an `ArgumentError` when writing:
+
+- Big-endian IPC data.
+- Metadata versions before V4, and the pre-1.0 experimental compression that predates
+  the format's body compression.
+- Appending to a file-format file; append to the stream format or use an `Arrow.Writer`.
+- Writing a `BigInt`, an `@enum`, a multidimensional array, or another type with no Arrow
+  type: convert it, or map it with ArrowTypes ([Custom types](@ref)).
+- Writing dictionary encoding inside a nested column (it reads), and rewriting, as it
+  was read, a union with two children of the same type ([Rewriting tables](@ref)).
diff --git a/docs/src/manual.md b/docs/src/manual.md
deleted file mode 100644
index 5a3330fd..00000000
--- a/docs/src/manual.md
+++ /dev/null
@@ -1,247 +0,0 @@
-```@raw html
-<!---
-  Licensed to the Apache Software Foundation (ASF) under one
-  or more contributor license agreements.  See the NOTICE file
-  distributed with this work for additional information
-  regarding copyright ownership.  The ASF licenses this file
-  to you under the Apache License, Version 2.0 (the
-  "License"); you may not use this file except in compliance
-  with the License.  You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-  Unless required by applicable law or agreed to in writing,
-  software distributed under the License is distributed on an
-  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-  KIND, either express or implied.  See the License for the
-  specific language governing permissions and limitations
-  under the License.
--->
-```
-
-# User Manual
-
-The goal of this documentation is to provide a brief introduction to the arrow data format, then provide a walk-through of the functionality provided in the Arrow.jl Julia package, with an aim to expose a little of the machinery "under the hood" to help explain how things work and how that influences real-world use-cases for the arrow data format.
-
-The best place to learn about the Apache arrow project is [the website itself](https://arrow.apache.org/), specifically the data format [specification](https://arrow.apache.org/docs/format/Columnar.html). Put briefly, the arrow project provides a formal specification for how columnar, "table" data can be laid out efficiently in memory to standardize and maximize the ability to share data across languages/platforms. In the current [apache/arrow GitHub repository](https://github.com/apache/arrow), language implementations exist for C++, Java, Go, Javascript, Rust, to name a few. Other database vendors and data processing frameworks/applications have also built support for the arrow format, allowing for a wide breadth of possibility for applications to "speak the data language" of arrow.
-
-The [Arrow.jl](https://github.com/apache/arrow-julia) Julia package is another implementation, allowing the ability to both read and write data in the arrow format. As a data format, arrow specifies an exact memory layout to be used for columnar table data, and as such, "reading" involves custom Julia objects ([`Arrow.Table`](@ref) and [`Arrow.Stream`](@ref)), which read the *metadata* of an "arrow memory blob", then *wrap* the array data contained therein, having learned the type and size, amongst other properties, from the metadata. Let's take a closer look at what this "reading" of arrow memory really means/looks like.
-
-## Support for generic path-like types
-
-Arrow.jl attempts to support any path-like type wherever a function takes a path as an argument. The Arrow.jl API should generically work as long as the type supports:
-
-- `Base.open(path, mode)::I where I <: IO`
-
-When a custom `IO` subtype is returned (`I`) then the following methods also need to be defined:
-
-- `Base.read(io::I, ::Type{UInt8})` or `Base.read(io::I)`
-- `Base.write(io::I, x)`
-
-## Reading arrow data
-
-After installing the Arrow.jl Julia package (via `] add Arrow`), and if you have some arrow data, let's say a file named `data.arrow` generated from the [`pyarrow`](https://arrow.apache.org/docs/python/) library (a Python library for interfacing with arrow data), you can then read that arrow data into a Julia session by doing:
-
-```julia
-using Arrow
-
-table = Arrow.Table("data.arrow")
-```
-
-### `Arrow.Table`
-
-The type of `table` in this example will be an `Arrow.Table`. When "reading" the arrow data, `Arrow.Table` first ["mmapped"](https://en.wikipedia.org/wiki/Mmap) the `data.arrow` file, which is an important technique for dealing with data larger than available RAM on a system. By "mmapping" a file, the OS doesn't actually load the entire file contents into RAM at the same time, but file contents are "swapped" into RAM as different regions of a file are requested. Once "mmapped", `Arrow.Table` then inspected the metadata in the file to determine the number of columns, their names and types, at which byte offset each column begins in the file data, and even how many "batches" are included in this file (arrow tables may be partitioned into one or more "record batches" each containing portions of the data). Armed with all the appropriate metadata, `Arrow.Table` then created custom array objects ([`Arrow.ArrowVector`](@ref)), which act as "views" into the raw arrow memory bytes. This is a significant point in that no extra memory is allocated for "data" when reading arrow data. This is in contrast to if we wanted to read data from a csv file as columns into Julia structures; we would need to allocate those array structures ourselves, then parse the file, "filling in" each element of the array with the data we parsed from the file. Arrow data, on the other hand, is *already laid out in memory or on disk* in a binary format, and as long as we have the metadata to interpret the raw bytes, we can figure out whether to treat those bytes as a `Vector{Float64}`, etc. A sample of the kinds of arrow array types you might see when deserializing arrow data, include:
-
-* [`Arrow.Primitive`](@ref): the most common array type for simple, fixed-size elements like integers, floats, time types, and decimals
-* [`Arrow.List`](@ref): an array type where its own elements are also arrays of some kind, like string columns, where each element can be thought of as an array of characters
-* [`Arrow.FixedSizeList`](@ref): similar to the `List` type, but where each array element has a fixed number of elements itself; you can think of this like a `Vector{NTuple{N, T}}`, where `N` is the fixed-size width
-* [`Arrow.Map`](@ref): an array type where each element is like a Julia `Dict`; a list of key value pairs like a `Vector{Dict}`
-* [`Arrow.Struct`](@ref): an array type where each element is an instance of a custom struct, i.e. an ordered collection of named & typed fields, kind of like a `Vector{NamedTuple}`
-* [`Arrow.DenseUnion`](@ref): an array type where elements may be of several different types, stored compactly; can be thought of like `Vector{Union{A, B}}`
-* [`Arrow.SparseUnion`](@ref): another array type where elements may be of several different types, but stored as if made up of identically lengthed child arrays for each possible type (less memory efficient than `DenseUnion`)
-* [`Arrow.DictEncoded`](@ref): a special array type where values are "dictionary encoded", meaning the list of unique, possible values for an array are stored internally in an "encoding pool", whereas each stored element of the array is just an integer "code" to index into the encoding pool for the actual value.
-
-And while these custom array types do subtype `AbstractArray`, there is no current support for `setindex!`. Remember, these arrays are "views" into the raw arrow bytes, so for array types other than `Arrow.Primitive`, it gets pretty tricky to allow manipulating those raw arrow bytes. Nevetheless, it's as simple as calling `copy(x)` where `x` is any `ArrowVector` type, and a normal Julia `Vector` type will be fully materialized (which would then allow mutating/manipulating values).
-
-So, what can you do with an `Arrow.Table` full of data? Quite a bit actually!
-
-Because `Arrow.Table` implements the [Tables.jl](https://juliadata.github.io/Tables.jl/stable/) interface, it opens up a world of integrations for using arrow data. A few examples include:
-
-* `df = DataFrame(Arrow.Table(file))`: Build a [`DataFrame`](https://juliadata.github.io/DataFrames.jl/stable/), using the arrow vectors themselves; this allows utilizing a host of DataFrames.jl functionality directly on arrow data; grouping, joining, selecting, etc.
-* `df = copy(DataFrame(Arrow.Table(file)))`: Build a [`DataFrame`](https://juliadata.github.io/DataFrames.jl/stable/), where the columns are regular in-memory vectors (specifically, `Base.Vector`s and/or `PooledVector`s). This requires that you have enough memory to load the entire `DataFrame` into memory.
-* `Tables.datavaluerows(Arrow.Table(file)) |> @map(...) |> @filter(...) |> DataFrame`: use [`Query.jl`'s](https://www.queryverse.org/Query.jl/stable/standalonequerycommands/) row-processing utilities to map, group, filter, mutate, etc. directly over arrow data.
-* `Arrow.Table(file) |> SQLite.load!(db, "arrow_table")`: load arrow data directly into an sqlite database/table, where sql queries can be executed on the data
-* `Arrow.Table(file) |> CSV.write("arrow.csv")`: write arrow data out to a csv file
-
-A full list of Julia packages leveraging the Tables.jl inteface can be found [here](https://github.com/JuliaData/Tables.jl/blob/master/INTEGRATIONS.md).
-
-Apart from letting other packages have all the fun, an `Arrow.Table` itself can be plenty useful. For example, with `tbl = Arrow.Table(file)`:
-* `tbl[1]`: retrieve the first column via indexing; the number of columns can be queried via `length(tbl)`
-* `tbl[:col1]` or `tbl.col1`: retrieve the column named `col1`, either via indexing with the column name given as a `Symbol`, or via "dot-access"
-* `for col in tbl`: iterate through columns in the table
-* `AbstractDict` methods like `haskey(tbl, :col1)`, `get(tbl, :col1, nothing)`, `keys(tbl)`, or `values(tbl)`
-
-### Arrow types
-
-In the arrow data format, specific logical types are supported, a list of which can be found [here](https://arrow.apache.org/docs/status.html#data-types). These include booleans, integers of various bit widths, floats, decimals, time types, and binary/string. While most of these map naturally to types builtin to Julia itself, there are a few cases where the definitions are slightly different, and in these cases, by default, they are converted to more "friendly" Julia types (this auto conversion can be avoided by passing `convert=false` to `Arrow.Table`, like `Arrow.Table(file; convert=false)`). Examples of arrow to julia type mappings include:
-
-* `Date`, `Time`, `Timestamp`, and `Duration` all have natural Julia defintions in `Dates.Date`, `Dates.Time`, `TimeZones.ZonedDateTime`, and `Dates.Period` subtypes, respectively.
-* `Char` and `Symbol` Julia types are mapped to arrow string types, with additional metadata of the original Julia type; this allows deserializing directly to `Char` and `Symbol` in Julia, while other language implementations will see these columns as just strings
-* Similarly to the above, the `UUID` Julia type is mapped to a 128-bit `FixedSizeBinary` arrow type.
-* `Decimal128` and `Decimal256` have no corresponding builtin Julia types, so they're deserialized using a compatible type definition in Arrow.jl itself: `Arrow.Decimal`
-
-
-Note that when `convert=false` is passed, data will be returned in Arrow.jl-defined types that exactly match the arrow definitions of those types; the authoritative source for how each type represents its data can be found in the arrow [`Schema.fbs`](https://github.com/apache/arrow/blob/master/format/Schema.fbs) file.
-
-One note on performance: when writing `TimeZones.ZonedDateTime` columns to the arrow format (via `Arrow.write`), it is preferrable to "wrap" the columns in `Arrow.ToTimestamp(col)`, as long
-as the column has `ZonedDateTime` elements that all share a common timezone. This ensures the writing process can know "upfront" which timezone will be encoded and is thus much more
-efficient and performant.
-
-#### Custom types
-
-To support writing your custom Julia struct, Arrow.jl utilizes the format's mechanism for "extension types" by allowing the storing of Julia type name and metadata in the field metadata. To "hook in" to this machinery, custom types can utilize the interface methods defined in the `Arrow.ArrowTypes` submodule. For example:
-
-```julia
-using Arrow
-
-struct Person
-    id::Int
-    name::String
-end
-
-# overload interface method for custom type Person; return a symbol as the "name"
-# this instructs Arrow.write what "label" to include with a column with this custom type
-const NAME = Symbol("JuliaLang.MyPackage.Person")
-ArrowTypes.arrowname(::Type{Person}) = NAME
-# overload JuliaType on `Val{NAME}`, which is like a dispatchable string
-# return our custom *type* Person; this enables Arrow.Table to know how the "label"
-# on a custom column should be mapped to a Julia type and deserialized
-ArrowTypes.JuliaType(::Val{NAME}) = Person
-
-table = (col1=[Person(1, "Bob"), Person(2, "Jane")],)
-io = IOBuffer()
-Arrow.write(io, table)
-seekstart(io)
-table2 = Arrow.Table(io)
-```
-
-In this example, we're writing our `table`, which is a NamedTuple with one column named `col1`, which has two
-elements which are instances of our custom `Person` struct. We overload `Arrowtypes.arrowname` so that
-Arrow.jl knows how to serialize our `Person` struct. We then overload `ArrowTypes.JuliaType` so the deserialization process knows how to map from our type label back to our `Person` struct type. We can then write our data in the arrow format to an in-memory `IOBuffer`, then read the table back in using `Arrow.Table`.
-The table we get back will be an `Arrow.Table`, with a single `Arrow.Struct` column with element type `Person`.
-
-Note that without calling `Arrowtypes.JuliaType`, we may get into a weird limbo state where we've written
-our table with `Person` structs out as a table, but when reading back in, Arrow.jl doesn't know what a `Person` is;
-deserialization won't fail, but we'll just get a `Namedtuple{(:id, :name), Tuple{Int, String}}` back instead of `Person`.
-
-While this example is very simple, it shows the basics to allow a custom type to be serialized/deserialized. But the `ArrowTypes` module offers even more powerful functionality for "hooking" non-native arrow types into the serialization/deserialization processes. Let's walk through a couple more examples; if you've had enough custom type shenanigans, feel free to skip to the next section.
-
-Let's take a look at how Arrow.jl allows serializing the `nothing` value, which is often referred to as the "software engineer's NULL" in Julia. While Arrow.jl treats `missing` as the default arrow NULL value, `nothing` is pretty similar, but we'd still like to treat it separately if possible. Here's how we enable serialization/deserialization in the `ArrowTypes` module:
-
-```julia
-ArrowTypes.ArrowKind(::Type{Nothing}) = ArrowTypes.NullKind()
-ArrowTypes.ArrowType(::Type{Nothing}) = Missing
-ArrowTypes.toarrow(::Nothing) = missing
-const NOTHING = Symbol("JuliaLang.Nothing")
-ArrowTypes.arrowname(::Type{Nothing}) = NOTHING
-ArrowTypes.JuliaType(::Val{NOTHING}) = Nothing
-ArrowTypes.fromarrow(::Type{Nothing}, ::Missing) = nothing
-```
-
-Let's walk through what's going on here, line-by-line:
-  * `ArrowKind` overload: `ArrowKind`s are generic "categories" of types supported by the arrow format, like `PrimitiveKind`, `ListKind`, etc. They each correspond to a different data layout strategy supported in the arrow format. Here, we define `nothing`'s kind to be `NullKind`, which means no actual memory is needed for storage, it's strictly a "metadata" type where we store the type and # of elements. In our `Person` example, we didn't need to overload this since types declared like `struct T` or `mutable struct T` are defined as `ArrowTypes.StructKind` by default
-  * `ArrowType` overload: here we're signaling that our type (`Nothing`) maps to the natively supported arrow type of `Missing`; this is important for the serializer so it knows which arrow type it will be serializing. Again, we didn't need to overload this for `Person` since the serializer knows how to serialize custom structs automatically by using reflection methods like `fieldnames(T)` and `getfield(x, i)`.
-  * `ArrowTypes.toarrow` overload: this is a sister method to `ArrowType`; we said our type will map to the `Missing` arrow type, so here we actually define ___how___ it converts to the arrow type; and in this case, it just returns `missing`. This is yet another method that didn't show up for `Person`; why? Well, as we noted in `ArrowType`, the serializer already knows how to serialize custom structs by using all their fields; if, for some reason, we wanted to omit some fields or otherwise transform things, then we could define corresponding `ArrowType` and `toarrow` methods
-  * `arrowname` overload: similar to our `Person` example, we need to instruct the serializer how to label our custom type in the arrow type metadata; here we give it the symbol `Symbol("JuliaLang.Nothing")`. Note that while this will ultimately allow us to disambiguate `nothing` from `missing` when reading arrow data, if we pass this data to other language implementations, they will only treat the data as `missing` since they (probably) won't know how to "understand" the `JuliaLang.Nothing` type label
-  * `JuliaType` overload: again, like our `Person` example, we instruct the deserializer that when it encounters the `JuliaLang.Nothing` type label, it should treat those values as `Nothing` type.
-  * And finally, `fromarrow` overload: this allows specifying how the native-arrow data should be converted back to our custom type. `fromarrow(T, x...)` by default will call `T(x...)`, which is why we didn't need this overload for `Person`, but in this example, `Nothing(missing)` won't work, so we define our own custom conversion.
-
-Let's run through one more complex example, just for fun and to really see how far the system can be pushed:
-
-```julia
-using Intervals
-table = (col = [
-    Interval{Closed,Unbounded}(1,nothing),
-],)
-const NAME = Symbol("JuliaLang.Intervals.Interval")
-ArrowTypes.arrowname(::Type{Interval{T, L, R}}) where {T, L, R} = NAME
-const LOOKUP = Dict(
-    "Closed" => Closed,
-    "Unbounded" => Unbounded
-)
-ArrowTypes.arrowmetadata(::Type{Interval{T, L, R}}) where {T, L, R} = string(L, ".", R)
-function ArrowTypes.JuliaType(::Val{NAME}, ::Type{NamedTuple{names, types}}, meta) where {names, types}
-    L, R = split(meta, ".")
-    return Interval{fieldtype(types, 1), LOOKUP[L], LOOKUP[R]}
-end
-ArrowTypes.fromarrow(::Type{Interval{T, L, R}}, first, last) where {T, L, R} = Interval{L, R}(first, R == Unbounded ? nothing : last)
-io = Arrow.tobuffer(table)
-tbl = Arrow.Table(io)
-```
-
-Again, let's break down what's going on here:
-  * Here we're trying to save an `Interval` type in the arrow format; this type is unique in that it has two type parameters (`Closed` and `Unbounded`) that are not inferred/based on fields, but are just "type tags" on the type itself
-  * Note that we define a generic `arrowname` method on all `Interval`s, regardless of type parameters. We just want to let arrow know which general type we're dealing with here
-  * Next we use a new method `ArrowTypes.arrowmetadata` to encode the two non-field-based type parameters as a string with a dot delimiter; we encode this information here because remember, we have to match our `arrowname` Symbol typename in our `JuliaType(::Val(name))` definition in order to dispatch correctly; if we encoded the type parameters in `arrowname`, we would need separate `arrowname` definitions for each unique combination of those two type parameters, and corresponding `JuliaType` definitions for each as well; yuck. Instead, we let `arrowname` be generic to our type, and store the type parameters *for this specific column* using `arrowmetadata`
-  * Now in `JuliaType`, note we're using the 3-argument overload; we want the `NamedTuple` type that is the native arrow type our `Interval` is being serialized as; we use this to retrieve the 1st type parameter for our `Interval`, which is simply the type of the two `first` and `last` fields. Then we use the 3rd argument, which is whatever string we returned from `arrowmetadata`. We call `L, R = split(meta, ".")` to parse the two type parameters (in this case `Closed` and `Unbounded`), then do a lookup on those strings from a predefined `LOOKUP` Dict that matches the type parameter name as string to the actual type. We then have all the information to recreate the full `Interval` type. Neat!
-  * The one final wrinkle is in our `fromarrow` method; `Interval`s that are `Unbounded`, actually take `nothing` as the 2nd argument. So letting the default `fromarrow` definition call `Interval{T, L, R}(first, last)`, where `first` and `last` are both integers isn't going to work. Instead, we check if the `R` type parameter is `Unbounded` and if so, pass `nothing` as the 2nd arg, otherwise we can pass `last`.
-
-This stuff can definitely make your eyes glaze over if you stare at it long enough. As always, don't hesitate to reach out for quick questions on the [#data](https://julialang.slack.com/messages/data/) slack channel, or [open a new issue](https://github.com/apache/arrow-julia/issues/new) detailing what you're trying to do.
-
-### `Arrow.Stream`
-
-In addition to `Arrow.Table`, the Arrow.jl package also provides `Arrow.Stream` for processing arrow data. While `Arrow.Table` will iterate all record batches in an arrow file/stream, concatenating columns, `Arrow.Stream` provides a way to *iterate* through record batches, one at a time. Each iteration yields an `Arrow.Table` instance, with columns/data for a single record batch. This allows, if so desired, "batch processing" of arrow data, one record batch at a time, instead of creating a single long table via `Arrow.Table`.
-
-### Custom application metadata
-
-The Arrow format allows data producers to [attach custom metadata](https://arrow.apache.org/docs/format/Columnar.html#custom-application-metadata) to various Arrow objects.
-
-Arrow.jl provides a convenient accessor for this metadata via [`Arrow.getmetadata`](@ref). `Arrow.getmetadata(t::Arrow.Table)` will return an immutable `AbstractDict{String,String}` that represents the [`custom_metadata` of the table's associated `Schema`](https://github.com/apache/arrow/blob/85d8175ea24b4dd99f108a673e9b63996d4f88cc/format/Schema.fbs#L515) (or `nothing` if no such metadata exists), while `Arrow.getmetadata(c::Arrow.ArrowVector)` will return a similar representation of [the column's associated `Field` `custom_metadata`](https://github.com/apache/arrow/blob/85d8175ea24b4dd99f108a673e9b63996d4f88cc/format/Schema.fbs#L480) (or `nothing` if no such metadata exists).
-
-To attach custom schema/column metadata to Arrow tables at serialization time, see the `metadata` and `colmetadata` keyword arguments to [`Arrow.write`](@ref).
-
-## Writing arrow data
-
-Ok, so that's a pretty good rundown of *reading* arrow data, but how do you *produce* arrow data? Enter `Arrow.write`.
-
-### `Arrow.write`
-
-With `Arrow.write`, you provide either an `io::IO` argument or a [`file_path`](#support-for-generic-path-like-types) to write the arrow data to, as well as a Tables.jl-compatible source that contains the data to be written.
-
-What are some examples of Tables.jl-compatible sources? A few examples include:
-* `Arrow.write(io, df::DataFrame)`: A `DataFrame` is a collection of indexable columns
-* `Arrow.write(io, CSV.File(file))`: read data from a csv file and write out to arrow format
-* `Arrow.write(io, DBInterface.execute(db, sql_query))`: Execute an SQL query against a database via the [`DBInterface.jl`](https://github.com/JuliaDatabases/DBInterface.jl) interface, and write the query resultset out directly in the arrow format. Packages that implement DBInterface include [SQLite.jl](https://juliadatabases.github.io/SQLite.jl/stable/), [MySQL.jl](https://juliadatabases.github.io/MySQL.jl/dev/), and [ODBC.jl](http://juliadatabases.github.io/ODBC.jl/latest/).
-* `df |> @map(...) |> Arrow.write(io)`: Write the results of a [Query.jl](https://www.queryverse.org/Query.jl/stable/) chain of operations directly out as arrow data
-* `jsontable(json) |> Arrow.write(io)`: Treat a json array of objects or object of arrays as a "table" and write it out as arrow data using the [JSONTables.jl](https://github.com/JuliaData/JSONTables.jl) package
-* `Arrow.write(io, (col1=data1, col2=data2, ...))`: a `NamedTuple` of `AbstractVector`s or an `AbstractVector` of `NamedTuple`s are both considered tables by default, so they can be quickly constructed for easy writing of arrow data if you already have columns of data
-
-And these are just a few examples of the numerous [integrations](https://github.com/JuliaData/Tables.jl/blob/master/INTEGRATIONS.md).
-
-In addition to just writing out a single "table" of data as a single arrow record batch, `Arrow.write` also supports writing out multiple record batches when the input supports the `Tables.partitions` functionality. One immediate, though perhaps not incredibly useful example, is `Arrow.Stream`. `Arrow.Stream` implements `Tables.partitions` in that it iterates "tables" (specifically `Arrow.Table`), and as such, `Arrow.write` will iterate an `Arrow.Stream`, and write out each `Arrow.Table` as a separate record batch. Another important point for why this example works is because an `Arrow.Stream` iterates `Arrow.Table`s that all have the same schema. This is important because when writing arrow data, a "schema" message is always written first, with all subsequent record batches written with data matching the initial schema.
-
-In addition to inputs that support `Tables.partitions`, note that the Tables.jl itself provides the `Tables.partitioner` function, which allows providing your own separate instances of similarly-schema-ed tables as "partitions", like:
-
-```julia
-# treat 2 separate NamedTuples of vectors with same schema as 1 table, 2 partitions
-tbl_parts = Tables.partitioner([(col1=data1, col2=data2), (col1=data3, col2=data4)])
-Arrow.write(io, tbl_parts)
-
-# treat an array of csv files with same schema where each file is a partition
-# in this form, a function `CSV.File` is applied to each element of 2nd argument
-csv_parts = Tables.partitioner(CSV.File, csv_files)
-Arrow.write(io, csv_parts)
-```
-
-### `Arrow.Writer`
-
-With `Arrow.Writer`, you instantiate an `Arrow.Writer` object, write sources using it, and then close it.  This allows for incrmental writes to the same sink.  It is similar to `Arrow.append` without having to close and re-open the sink in between writes and without the limitation of only supporting the IPC stream format.
-
-### Multithreaded writing
-
-By default, `Arrow.write` will use multiple threads to write multiple
-record batches simultaneously (e.g. if julia is started with `julia -t 8` or the `JULIA_NUM_THREADS` environment variable is set). The number of concurrent tasks to use when writing can be controlled by passing the `ntasks` keyword argument to `Arrow.write`. Passing `ntasks=1` avoids any multithreading when writing.
-
-### Compression
-
-Compression is supported when writing via the `compress` keyword argument. Possible values include `:lz4`, `:zstd`, or your own initialized `LZ4FrameCompressor` or `ZstdCompressor` objects; will cause all buffers in each record batch to use the respective compression encoding or compressor.
diff --git a/docs/src/migration.md b/docs/src/migration.md
new file mode 100644
index 00000000..abb88531
--- /dev/null
+++ b/docs/src/migration.md
@@ -0,0 +1,162 @@
+```@raw html
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+```
+
+# Migrating from Arrow.jl 2.x
+
+Arrow.jl 3.0 is a new implementation with the same main names: `Arrow.Table`,
+`Arrow.Stream`, `Arrow.write`, `Arrow.Writer`, `Arrow.append`, `Arrow.tobuffer`,
+`Arrow.DictEncode`, and `Arrow.getmetadata`. It reads Arrow 2.x files using the Julia
+types described below. Code that reads a table into a `DataFrame` and writes it back
+usually runs unchanged. Files containing `ZonedDateTime` written before Arrow 2.4.2
+need rewriting first; see [Reading and writing alongside Arrow.jl 2.x](@ref).
+Other changes include a few removed arguments and, for teams that run both versions,
+column types that Arrow 2.x cannot read correctly.
+
+## Before you upgrade
+
+Arrow 3.0 needs Julia 1.10 or later and uses ArrowTypes.jl 2, Tables.jl 1.14,
+DataStrings.jl, DataDecimals.jl, and Durations.jl. It no longer depends on TimeZones.jl
+or BitIntegers.jl.
+
+Some registered packages still declare compatibility with Arrow 2 only, so adding Arrow 3
+can make the package manager hold them, or downgrade them, to older versions; until its
+next release this includes CategoricalArrays, through its Arrow extension. After
+upgrading, check `Pkg.status()` for packages that went backwards.
+
+## Calls
+
+| Arrow 2.x | Arrow 3.0 |
+|:--|:--|
+| `Arrow.Table(path; convert=false)` | removed: values always convert to Julia types ([Values](@ref)) |
+| `Arrow.Table(bytes, pos, len)` | `Arrow.Table(bytes[pos:(pos + len - 1)])` |
+| `Arrow.Table(path)`, `Arrow.write(path, table)` with a path object, such as a FilePathsBase.jl path or an AWSS3.jl `S3Path` | unchanged: any object that `open(path, "r")` (to read) or `open(path, "w")` (to write) accepts works |
+| `Arrow.Table([path1, path2])`, `Arrow.Stream([...])` | read each source: `reduce(vcat, DataFrame.(Arrow.Table.(paths)))`, or `for path in paths, batch in Arrow.Stream(path)` |
+| `table.col[i] = x` | columns are read-only: `df = DataFrame(table); df.col[i] = x` |
+| `table.col isa Arrow.List` (or `Map`, `Struct`, `DenseUnion`, ...) | the column types are now `Arrow.ListVector`, `MapVector`, `StructVector`, and plain `Vector`s for unions; better, test the element type |
+| `Arrow.getmetadata(table)` | unchanged; `DataAPI.metadata(table)` also works |
+| `Arrow.getmetadata(table.col)` | `DataAPI.colmetadata(table, :col)` |
+| `Arrow.write(...; compress=LZ4FrameCompressor())` | `compress=:lz4` (or `:zstd`), with `compresslevel` |
+| `Arrow.write(...; alignment, dictencodenested, denseunions, maxdepth)` | accepted with a warning and ignored |
+| `Arrow.write(...; ntasks=0)` | `ntasks=1` |
+| `Arrow.ToTimestamp(x)` | removed: write `Durations.ZonedTimestamp` values, or `ZonedDateTime`s with TimeZones loaded |
+| `open(Arrow.Writer, path) do writer ... end` | unchanged, or `Arrow.Writer(path) do writer ... end` |
+
+A keyword Arrow 3.0 does not know is an `ArgumentError` that lists the valid ones and
+suggests the name to use for pyarrow's, Polars', and Arrow 2.x's names. `release!` is new
+and public, and like every name but `ArrowTypes` it is called with the `Arrow.` prefix.
+
+## Values
+
+Columns are still views of the file, and most element types are the same as in 2.x.
+These changed:
+
+| Arrow type | Arrow 2.x | Arrow 3.0 | To get the 2.x value |
+|:--|:--|:--|:--|
+| Utf8 | `String` | `DataStrings.DataString` | `String(x)`; or read with `stringtype=String` |
+| Binary | `Base.CodeUnits` | `DataStrings.DataBytes` | `Vector{UInt8}(x)` |
+| Timestamp | `DateTime`, truncated to milliseconds | `Durations.Timestamp{unit}`, exact | `DateTime(x)`; or select the column as `:col => DateTime` |
+| Timestamp with a zone | `TimeZones.ZonedDateTime` | `Durations.ZonedTimestamp{unit,zone}` | `ZonedDateTime(x)`, with TimeZones loaded |
+| Decimal | `Arrow.Decimal{P,S,Int128}` | `DataDecimals.Decimal{P,S,T}` | |
+| Interval | `Arrow.Interval` | `Durations.Duration` | |
+| List | a `SubArray` view | `Arrow.ListValue{T}` view | `copy(x)` |
+| FixedSizeList with nullable values | a `Tuple` | `Arrow.ListValue{T}` | `Tuple(x)` |
+| Map | `Dict{K,V}` | `Arrow.MapValue{K,V}`, an `AbstractDict` in stored order | `Dict(x)`; `Dict{String,V}(x)` for `String` keys |
+| Struct | `NamedTuple` | `NamedTuple`, with `DataString` fields for strings | |
+
+A `DataString` compares and hashes equal to the `String` with the same characters, and a
+`Timestamp` to the `DateTime` at the same time, so lookups, joins, and comparisons
+against `String` and `DateTime` values keep working. Code that dispatches on, or asserts,
+`String`, `DateTime`, or `Dict` element types needs the conversions above:
+
+```@example migration
+using Arrow, Dates
+
+path = joinpath(mktempdir(), "values.arrow")
+Arrow.write(path, (name=["Ada"], at=[DateTime(2025, 1, 1, 12)], attrs=[Dict("k" => 1)]))
+table = Arrow.Table(path)
+(table.name[1] == "Ada", String(table.name[1]), DateTime(table.at[1]),
+    Dict{String,Int}(table.attrs[1]))
+```
+
+[Type mapping](@ref) lists every type.
+
+Ordered dictionary columns keep their order in `DataAPI.levels`, and with
+CategoricalArrays loaded `isordered(column)` reports it; see [Dictionary
+columns](@ref) for rebuilding an ordered `CategoricalArray`.
+
+`Symbol` columns intern at most `Arrow.Limits().max_new_symbols` new symbols per read
+([Resource limits](@ref)).
+
+## Writing changes
+
+- A path still gets the file format and an `IO` the stream format; `file=` overrides.
+- `Arrow.Writer` takes its schema from the first table, with every column nullable
+  unless `nullable=false`. Later tables, and tables given to `Arrow.append`, must have
+  the same columns with values that convert exactly (an `Int32` column fits an `Int64`
+  one), or the write is an error naming the column. Arrow 2.x did not check them.
+- `dictencode=false` writes `PooledArray` and `CategoricalArray` columns as plain values;
+  2.x dictionary-encoded them regardless. `dictencode` also takes column names.
+- Strings must be valid UTF-8; write other bytes as `Vector{UInt8}`.
+- `UUID` columns write as the canonical `arrow.uuid` extension, which pyarrow and Polars
+  read as UUIDs. Files from 2.x, which used a `JuliaLang.UUID` label, still read as
+  `UUID`.
+- `Int128` and `UInt128` write as 16-byte fixed-size binary labelled `JuliaLang.Int128`
+  and `JuliaLang.UInt128`.
+- A vector of `Pair`s writes as an Arrow map, where 2.x wrote a list of structs.
+- `metadata` and `colmetadata` default to the table's DataAPI metadata, so a
+  `DataFrame`'s metadata is written.
+- New keywords: `compresslevel`, `batchsize`, `dictdeltas`, `stringview`, and, for
+  `Arrow.Writer`, `nullable` and `dictreplacement` ([Writing](@ref)).
+
+## Packages that define mappings
+
+ArrowTypes.jl 2 keeps the 2.x interface. Define `ArrowTypes.ArrowType` and
+`ArrowTypes.toarrow` to write a type as a supported one, and `ArrowTypes.arrowname`,
+`ArrowTypes.JuliaType`, and `ArrowTypes.fromarrow` to read it back ([Custom
+types](@ref)). Files written with 2.x mappings read back through the same definitions.
+Overriding `ArrowTypes.ArrowKind` alone no longer chooses how a type is stored. A
+package that defines mappings should depend on ArrowTypes.jl directly rather than reach
+it through Arrow.
+
+## Reading and writing alongside Arrow.jl 2.x
+
+Arrow 3.0 reads Arrow 2.x files as the types listed under [Values](@ref), with the
+older `ZonedDateTime` exception described below. The other direction has gaps:
+Arrow 2.x reads most files Arrow 3.0 writes, but not all. While some readers still
+run Arrow 2.x, avoid these columns or write them in the form the last column suggests:
+
+| Written by Arrow 3.0 | Arrow 2.x reads | For 2.x readers, write |
+|:--|:--|:--|
+| `UUID` | `NTuple{16,UInt8}`, with a warning | `string.(uuids)` |
+| `Int128`, `UInt128` | `NTuple{16,UInt8}`, with a warning | `string.(x)` |
+| `Minute`, `Hour`, `Day`, `Week` | an `Arrow.Duration` of seconds, with a warning | `Dates.Second.(x)` |
+| `Month`, `Year` | an `Arrow.Interval` of months, with a warning | `Dates.value.(x)` |
+| `VersionNumber` | fails when the column is read | `string.(versions)` |
+| `Durations.Duration` | cannot open the file | separate columns, or `string.(x)` |
+| A dictionary column that gained values across partitions or `Arrow.Writer` tables, in the file format | with several threads, can fail with a `KeyError` | `dictdeltas=true`, or the stream format |
+| Decimal32 or Decimal64, kept from a file another tool wrote | wrong values, without an error | `DataFrame(table)` first, which writes Decimal128 |
+
+Arrow 2.x reads the other columns as its own types, as listed under [Values](@ref):
+timestamps as `DateTime`, strings as `String`, maps as `Dict`s.
+
+Arrow.jl releases before 2.4.2 stored `ZonedDateTime` columns as local times, labelled
+`JuliaLang.ZonedDateTime`. Arrow 3.0 warns about that label and reads the stored values
+as UTC instants, so rewrite such files with Arrow 2.x before reading them with 3.0.
diff --git a/docs/src/reading.md b/docs/src/reading.md
new file mode 100644
index 00000000..20678b78
--- /dev/null
+++ b/docs/src/reading.md
@@ -0,0 +1,264 @@
+```@raw html
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+```
+
+# Reading
+
+## Read a table
+
+[`Arrow.Table(source)`](@ref Arrow.Table) reads Arrow IPC data, in the file or the stream
+format, into columns. A table is a `Tables.AbstractColumns`: `table.fare`,
+`table[:fare]`, `table["fare"]`, `table[2]`, and `Tables.getcolumn(table, :fare)` return a
+column, `names(table)` lists them, `DataAPI.nrow(table)` and `DataAPI.ncol(table)` (the
+`nrow` and `ncol` DataFrames exports) count rows and columns, and any Tables.jl sink
+accepts the table.
+
+```@example reading
+using Arrow, DataFrames, Dates, Tables
+
+dir = mktempdir()
+path = joinpath(dir, "trips.arrow")
+Arrow.write(path, (id=1:6, fare=[7.5, 12.0, 3.25, 40.0, 9.5, 21.0],
+    zone=["A", "B", "A", "C", "B", "A"], day=Date(2025, 1, 1):Day(1):Date(2025, 1, 6)))
+
+table = Arrow.Table(path)
+```
+
+A source is a path, an `IO`, a byte vector, or an [`Arrow.AbstractArrowSource`](@ref)
+([Sources](@ref)); any other object that `open(source, "r")` accepts, such as a
+FilePathsBase.jl path, reads as the file or `IO` it opens. With FileIO.jl loaded,
+`load("trips.arrow")` reads a table too. Column types are listed under
+[Type mapping](@ref). Columns that share a name read as `a`, `a_1`, `a_2`, and so on, as
+CSV.jl names them. Two tables are `==` when their column names and columns are.
+
+## Columns are read-only views
+
+Numbers, booleans, dates, times, timestamps, decimals, and the indices of dictionary
+columns are read in place: such a column is an [`Arrow.ArrowVector`](@ref) that views the
+mapped file, the byte vector, or the decompressed buffer it was read from. Opening a
+table costs time per column and record batch, not per byte. A column of a file with
+several record batches is a `SentinelArrays.ChainedVector` of one view per batch.
+
+```@example reading
+table.fare
+```
+
+Strings and binary values read as a `DataStrings.StringVector` of `DataString`s and a
+`BytesVector` of `DataBytes`, built the first time the table hands the column out: 16
+bytes per value, over the source's own bytes. A string longer than 12 bytes is a view
+into the mapped file, the byte vector, or the decompressed buffer, so a `DataString`
+taken from the column keeps those bytes alive until it is garbage collected;
+`String(x)` copies it out. `stringtype=String` reads strings as `String`s, nested ones
+included, at the cost of one allocation per value. Lists, maps, and structs read as
+typed rows ([Nested values](@ref)).
+
+Columns are read-only:
+
+```@example reading
+try
+    table.fare[1] = 0.0
+catch err
+    err
+end
+```
+
+A column keeps the memory it reads alive for as long as the column is reachable, even
+after its table is gone.
+
+## Copy into Julia vectors
+
+`copy(column)` and `copy(table)` copy into owned, mutable columns: a `Vector` per column,
+a `PooledArray` for a dictionary column, and a `StringVector` for strings. A copied
+table's string columns hold their own bytes, so nothing of the source stays
+referenced. `DataFrame(table)` copies once, as `DataFrame` always does, but its string
+columns still share the source's bytes (DataStrings' `copy` keeps a column's buffers);
+`DataFrame(table; copycols=false)` keeps the views. [`Arrow.read(source,
+sink)`](@ref Arrow.read) reads and hands fully owned copies to a sink in one step:
+
+```@example reading
+df = Arrow.read(path, DataFrame)
+```
+
+`copy(table)` and `Arrow.read` also detach nested Arrow views. Lists become vectors,
+maps become `Dict`s (a repeated key keeps its last value, as a lookup on the map finds
+it), and structs and tuples keep their shape with owned child values. A copied table
+therefore keeps no dependency on the input's buffers. Nested values that were already
+ordinary Julia arrays follow Julia's usual shallow-copy behavior.
+
+## Memory mapping and lifetime
+
+A path is memory mapped by default, so opening a file larger than memory is cheap and
+only the pages a read touches are loaded. `mmap=false` reads the file into memory
+instead. The mapping lasts until the table and every column taken from it are garbage
+collected.
+
+`Arrow.write` to a mapped path writes a new file and renames it over the old one, so
+columns of the old file keep reading the old contents. On Linux and macOS, deleting or
+renaming a mapped file is safe too.
+
+!!! warning "Files that other programs rewrite in place"
+    If another program truncates and rewrites a file in place (`open(path, "w")`,
+    `CSV.write`, pyarrow, Polars, a shell redirect) while a column of a mapped table of
+    that file is alive, the next read of that column crashes Julia with a bus error
+    (SIGBUS). No check can prevent it: the operating system removes the pages under the
+    mapping. Read such files with `mmap=false`.
+
+!!! note "Windows"
+    Windows cannot delete a file while it is mapped, so there a path is read into memory
+    unless `mmap=true` is passed. With `mmap=true`, deleting the file fails until the
+    table and its columns are garbage collected; `Arrow.write` can still replace it.
+
+[`Arrow.release!(table)`](@ref Arrow.release!(::Arrow.Table)) ends a read: the table
+refuses further column access. A column taken before the release keeps working, and its
+memory is freed when it is garbage collected.
+
+```@example reading
+t = Arrow.Table(path)
+fares = t.fare
+Arrow.release!(t)
+sum(fares)
+```
+
+## Choose columns and rows
+
+`select` and `drop` choose columns (names, indices, a regex, a vector of them, or a
+function `(i, name) -> Bool` as in CSV.jl), `filter` keeps the rows where a predicate is
+`true`, `limit` caps the row count, and `offset` skips rows first. Only the selected and
+filter columns are read, a filter's other columns only for the record batches that keep
+rows, and a `limit` stops reading once it has its rows.
+
+```@example reading
+DataFrame(Arrow.Table(path; select=[:id, :fare], filter=Arrow.col(:fare) > 10, limit=2))
+```
+
+Predicates are the `Tables.col` family, which Arrow provides under its own names, so a
+filter needs no other package:
+
+- [`Arrow.col`](@ref) with `<`, `<=`, `>`, and `>=` against numbers, strings, and
+  characters;
+- [`Arrow.colcmp`](@ref) for equality and for other values, such as dates and
+  timestamps;
+- [`Arrow.colin`](@ref) for membership and [`Arrow.isnull`](@ref) for missing values;
+- `&`, `|`, and `!` to combine them.
+
+A row whose predicate is `missing` is dropped.
+
+```@example reading
+keep = Arrow.colcmp(==, Arrow.col(:zone), "A") &
+       Arrow.colcmp(>=, Arrow.col(:day), Date(2025, 1, 2))
+DataFrame(Arrow.Table(path; filter=keep))
+```
+
+A literal must be of its column's kind: comparing a string column with a number is an
+`ArgumentError` that names the column and both kinds of value. A `Date`, `DateTime`, or `Durations.Timestamp`
+compared with a UTC timestamp column (pandas' time-zone-aware data, DuckDB's
+TIMESTAMPTZ) is that time in UTC. A column in another zone needs a
+`Durations.ZonedTimestamp` literal, and the error says how to write one.
+
+`select` also takes `name => newname` to rename a column and `name => Type` to convert
+it, such as `:day => DateTime`; `scan` takes a `Tables.Scan` in place of all these
+keywords.
+
+```@example reading
+DataFrame(Arrow.Table(path; select=[:id, :fare => :amount], offset=1, limit=3))
+```
+
+A read that keeps every row reads its columns as a full read does: as views. A read with
+`filter`, `limit`, or `offset` copies the rows it keeps: numbers and other values into
+`Vector`s, strings and binary values into columns that hold just those values' bytes,
+and dictionary columns with their categories. These copies keep nothing else of the
+source alive, but kept list, map, and struct rows still read their record batch's
+buffers, which stay in memory (or keep the file mapped) as long as the rows do. A
+column's element type does not depend on the filter or on the kind of source.
+
+## Threads
+
+A read uses up to `ntasks` tasks (default `Threads.nthreads()`): record batches decode
+and decompress in parallel, columns build in parallel, a long string column builds in
+chunks of rows, and a filter is evaluated on several record batches at once, and in
+chunks of rows of a large one. `ntasks=1` reads on the calling task. The result is the same for every
+`ntasks`. Start Julia with threads (`julia -t 8`) for the tasks to run at once.
+
+## Metadata
+
+`DataAPI.metadata(table)` gives the schema's key-value metadata and
+`DataAPI.colmetadata(table, :fare)` a column's. `DataFrame(table)` and `Arrow.read(path,
+DataFrame)` keep both, and writing the table again keeps them too.
+[`Arrow.getmetadata(table)`](@ref Arrow.getmetadata) is the Arrow 2.x form.
+
+```@example reading
+using DataAPI
+meta = joinpath(dir, "meta.arrow")
+Arrow.write(meta, (fare=[7.5],); metadata=["source" => "meter"],
+    colmetadata=Dict(:fare => ["unit" => "USD"]))
+t = Arrow.Table(meta)
+(DataAPI.metadata(t), DataAPI.colmetadata(t, :fare))
+```
+
+## Sources
+
+- A **path** is memory mapped ([Memory mapping and lifetime](@ref)).
+- A **byte vector** is read in place: do not modify or resize it while its table's
+  columns are in use.
+- An **`IO`** is read to its end into memory by `Arrow.Table`; [`Arrow.Stream`](@ref)
+  reads a stream-format `IO` one record batch at a time ([Streams and IPC](@ref)). The
+  `IO` is not closed.
+- An [`Arrow.AbstractArrowSource`](@ref) supplies bytes by range, for storage the others
+  do not cover. It implements [`Arrow.sourcelength`](@ref) and [`Arrow.readrange`](@ref),
+  and [`Arrow.concurrentreads`](@ref) when ranges may be read on several tasks at once.
+  A read with `select`, `drop`, `filter`, `limit`, `offset`, or `scan` reads the
+  file-format footer from the end of the source, then plans only the byte ranges of the
+  record batches and columns it needs, whatever the filter compares, and fetches them in
+  a few coalesced ranges. A record batch of at most 1 MiB is fetched whole with its
+  metadata, so a file of many small batches is fetched almost whole. A `select`'s columns
+  view the fetched bytes in place, except that bytes filling less than half of a fetched
+  range are copied out of it, so a few columns do not keep the whole object in memory. A
+  read without them fetches the whole source in 8 MiB ranges.
+
+```@example reading
+struct CountingSource <: Arrow.AbstractArrowSource
+    bytes::Vector{UInt8}
+    fetched::Base.RefValue{Int}
+end
+Arrow.sourcelength(src::CountingSource) = length(src.bytes)
+function Arrow.readrange(src::CountingSource, offset, count)
+    src.fetched[] += count
+    return src.bytes[(offset + 1):(offset + count)]
+end
+
+big = joinpath(dir, "big.arrow")
+Arrow.write(big, (id=1:100_000, fare=rand(100_000), note=fill("no comment", 100_000)))
+src = CountingSource(read(big), Ref(0))
+fares = Arrow.Table(src; select=[:fare]).fare
+(bytes_fetched=src.fetched[], file_bytes=filesize(big))
+```
+
+With [CloudStore.jl](https://github.com/JuliaServices/CloudStore.jl) loaded, a
+`CloudStore.Object` (S3 or Azure Blob Storage) reads by ranged requests the same way:
+
+```julia
+using Arrow, CloudStore
+
+object = CloudStore.Object(bucket, "events/2025-01.arrow"; credentials)
+table = Arrow.Table(object; select=[:id, :amount])
+```
+
+`Serialization.serialize` of a table saves its values and schema; the deserialized table
+owns its columns.
diff --git a/docs/src/reference.md b/docs/src/reference.md
index 0409d76f..86786268 100644
--- a/docs/src/reference.md
+++ b/docs/src/reference.md
@@ -19,17 +19,85 @@
 -->
 ```
 
-# API Reference
+# API reference
 
-```@autodocs
-Modules = [Arrow]
-Order   = [:type, :function]
+```@docs
+Arrow
 ```
 
-## Internals: `Arrow.FlatBuffers`
+## Read
 
-The `FlatBuffers` module is not part of Arrow.jl's public API, and these functions may change without notice.
+```@docs
+Arrow.Table
+Arrow.read
+Arrow.Stream
+Arrow.release!(::Arrow.Table)
+Base.copy(::Arrow.Table)
+Arrow.getmetadata
+Arrow.Limits
+```
+
+## Filter
+
+```@docs
+Arrow.col
+Arrow.colcmp
+Arrow.colin
+Arrow.isnull
+```
+
+## Write
+
+```@docs
+Arrow.write
+Arrow.write(::Arrow.Writer, ::Any)
+Arrow.Writer
+Arrow.append
+Arrow.tobuffer
+Arrow.DictEncode
+```
+
+## Column and value types
+
+```@docs
+Arrow.ArrowVector
+Arrow.Primitive
+Arrow.BoolVector
+Arrow.DictEncoded
+Arrow.RunEndEncoded
+Arrow.ListVector
+Arrow.ListValue
+Arrow.MapVector
+Arrow.MapValue
+Arrow.StructVector
+```
+
+## Byte-range sources
+
+```@docs
+Arrow.AbstractArrowSource
+Arrow.sourcelength
+Arrow.readrange
+Arrow.concurrentreads
+```
+
+## Error types
+
+```@docs
+Arrow.ValidationError
+Arrow.AllocationLimitError
+```
+
+## C data and C stream interfaces
 
-```@autodocs
-Modules = [Arrow.FlatBuffers]
+```@docs
+Arrow.Table(::Ptr{Arrow.CArrowSchema}, ::Ptr{Arrow.CArrowArray})
+Arrow.Table(::Ptr{Arrow.CArrowArrayStream})
+Arrow.Stream(::Ptr{Arrow.CArrowArrayStream})
+Arrow.to_c_data
+Arrow.export_stream!
+Arrow.from_c_data
+Arrow.CArrowSchema
+Arrow.CArrowArray
+Arrow.CArrowArrayStream
 ```
diff --git a/docs/src/streams.md b/docs/src/streams.md
new file mode 100644
index 00000000..0eb1f6dc
--- /dev/null
+++ b/docs/src/streams.md
@@ -0,0 +1,137 @@
+```@raw html
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+```
+
+# Streams and IPC
+
+Arrow has two IPC formats. The **file** format starts with the `ARROW1` magic and ends
+with a footer that indexes the record batches, so a reader can open any batch directly;
+it suits files on disk. The **stream** format is a schema message, then dictionaries and
+record batches, then an end marker; a reader can process it as it arrives, so it suits
+pipes, sockets, and HTTP bodies. `Arrow.Table` and `Arrow.Stream` read both and detect
+which one they are given. `Arrow.write` writes the file format to a path and the stream
+format to an `IO`.
+
+## Read record batches
+
+[`Arrow.Stream(source)`](@ref Arrow.Stream) reads a source one record batch at a time;
+each iteration gives an `Arrow.Table` of one batch. It takes the keywords of
+`Arrow.Table`: `select`, `drop`, and `filter` apply to every batch, and `limit` and
+`offset` count rows across batches. A batch decodes only the selected and filter
+columns. Over an [`Arrow.AbstractArrowSource`](@ref) it fetches only their bytes, except
+that batches of at most 1 MiB are fetched whole, several to a request. A loop
+that processes and drops each batch holds one batch at a time, plus the dictionaries,
+so a source larger than memory reads in bounded memory.
+
+```@example streams
+using Arrow, DataAPI, DataFrames, Tables
+
+path = joinpath(mktempdir(), "batches.arrow")
+Arrow.write(path, Tables.partitioner([(id=[1, 2], x=[0.5, 1.5]), (id=[3], x=[2.5])]))
+
+stream = Arrow.Stream(path)
+[sum(batch.x) for batch in stream]
+```
+
+A stream is its own `Tables.partitions`, so `Arrow.write(out, Arrow.Stream(path))` writes
+one record batch per batch read. `Tables.schema(stream)`, `DataAPI.metadata(stream)`, and
+`DataAPI.colmetadata(stream, :x)` read no data. For the file format, `length(stream)` is
+the number of batches, `stream[i]` reads batch `i`, and `DataAPI.nrow(stream)` counts rows
+from the batches' metadata:
+
+```@example streams
+(length(stream), DataAPI.nrow(stream), DataFrame(stream[2]))
+```
+
+A stream-format source has no index: it is read in order, its batch count is known only
+once it has been read, and an `Arrow.Stream` over an `IO` can be iterated once.
+
+## Read a stream as it arrives
+
+Over a stream-format `IO`, `Arrow.Stream` reads each record batch when the iteration
+reaches it, so a consumer processes batches while the producer is still writing.
+[`Arrow.Writer(io)`](@ref Arrow.Writer) is the producer's side: each
+`Arrow.write(writer, table)` writes that table's batches to the `IO` before it returns,
+and `close(writer)` writes the end marker and leaves the `IO` open. Here the two ends of
+a TCP connection are in one process:
+
+```@example streams
+using Sockets
+
+port, server = listenany(ip"127.0.0.1", 40000)
+producer = @async begin
+    socket = accept(server)
+    Arrow.Writer(socket) do writer
+        for i in 1:3
+            Arrow.write(writer, (batch=[i, i], value=[10i, 10i + 1]))
+        end
+    end
+    close(socket)
+end
+
+client = connect(ip"127.0.0.1", port)
+received = [collect(batch.value) for batch in Arrow.Stream(client)]
+wait(producer); close(client); close(server)
+received
+```
+
+An `IO` that buffers its writes, such as a file's `IOStream`, may hold a batch until
+`flush(io)`. [`Arrow.append`](@ref) adds batches to the end of an existing stream in a
+file or a seekable `IO`.
+
+`Arrow.Table(io)` reads an `IO` to its end and refuses bytes after a stream's end marker.
+To read several streams written one after another to one `IO`, call `Arrow.Stream(io)`
+once per stream: each call reads one stream and stops after its end marker.
+
+```@example streams
+io = IOBuffer()
+Arrow.write(io, (a=[1],))
+Arrow.write(io, (a=[2, 3],))
+seekstart(io)
+[[collect(batch.a) for batch in Arrow.Stream(io)] for _ in 1:2]
+```
+
+## Bytes in memory
+
+[`Arrow.tobuffer(table)`](@ref Arrow.tobuffer) writes a table in the stream format to a
+new `IOBuffer`, positioned at its start, and `Arrow.Table(bytes)` reads a byte vector in
+place:
+
+```@example streams
+bytes = take!(Arrow.tobuffer((a=[1, 2],)))
+Arrow.Table(bytes).a
+```
+
+## Other Arrow implementations
+
+Other Arrow implementations read both formats: pyarrow reads streams with
+`pyarrow.ipc.open_stream` and files with `pyarrow.ipc.open_file`, Polars with
+`polars.read_ipc_stream` and `polars.read_ipc`. Arrow.jl reads what they write:
+
+```python
+import pyarrow as pa, pyarrow.ipc as ipc, sys
+
+table = pa.table({"id": [1, 2, 3]})
+with ipc.new_stream(sys.stdout.buffer, table.schema) as writer:
+    writer.write_table(table)       # julia: for batch in Arrow.Stream(stdin) ... end
+```
+
+To exchange columns with another implementation in the same process without IPC bytes,
+use the [C data interface](@ref "C data interface").
diff --git a/docs/src/types.md b/docs/src/types.md
new file mode 100644
index 00000000..9b19adf9
--- /dev/null
+++ b/docs/src/types.md
@@ -0,0 +1,295 @@
+```@raw html
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+```
+
+# Type mapping
+
+## Arrow to Julia
+
+A column's element type comes from its Arrow type alone, never from its values, so an
+empty or all-missing column has the same type as a full one. A nullable field's elements
+are `Union{Missing,T}`.
+
+| Arrow type | Julia element type |
+|:--|:--|
+| Int8-Int64, UInt8-UInt64, Float16-Float64, Bool | the same type |
+| Utf8, LargeUtf8, Utf8View | `DataStrings.DataString` (the column is a `StringVector`); `String` with `stringtype=String` |
+| Binary, LargeBinary, BinaryView | `DataStrings.DataBytes` (the column is a `BytesVector`) |
+| FixedSizeBinary(N) | `NTuple{N,UInt8}`; `DataBytes` when N > 256 |
+| Date32, Date64 | `Dates.Date`, `Dates.DateTime` |
+| Time32, Time64 | `Dates.Time` |
+| Timestamp(unit) | `Durations.Timestamp{unit}` |
+| Timestamp(unit, zone) | `Durations.ZonedTimestamp{unit,Symbol(zone)}` |
+| Duration(unit) | `Dates.Second`, `Millisecond`, `Microsecond`, or `Nanosecond` |
+| Interval | `Durations.Duration` |
+| Decimal32/64/128/256(P, S) | `DataDecimals.Decimal{P,S,T}`, `T` the 32- to 256-bit integer of the type's width |
+| List, LargeList, ListView, LargeListView | [`Arrow.ListValue{T}`](@ref Arrow.ListValue) |
+| FixedSizeList(N) | `NTuple{N,T}`, or `ListValue{T}` when N > 64 or values may be null |
+| Struct | a `NamedTuple` |
+| Map | [`Arrow.MapValue{K,V}`](@ref Arrow.MapValue) |
+| Dense and sparse Union | a `Union` of the children's types |
+| Dictionary, run-end encoded | the values' type, in an [`Arrow.DictEncoded`](@ref) or [`Arrow.RunEndEncoded`](@ref) column |
+| Null | `Missing` |
+
+Extension types read as their Julia type: canonical `arrow.uuid` as `UUIDs.UUID`,
+`arrow.bool8` as `Bool`, `arrow.fixed_shape_tensor` as `Array{T,N}` rows, and the labels
+Arrow.jl writes ([Julia to Arrow](@ref)) as the Julia type that wrote them. `arrow.json`
+and `arrow.opaque` read as their storage, strings or bytes. Another extension name reads
+as its storage too, with one warning per name per process, unless a package defines a
+mapping for it ([Custom types](@ref)).
+
+A decimal with a negative scale, or a scale above its precision, reads as it is stored:
+integers for Decimal32 and Decimal64, little-endian bytes for Decimal128 and Decimal256.
+A decimal value with more digits than its precision reads as stored, as pyarrow reads
+it. A time of day outside [0, 24 h) has no `Dates.Time` value and fails the read
+with an error naming the column.
+
+## Julia to Arrow
+
+Each column's element type decides its Arrow type, at any depth. Values read back as the
+same type unless the table says otherwise.
+
+| Julia element type | Arrow type | Reads back as |
+|:--|:--|:--|
+| `Int8`-`Int64`, `UInt8`-`UInt64`, `Float16`-`Float64`, `Bool` | the same type | the same type |
+| `AbstractString` (`String`, `SubString`, `DataString`) | Utf8 | `DataString` |
+| InlineStrings' `String1`-`String255` | Utf8, labelled by InlineStrings | the same type |
+| `Symbol`, `Char` | Utf8, UInt32; labelled | `Symbol`, `Char` |
+| `Vector{UInt8}`, `DataBytes` | Binary | `DataBytes` |
+| `NTuple{N,UInt8}` | FixedSizeBinary(N) | `NTuple{N,UInt8}` |
+| `Int128`, `UInt128` | FixedSizeBinary(16), labelled `JuliaLang.Int128`/`UInt128` | the same type |
+| `UUID` | `arrow.uuid` | `UUID` |
+| `Date`, `Time` | Date32, Time64(nanosecond) | `Date`, `Time` |
+| `DateTime` | Timestamp(millisecond) | `Durations.Timestamp{Millisecond}` |
+| `Durations.Timestamp{P}` | Timestamp(P) | `Durations.Timestamp{P}` |
+| `Durations.ZonedTimestamp{P,Z}` | Timestamp(P, zone `Z`) | `Durations.ZonedTimestamp{P,Z}` |
+| `TimeZones.ZonedDateTime` (with TimeZones loaded), one zone per column | Timestamp(millisecond, zone) | `ZonedTimestamp{Millisecond,Z}` |
+| `Nanosecond`-`Second` | Duration of that unit | the same type |
+| `Minute`, `Hour`, `Day`, `Week` | Duration(second), labelled | the same type |
+| `Month`, `Year` | Interval(year-month), labelled | the same type |
+| `Durations.Duration` | Interval(month-day-nano) | `Durations.Duration` |
+| `DataDecimals.Decimal{P,S}` | Decimal128(P, S), or Decimal256 when P > 38 | `Decimal{P,S}`, stored in `Int128` or `Int256` |
+| `PooledArray`, `CategoricalArray` | Dictionary of the pool's values; ordered if the array is | an `Arrow.DictEncoded` column |
+| `AbstractVector{T}` | List | `ListValue{T}` |
+| `NTuple{N,T}` | FixedSizeList(N) | `NTuple{N,T}` |
+| other `Tuple`s | Struct with fields `1`, `2`, ..., labelled | the same type |
+| `NamedTuple` | Struct | `NamedTuple` |
+| `AbstractDict{K,V}`, `AbstractVector{<:Pair}` | Map | `MapValue{K,V}` |
+| `Union{Missing,T}` | the type of `T`, nullable | `Union{Missing,T}` |
+| `Union{T1,T2,...}` | dense Union, or one type that every member writes | a `Union` of the members' types as read |
+| `VersionNumber`, `Nothing` | Utf8, Null; labelled | the same type |
+| `Missing` only | Null | `Missing` |
+
+"Labelled" means the column carries an `ARROW:extension:name` such as
+`JuliaLang.Symbol`, so Arrow.jl reads the Julia type back; other readers see the
+storage type. SentinelArrays' `ChainedVector` and CSV.jl's columns write without being
+collected first.
+
+A column whose element type is abstract (`Any`, `Real`, a `NamedTuple` with open field
+types) is written as the types its values have: one type writes as that type, and up to
+8 types as a dense Union of them. When all the types in such a column, or all the members
+of a `Union` element type, write the same Arrow type, label included, the column is one
+column of that type and reads back as it: `Union{String,SubString{String}}` writes one
+Utf8 column, and two structs whose ArrowTypes.jl mappings give an `Int32` with no label
+(or with one label they share) write one Int32 column. Two structs without mappings
+that have the same fields are the exception: they write a dense Union. A column of
+`Timestamp`s, `ZonedTimestamp`s, or `Decimal`s that mixes units, zones, or precisions is
+an error, since one Arrow column has one of each (`Durations.astimezone` gives a column
+one zone). A type with no Arrow type, such as `BigInt`, an `@enum`, or a `Matrix`, is an
+error that names the column; map it with [Custom types](@ref), or convert it first.
+
+## Timestamps
+
+Timestamps read as `Durations.Timestamp{P}` and `Durations.ZonedTimestamp{P,Z}` at the
+column's unit: 8-byte values that hold the stored instant exactly, at every unit, with no
+time-zone database. A `Timestamp` compares and hashes equal to the `DateTime` at the
+same time, so a `DateTime` column reads back equal to what was written, and
+`DateTime(ts)` converts (truncating below a millisecond).
+
+A `ZonedTimestamp{P,Z}` holds a UTC instant and its zone `Z`. Instants compare with each
+other across zones, but never equal a `DateTime`, which has no zone; `DateTime(zt)` gives
+the local time in `Z`. UTC and fixed offsets such as `+05:30` need nothing else; named
+zones such as `America/New_York` need TimeZones.jl loaded for local times and for
+`ZonedDateTime(zt)`.
+
+```@example types
+using Arrow, Dates, Durations
+
+io = IOBuffer()
+Arrow.write(io, (at=[DateTime(2025, 1, 1, 12)],
+    utc=[Durations.ZonedTimestamp{Millisecond,:UTC}(2025, 1, 1, 12)]))
+table = Arrow.Table(take!(io))
+table.at
+```
+
+```@example types
+table.at[1] == DateTime(2025, 1, 1, 12)
+```
+
+```@example types
+table.utc
+```
+
+To read a timestamp column as `DateTime`s, give the type in `select`:
+`Arrow.Table(path; select=[:id, :at => DateTime])`.
+
+## Decimals
+
+Decimals read as `DataDecimals.Decimal{P,S,T}` whose storage integer `T` matches the
+Arrow type's width: `Int32` for Decimal32, `Int64` for Decimal64, `Int128` for
+Decimal128, and `DataDecimals.Int256` for Decimal256. They write as Decimal128 up to 38
+digits and Decimal256 above, as pyarrow, Polars, and DuckDB write them, whatever the
+storage of the Julia value. So `dec"1.25"`, a `Decimal{3,2,Int32}`, reads back as the
+equal `Decimal{3,2,Int128}`. Rewriting a column read from a Decimal32 or Decimal64 field
+keeps that width.
+
+## Strings and bytes
+
+A `DataStrings.DataString` is a 16-byte value: strings of up to 12 bytes are stored in
+the value, longer ones refer to the column's bytes. It is an `AbstractString` that
+compares and hashes equal to the `String` with the same characters; `String(s)` makes
+one. A `StringVector` writes as Utf8 in one pass over its values, or as Utf8View with
+`stringview=true`. DuckDB 1.5's `read_arrow` and other older readers refuse the view
+types, so they are written only on request.
+
+## Nested values
+
+Lists, maps, and structs read as typed rows, in [`Arrow.ListVector`](@ref),
+[`Arrow.MapVector`](@ref), and [`Arrow.StructVector`](@ref) columns:
+
+- A list row is an [`Arrow.ListValue{T}`](@ref Arrow.ListValue), a read-only
+  `AbstractVector{T}` view of the column's values; `copy(row)` gives a `Vector{T}`.
+- A struct row is a `NamedTuple` of its fields, built when it is read. A struct with
+  more than 64 fields, or with repeated field names, reads as a `Vector` of
+  `name => value` pairs instead.
+- A map row is an [`Arrow.MapValue{K,V}`](@ref Arrow.MapValue), an `AbstractDict{K,V}`
+  over the map's entries in stored order: `row[key]`, `get`, and `haskey` look keys up,
+  and iteration gives `key => value` pairs, duplicate keys included (a lookup finds the
+  last). `Dict(row)` builds a `Dict`.
+- A union value is a value of one of the children's types.
+
+`T` includes `Missing` only when the schema allows null elements, and a null list,
+struct, or map reads as `missing`. Rows stay valid after their table is gone. Copies of a
+nested column (`copy`, `DataFrame(table)`) are `Vector`s of plain rows, and the writer
+takes plain rows back: vectors, named tuples, dictionaries, and vectors of pairs.
+
+```@example types
+io = IOBuffer()
+Arrow.write(io, (tags=[["a", "b"], String[]], point=[(x=1.0, y=2.0), (x=3.0, y=4.0)],
+    attrs=[Dict("k" => 1), Dict("j" => 2, "k" => 3)]))
+nested = Arrow.Table(take!(io))
+nested.attrs
+```
+
+```@example types
+(nested.point[2].y, nested.attrs[2]["k"], copy(nested.tags[1]))
+```
+
+Each level of a typed row nests one more type, and Julia compiles deep ones slowly. A
+column nested more than 8 levels deep therefore reads with untyped rows: lists as
+`Vector{Any}` and structs as `name => value` pairs.
+
+## Dictionary columns
+
+A dictionary column reads as an [`Arrow.DictEncoded`](@ref) of its values' type.
+`DataAPI.refarray`, `DataAPI.refpool`, and `DataAPI.levels` expose the encoding without
+decoding it; `levels` follows the dictionary's order. `copy(column)` gives a
+`PooledArray`. With CategoricalArrays.jl loaded, `isordered(column)` tells whether the
+dictionary is ordered, and `categorical` rebuilds a `CategoricalArray` with its order:
+
+```@example types
+using CategoricalArrays, DataAPI
+
+sizes = categorical(["small", "large", "medium"]; levels=["small", "medium", "large"],
+    ordered=true)
+io = IOBuffer()
+Arrow.write(io, (size=sizes,))
+column = Arrow.Table(take!(io)).size
+cat = categorical(column; levels=DataAPI.levels(column), ordered=isordered(column))
+(levels(cat), cat[1] < cat[2])
+```
+
+## Custom types
+
+[ArrowTypes.jl](https://github.com/apache/arrow-julia/tree/main/src/ArrowTypes) maps
+Julia types to Arrow types. A package that owns a type depends on ArrowTypes and defines
+`ArrowTypes.ArrowType` and `ArrowTypes.toarrow` to write it as a supported type; to read
+it back, it also names an extension with `ArrowTypes.arrowname` and defines
+`ArrowTypes.JuliaType` and `ArrowTypes.fromarrow`:
+
+```@example types
+import ArrowTypes
+
+struct AccountID
+    value::Int64
+end
+
+const ACCOUNT_ID = Symbol("JuliaLang.Example.AccountID")
+ArrowTypes.ArrowType(::Type{AccountID}) = Int64
+ArrowTypes.toarrow(id::AccountID) = id.value
+ArrowTypes.arrowname(::Type{AccountID}) = ACCOUNT_ID
+ArrowTypes.JuliaType(::Val{ACCOUNT_ID}, ::Type{Int64}, metadata) = AccountID
+ArrowTypes.fromarrow(::Type{AccountID}, value::Int64) = AccountID(value)
+
+io = IOBuffer()
+Arrow.write(io, (id=AccountID.(1:3),))
+Arrow.Table(take!(io)).id
+```
+
+The mapping applies at any depth: in lists, structs, maps, unions, and dictionaries.
+An `ArrowType` that is a `Union` with `Missing` as a member is refused, since a stored
+`missing` could not be told from a null value; declare the storage without `Missing` and
+write the column's missing values as such.
+`ArrowTypes.arrowmetadata` adds a string the reader passes to `JuliaType`. Without a
+mapping, a struct with supported field types writes as an Arrow struct and reads back as
+a `NamedTuple`. In a process that has not loaded the mapping, the column reads as its
+storage, with one warning.
+
+## Rewriting tables
+
+Writing an `Arrow.Table` or `Arrow.Stream` keeps its schema: each column's Arrow type,
+with its units, offset widths, union mode, dictionary index type and order, run-end
+encoding, and list views, along with nullability and metadata. Copying it into Julia
+vectors first (`DataFrame(table)`, `copy(table)`) keeps only what the Julia types say,
+so some types change on the way back while the values stay equal:
+
+| Read from | Written from Julia vectors as |
+|:--|:--|
+| LargeUtf8, Utf8View; LargeBinary, BinaryView | Utf8; Binary |
+| LargeList, ListView, FixedSizeList with nullable values | List |
+| Date64 | Timestamp(millisecond) |
+| Time32, Time64(microsecond) | Time64(nanosecond) |
+| Decimal32, Decimal64 | Decimal128 |
+| Dictionary with Int16-Int64 indices | Dictionary with the narrowest indices |
+| Ordered Dictionary | Dictionary, not ordered: a `PooledArray` has no order ([Dictionary columns](@ref) shows how to keep it) |
+| Run-end encoded | plain values |
+| Sparse or dense Union | dense Union with a Null child |
+| `arrow.bool8`, `arrow.json` | Bool, Utf8 |
+| Interval(year-month or day-time) | Interval(month-day-nano) |
+
+A rewrite keeps every type except Int(128) and UInt(128), which Polars and Arrow 2.x
+write and pyarrow cannot read: they rewrite as FixedSizeBinary(16) labelled
+`JuliaLang.Int128` or `JuliaLang.UInt128`, as a fresh Julia `Int128` column writes, which
+Arrow.jl reads back as the same values and Polars reads as binary.
+
+A union with two children of the same type cannot be rewritten as it was, because its
+values do not say which child they came from; writing it is an error that suggests
+`Arrow.write(path, DataFrame(table))`. A dictionary column nested inside another column
+is refused the same way.
diff --git a/docs/src/writing.md b/docs/src/writing.md
new file mode 100644
index 00000000..e307c914
--- /dev/null
+++ b/docs/src/writing.md
@@ -0,0 +1,228 @@
+```@raw html
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+```
+
+# Writing
+
+## Write a table
+
+[`Arrow.write(sink, table)`](@ref Arrow.write) writes any Tables.jl source (a
+`DataFrame`, a `NamedTuple` of vectors, a `CSV.File`, an `Arrow.Table`) to a path or an
+`IO` and returns the sink. FilePathsBase.jl local paths (`SystemPath`) work like string
+paths, including atomic replacement and `Arrow.append`. Any other object that
+`open(sink, "w")` accepts is written in place. `Arrow.write(sink)` returns a
+function, so a table can be piped into it, as in
+`CSV.File("trips.csv") |> Arrow.write("trips.arrow")`. With FileIO.jl loaded,
+`save("trips.arrow", table)` writes a table as well.
+
+```@example writing
+using Arrow, Tables
+
+dir = mktempdir()
+path = joinpath(dir, "trips.arrow")
+table = (id=[1, 2, 3], fare=[7.5, 12.0, missing])
+Arrow.write(path, table)
+table |> Arrow.write(path)
+Arrow.write(path, table; compress=:zstd)
+Arrow.Table(path).fare
+```
+
+A path gets the IPC **file** format: the `ARROW1` magic, the record batches, and a footer
+that indexes them, so readers can open any batch directly. An `IO` gets the **stream**
+format, which has no footer and can be read as it arrives ([Streams and IPC](@ref)).
+`file=true` or `file=false` overrides the choice. [`Arrow.tobuffer(table)`](@ref
+Arrow.tobuffer) writes the stream format to a new `IOBuffer`.
+
+```@example writing
+(String(read(path, 6)), String(take!(Arrow.write(IOBuffer(), table; file=true))[1:6]))
+```
+
+Writing to an existing path writes a temporary file in the same directory and renames it
+over the old one at the end. A failed write leaves the old file unchanged, a table that
+maps the old file keeps reading it, the file keeps its permissions, a symlink is written
+through, and a read-only file is refused. An `IO` is left open.
+
+The keywords:
+
+| keyword | default | |
+|:--|:--|:--|
+| `file` | `true` for a path, `false` for an `IO` | the file format, or the stream format |
+| `compress` | `nothing` | `:lz4` (LZ4 frame) or `:zstd` |
+| `compresslevel` | `nothing` | the codec's level: LZ4 up to 12 (default 0), Zstandard up to 22 (default 3) |
+| `batchsize` | `1_048_576` | rows per record batch |
+| `dictencode` | `nothing` | `true`, or a column name or names: dictionary-encode those columns too; `false`: write pooled columns as values |
+| `dictdeltas` | `false` | write the categories a dictionary gains as delta dictionaries |
+| `largelists` | `false` | 64-bit offsets: LargeUtf8, LargeBinary, LargeList |
+| `stringview` | `false` | write strings and bytes as Utf8View and BinaryView |
+| `metadata`, `colmetadata` | the table's | schema and column key-value metadata |
+| `ntasks` | `Threads.nthreads()` | tasks that build columns and compress buffers |
+
+[`Arrow.Writer`](@ref) also takes `nullable` and `dictreplacement`. A misspelled keyword is
+an `ArgumentError` that lists the valid ones; the Arrow 2.x keywords `alignment`,
+`dictencodenested`, `denseunions`, and `maxdepth` are accepted with a warning and ignored.
+
+## Column types
+
+Each column's element type decides its Arrow type, at any depth: a `Vector{Date}` inside a
+list writes the type a `Date` column writes. [Type mapping](@ref) lists every type in both
+directions.
+
+Strings must be valid UTF-8, as the format requires: a string that is not fails the write
+with an error naming its column and row. Write bytes that are not text as `Vector{UInt8}`
+values, which write as Binary.
+
+Utf8, Binary, and List store 32-bit offsets, which address 2 GiB of data in one record
+batch. A batch whose strings, bytes, or list values would pass that is cut into smaller
+batches, so the declared types never change. `largelists=true` declares 64-bit offsets
+instead; a single value larger than 2 GiB needs it.
+
+## Batches and partitions
+
+Each `Tables.partitions` partition of the source becomes one or more record batches of at
+most `batchsize` rows; a partition with no rows adds none, so a table with no rows writes
+its schema alone. `Arrow.write(path, Arrow.Stream(src))` keeps the source's record
+batches. Partitions are read, encoded, and written one at a time, so
+`Arrow.write("big.arrow", CSV.Chunks("big.csv"))` holds about one chunk in memory.
+
+The first partition fixes the schema. With several partitions, or a source whose
+partition count is unknown, every field is declared nullable, since a later partition
+may hold missing values the first did not (pyarrow and Polars write partitioned data the
+same way), so such a table reads back with
+`Union{Missing,T}` columns. Later partitions must have the same columns in the same
+order, with values that convert exactly (an `Int32` partition fits an `Int64` column);
+anything else is an error naming the column.
+
+## Compression
+
+`compress=:lz4` or `:zstd` compresses each buffer of each record batch and dictionary on
+its own, as the format defines; a buffer that does not shrink is stored uncompressed.
+pyarrow and Polars read both codecs; DuckDB 1.5's `read_arrow` reads Zstandard but not
+LZ4. Zstandard usually writes smaller files; LZ4 is faster to write and read.
+
+## Dictionary encoding
+
+A dictionary-encoded column stores each distinct value once and an integer index per row.
+Low-cardinality strings, such as a region or a status, are the usual case. A column is
+dictionary encoded when
+
+- it is wrapped in [`Arrow.DictEncode`](@ref);
+- it has a `DataAPI.refpool`, as a `PooledArray`, a `CategoricalArray`, and a dictionary
+  column read from Arrow do: its pool becomes the dictionary, in pool order and with
+  unused entries, and an ordered `CategoricalArray` writes an ordered dictionary; or
+- `dictencode` names it, or is `true`.
+
+`dictencode=false` writes pooled and categorical columns, and dictionary columns read
+from Arrow, as plain values, for readers that refuse dictionaries such as DuckDB 1.5's
+`read_arrow`; an `Arrow.DictEncode` column stays encoded. A pooled column of `UUID`s, or
+one `dictencode` names, is written unencoded, because pyarrow cannot read a dictionary of
+`arrow.uuid` values; an `Arrow.DictEncode` of `UUID`s is an error that names the column.
+A dictionary of `UUID`s read from Arrow keeps its encoding unless `dictencode=false`.
+
+```@example writing
+using PooledArrays
+
+Arrow.write(path, (region=Arrow.DictEncode(["east", "west", "east"]),
+    status=PooledArray(["open", "closed", "open"]), id=[1, 2, 3]))
+t = Arrow.Table(path)
+t.region
+```
+
+The indices are the narrowest signed integers that hold the dictionary (`Int8` up to 128
+values) for a known one-partition table, and `Int32` for several or an unknown number of
+partitions and for an `Arrow.Writer`, since later tables may add values. Reading gives a
+[`Arrow.DictEncoded`](@ref) column: `DataAPI.refarray`, `DataAPI.refpool`, and
+`DataAPI.levels` expose the encoding, and `copy` gives a `PooledArray`.
+
+### Dictionaries that grow
+
+When a later partition, or a later table given to an `Arrow.Writer`, has new values, the
+column keeps one dictionary: the new values follow the earlier ones. How the growth is
+written, and who reads it:
+
+| output | default | `dictdeltas=true` |
+|:--|:--|:--|
+| file | the whole dictionary once, after the record batches | a delta dictionary with the new values |
+| stream | the whole dictionary again, before the batch that needs it | a delta dictionary with the new values |
+| read by | pyarrow, Polars | pyarrow; not Polars 1.43 |
+
+Arrow 2.x reads all of these, but with several threads it can fail on the default file
+output with a `KeyError`, decoding a record batch before the dictionary written after it;
+write such files with `dictdeltas=true` when Arrow 2.x readers need them. DuckDB 1.5's
+`read_arrow` refuses dictionaries in every form.
+
+A stream [`Arrow.Writer`](@ref) created with `dictreplacement=true` instead replaces each
+dictionary with the next table's own values. The schema then declares the
+DictionaryReplacement feature, which some readers (nanoarrow) refuse.
+
+## Write in parts
+
+[`Arrow.Writer`](@ref) writes one output from several tables, such as batches that do
+not fit in memory together. Each `Arrow.write(writer, table)` encodes that table's record
+batches and hands them to the sink before it returns; `close` finishes the output, and the
+function form closes it. If the function throws, the writer is abandoned instead, so an
+existing file is kept, unless the sink is an `IO` that already received a table: then the
+function form closes it, and the `IO` holds the tables written before the error. A writer
+to a path writes nothing to that path until `close`: an existing file is replaced then,
+from a temporary file beside it, and a new file holds no complete output before.
+
+```@example writing
+Arrow.Writer(path) do writer
+    Arrow.write(writer, (id=[1, 2], name=["a", "b"]))
+    Arrow.write(writer, (id=Int32[3], name=[missing]))
+end
+Arrow.Table(path).name
+```
+
+The first table fixes the column names, order, and types. Every column is declared
+nullable unless the writer was created with `nullable=false`, so later tables may hold
+missing values. Later tables convert to the first table's types exactly: an `Int32`
+column fits an `Int64` one, but a `Float64` column does not. A table that does not conform is
+an error naming the column and both types; the batches written before it stay in the
+output and the writer stays open. A writer closed before it receives a table writes an
+output with no columns. A writer that is never closed leaves an `IO` without its footer or
+end marker, and leaves a path as it was, beside a stray temporary file (`jl_` and random
+letters) or a new file without its footer or end marker.
+
+[`Arrow.append(path, table)`](@ref Arrow.append) adds a table's record batches to an
+existing stream-format file (or a seekable `IO`), under the same rules; a missing or empty
+file starts a new stream. The file format cannot be appended to, since its footer would
+have to be rewritten: produce it with an `Arrow.Writer`, or rewrite it with
+`Arrow.write`.
+
+## Metadata
+
+`metadata` sets the schema's key-value pairs and `colmetadata` each column's, as a `Dict`
+or a vector of pairs; `colmetadata` maps column names, as `Symbol`s or strings, to them.
+Values that are not strings are written as they print. Both default to the
+table's DataAPI metadata, so a `DataFrame`'s `metadata` and `colmetadata` are written;
+keys under the reserved `ARROW:` prefix are not. Writing an `Arrow.Table` or
+`Arrow.Stream` keeps its schema and column metadata.
+
+## Memory and threads
+
+A write holds the partition it is writing, the record batch it is building and that
+batch's encoded buffers, and, in the file format, each dictionary that grows until it is
+written at the end. Columns that are already Arrow layouts, such as the views of an
+`Arrow.Table`, are written from their own memory without a copy.
+
+The columns of a record batch are built and its buffers compressed on up to `ntasks`
+tasks (default `Threads.nthreads()`); with compression, a batch compresses while the next
+one builds. `ntasks=1` writes on the calling task. The bytes written are the same for
+every `ntasks`.
diff --git a/ext/ArrowCategoricalArraysExt.jl b/ext/ArrowCategoricalArraysExt.jl
new file mode 100644
index 00000000..a313f15d
--- /dev/null
+++ b/ext/ArrowCategoricalArraysExt.jl
@@ -0,0 +1,29 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# An ordered CategoricalArray writes an ordered Arrow dictionary, and
+# `isordered` reads a dictionary column's flag.
+module ArrowCategoricalArraysExt
+
+import Arrow
+import CategoricalArrays
+
+Arrow._isordered(x::CategoricalArrays.CategoricalArray) = CategoricalArrays.isordered(x)
+CategoricalArrays.isordered(x::Arrow.DictEncoded) = Arrow._isordered(x)
+CategoricalArrays.isordered(x::Arrow.ChainedVector{T,<:Arrow.DictEncoded}) where {T} =
+    Arrow._isordered(x)
+
+end
diff --git a/ext/ArrowCloudStoreExt.jl b/ext/ArrowCloudStoreExt.jl
new file mode 100644
index 00000000..5d1bfb1d
--- /dev/null
+++ b/ext/ArrowCloudStoreExt.jl
@@ -0,0 +1,74 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# CloudStore.jl objects as Arrow byte-range sources: `Arrow.Table(obj;
+# scan=…)` reads only the selected columns' bytes from S3, Azure Blob
+# Storage through HTTP `Range` requests.
+module ArrowCloudStoreExt
+
+using Arrow
+using CloudStore: CloudStore, Object
+
+"""
+    CloudObjectSource(obj::CloudStore.Object) <: Arrow.AbstractArrowSource
+
+A `CloudStore.Object` as an [`Arrow.AbstractArrowSource`](@ref): the length
+is the object's known size, one range is one HTTP `Range` GET pinned to the
+object's ETag with `If-Match` (an overwritten key fails the read instead of
+mixing versions across requests), and Arrow issues up to
+`CONCURRENT_RANGE_READS` of a round's ranges at once. `Arrow.Table(obj; …)`
+and `Arrow.Stream(obj; …)` construct one implicitly.
+"""
+struct CloudObjectSource{O<:Object} <: Arrow.AbstractArrowSource
+    obj::O
+end
+
+# Independent HTTP range GETs are latency-bound, so a round's requests are
+# worth overlapping; the bound keeps a fragmented object from becoming a
+# request storm.
+const CONCURRENT_RANGE_READS = 16
+
+Arrow.sourcelength(s::CloudObjectSource) = Int64(s.obj.size)
+Arrow.concurrentreads(::CloudObjectSource) = CONCURRENT_RANGE_READS
+
+# The object's ETag as an `If-Match` value (the header wants it quoted).
+function _ifmatch(etag::AbstractString)
+    isempty(etag) && return nothing
+    return startswith(etag, '"') ? String(etag) : string('"', etag, '"')
+end
+
+function Arrow.readrange(s::CloudObjectSource, off, len)
+    len == 0 && return UInt8[]
+    last = off + len - 1
+    obj = s.obj
+    headers = ["Range" => "bytes=$(off)-$(last)"]
+    etag = _ifmatch(obj.eTag)
+    etag === nothing || push!(headers, "If-Match" => etag)
+    bytes = CloudStore.get(
+        obj.store,
+        obj.key;
+        credentials=obj.credentials,
+        headers=headers,
+        allowMultipart=false,
+        objectMaxSize=Int(len),
+    )
+    return bytes isa Vector{UInt8} ? bytes : Vector{UInt8}(bytes)
+end
+
+Arrow.Table(obj::Object; kw...) = Arrow.Table(CloudObjectSource(obj); kw...)
+Arrow.Stream(obj::Object; kw...) = Arrow.Stream(CloudObjectSource(obj); kw...)
+
+end # module
diff --git a/ext/ArrowDataFramesExt.jl b/ext/ArrowDataFramesExt.jl
new file mode 100644
index 00000000..d296dce8
--- /dev/null
+++ b/ext/ArrowDataFramesExt.jl
@@ -0,0 +1,54 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Precompiles the reads and writes of a DataFrame, so the first one in a session
+# does not compile them. It adds no methods.
+module ArrowDataFramesExt
+
+import Arrow
+import DataFrames
+import Dates
+import PooledArrays
+import PrecompileTools
+
+PrecompileTools.@setup_workload begin
+    table = (
+        id=Int64[1, 2, 3],
+        x=Float64[1.5, 2.5, 3.5],
+        y=Union{Missing,Float64}[1.5, missing, 3.5],
+        name=["a", "a longer string than twelve bytes", "c"],
+        note=Union{Missing,String}["a", missing, "c"],
+        day=[Dates.Date(2025, 1, 1), Dates.Date(2025, 1, 2), Dates.Date(2025, 1, 3)],
+        at=[
+            Dates.DateTime(2025, 1, 1),
+            Dates.DateTime(2025, 1, 2),
+            Dates.DateTime(2025, 1, 3),
+        ],
+        flag=[true, false, true],
+        pool=PooledArrays.PooledArray(["u", "v", "u"]),
+    )
+    PrecompileTools.@compile_workload begin
+        bytes = take!(Arrow.write(IOBuffer(), table; file=true))
+        arrowtable = Arrow.Table(bytes)
+        df = DataFrames.DataFrame(arrowtable)
+        DataFrames.DataFrame(arrowtable; copycols=false)
+        Arrow.read(bytes, DataFrames.DataFrame)
+        take!(Arrow.write(IOBuffer(), df; file=true))
+        take!(Arrow.write(IOBuffer(), DataFrames.DataFrame(table); file=true))
+    end
+end
+
+end # module ArrowDataFramesExt
diff --git a/ext/ArrowFileIOExt.jl b/ext/ArrowFileIOExt.jl
new file mode 100644
index 00000000..0bf99732
--- /dev/null
+++ b/ext/ArrowFileIOExt.jl
@@ -0,0 +1,38 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# FileIO.jl registers `.arrow` files (magic `ARROW1`) as `format"Arrow"` and
+# hands them to this package: `load(path)` reads an `Arrow.Table` and
+# `save(path, table)` writes any Tables.jl table, with `Arrow.Table`'s and
+# `Arrow.write`'s keywords.
+module ArrowFileIOExt
+
+import Arrow
+using FileIO: File, Stream, @format_str, filename, stream
+
+Arrow.fileio_load(f::File{format"Arrow"}; kwargs...) = Arrow.Table(filename(f); kwargs...)
+Arrow.fileio_load(s::Stream{format"Arrow"}; kwargs...) = Arrow.Table(stream(s); kwargs...)
+
+function Arrow.fileio_save(f::File{format"Arrow"}, table; kwargs...)
+    Arrow.write(filename(f), table; kwargs...)
+    return nothing
+end
+function Arrow.fileio_save(s::Stream{format"Arrow"}, table; kwargs...)
+    Arrow.write(stream(s), table; kwargs...)
+    return nothing
+end
+
+end # module ArrowFileIOExt
diff --git a/ext/ArrowFilePathsBaseExt.jl b/ext/ArrowFilePathsBaseExt.jl
new file mode 100644
index 00000000..26ce7102
--- /dev/null
+++ b/ext/ArrowFilePathsBaseExt.jl
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Local paths share the string-path source and atomic destination behavior.
+module ArrowFilePathsBaseExt
+
+import Arrow
+using FilePathsBase: SystemPath
+
+Arrow.Table(path::SystemPath; kwargs...) = Arrow.Table(string(path); kwargs...)
+Arrow.Stream(path::SystemPath; kwargs...) = Arrow.Stream(string(path); kwargs...)
+Arrow._opensink(path::SystemPath) = Arrow._openpath(string(path))
+
+function Arrow.append(path::SystemPath, table; kwargs...)
+    Arrow.append(string(path), table; kwargs...)
+    return path
+end
+Arrow.append(path::SystemPath; kwargs...) = table -> Arrow.append(path, table; kwargs...)
+
+end
diff --git a/ext/ArrowSerializationExt.jl b/ext/ArrowSerializationExt.jl
new file mode 100644
index 00000000..3f8d749f
--- /dev/null
+++ b/ext/ArrowSerializationExt.jl
@@ -0,0 +1,85 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module ArrowSerializationExt
+
+import Arrow
+import Serialization
+const AC = Arrow.ArrowCore
+const S = Serialization
+
+# Write only the physical values. ForeignOwner, OwnerRegion, ReleaseCell,
+# raw addresses, and semantic certificates must never cross this boundary.
+function S.serialize(s::S.AbstractSerializer, d::AC.ArrayData)
+    S.serialize_cycle_header(s, d) && return nothing
+    S.serialize(s, d.type)
+    S.serialize(s, d.len)
+    S.serialize(s, d.offset)
+    S.serialize(s, [AC.slicebytes(b) for b in d.buffers])
+    S.serialize(s, d.children)
+    S.serialize(s, d.dictionary)
+    S.serialize(s, @atomic(:monotonic, d.nullcount))
+    return nothing
+end
+
+function S.deserialize(s::S.AbstractSerializer, ::Type{AC.ArrayData})
+    type = S.deserialize(s)
+    len = S.deserialize(s)
+    offset = S.deserialize(s)
+    buffers = S.deserialize(s)
+    children = S.deserialize(s)
+    dictionary = S.deserialize(s)
+    nullcount = S.deserialize(s)
+    d = AC.ArrayData(
+        type,
+        len,
+        [AC._databuffer(b) for b in buffers];
+        offset=offset,
+        children=children,
+        dictionary=dictionary,
+        nullcount=nullcount,
+    )
+    # ArrayData's immutable topology cannot contain a cycle. Register after
+    # its children are read to preserve repeated references to the same node.
+    S.deserialize_cycle(s, d)
+    return d
+end
+
+function S.serialize(s::S.AbstractSerializer, t::Arrow.Table)
+    S.serialize_type(s, Arrow.Table)
+    S.serialize(s, getfield(t, :names))
+    # Views serialize as the owned vectors they copy to, not as their buffers.
+    S.serialize(
+        s,
+        AbstractVector[Arrow._ownedcolumn(Arrow._force(c)) for c in getfield(t, :columns)],
+    )
+    for name in (:schema, :nrows, :retainedpools)
+        S.serialize(s, getfield(t, name))
+    end
+    return nothing
+end
+
+function S.deserialize(s::S.AbstractSerializer, ::Type{Arrow.Table})
+    names = S.deserialize(s)
+    columns = S.deserialize(s)
+    schema = S.deserialize(s)
+    nrows = S.deserialize(s)
+    pools = S.deserialize(s)
+    return Arrow._table(names, columns, schema, AC.OwnerRegion[], nrows, pools)
+end
+
+end # module ArrowSerializationExt
diff --git a/ext/ArrowTimeZonesExt.jl b/ext/ArrowTimeZonesExt.jl
new file mode 100644
index 00000000..fdac9c45
--- /dev/null
+++ b/ext/ArrowTimeZonesExt.jl
@@ -0,0 +1,91 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+"""
+TimeZones.jl conveniences for timezone-aware timestamp columns. Reading
+never needs this extension: a zone-declared timestamp column materializes as
+`Durations.ZonedTimestamp` at every unit (Durations' own TimeZones extension
+adds named-zone rules and `ZonedDateTime` conversions to those values).
+Loading TimeZones.jl adds two things here:
+
+  * Writing: a fresh `TimeZones.ZonedDateTime` column writes as a
+    timezone-declared millisecond timestamp, matching Arrow 2.x, instead of
+    falling through to reflected-struct lowering.
+  * Retained writes: a `ZonedDateTime` lowers exactly to a zone-declared
+    column's storage domain (the UTC instant in the column unit).
+"""
+module ArrowTimeZonesExt
+
+import Arrow
+import Dates
+import TimeZones
+
+const AC = Arrow.ArrowCore
+
+# Lower one ZonedDateTime to a zone-declared timestamp's storage domain
+# exactly: the UTC instant in the descriptor's unit, or `nothing` when the
+# value is not a ZonedDateTime or the unit cannot hold the instant exactly.
+# The declared zone deliberately plays no role: storage is the UTC instant
+# and zoned comparisons use only it, so semantics survive lowering.
+function zonedstorage(unit::AC.TimeUnit, value)
+    value isa TimeZones.ZonedDateTime || return nothing
+    ms = Dates.value(Dates.DateTime(value, TimeZones.UTC)) - Dates.UNIXEPOCH
+    unit == AC.MILLISECOND && return ms
+    unit == AC.SECOND && return ms % 1000 == 0 ? ms ÷ 1000 : nothing
+    scale = unit == AC.MICROSECOND ? Int64(1_000) : Int64(1_000_000)
+    wide = Int128(ms) * Int128(scale)
+    return Int128(typemin(Int64)) <= wide <= Int128(typemax(Int64)) ? Int64(wide) : nothing
+end
+
+# The fresh-write hooks `Arrow._zonedwritertype`/`Arrow._zonednativepart`
+# route to. A fresh ZonedDateTime column writes as a timezone-declared
+# millisecond timestamp, matching Arrow 2.x, instead of falling through to
+# reflected-struct lowering of the zone's whole transition table.
+iszonedtype(T::Type) = T === TimeZones.ZonedDateTime
+
+# One column carries one zone (the descriptor has one timezone slot), so
+# mixed zones refuse with a normalization hint. An empty or all-missing
+# column has no zone evidence and declares UTC.
+function zonednativepart(name::String, v::AbstractVector, T::Type)
+    T === TimeZones.ZonedDateTime || return nothing
+    zone = nothing
+    for x in v
+        x === missing && continue
+        z = TimeZones.timezone(x)
+        if zone === nothing
+            zone = z
+        elseif z != zone
+            throw(
+                ArgumentError(
+                    "column $name holds ZonedDateTime values in more than " *
+                    "one timezone ($(TimeZones.name(zone)) and " *
+                    "$(TimeZones.name(z))); convert them to one zone with " *
+                    "astimezone before writing",
+                ),
+            )
+        end
+    end
+    tzname = zone === nothing ? "UTC" : String(TimeZones.name(zone))
+    return Arrow._constructtemporalpart(
+        name,
+        v,
+        AC.TimestampType(AC.MILLISECOND, tzname),
+        x -> Int64(Dates.value(Dates.DateTime(x, TimeZones.UTC)) - Dates.UNIXEPOCH),
+    )
+end
+
+end # module ArrowTimeZonesExt
diff --git a/src/Arrow.jl b/src/Arrow.jl
index 6f3ccdf8..3f71647e 100644
--- a/src/Arrow.jl
+++ b/src/Arrow.jl
@@ -14,131 +14,162 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# Layering (docs/dev/core-README.md documents each layer in depth):
+#
+# - `ArrowCore` (private): ownership regions, layout registry, `ArrayData`,
+#   staged validation, accessors; the trim-friendly, dependency-free core.
+# - `Meta`: FlatBuffers metadata bindings and the shape verifier, both
+#   generated from the vendored spec schemas (`src/metadata/fbs/`, generator
+#   `tools/fbsgen.jl`) over the vendored `FlatBuffers` runtime.
+# - IPC adapters (`ipc_read.jl`, `ipc_write.jl`): stream and file formats,
+#   framing, resource limits, compression, dictionary lifecycles.
+# - `cdata.jl`, `cstream.jl`: the C data and C stream interfaces over Core,
+#   import and export, with lifecycle accounting; `cdata_table.jl` puts
+#   `Arrow.Table`, `Arrow.Stream`, and any Tables.jl table across them.
+# - `scan.jl`: `Tables.Scan` pushdown and byte-range reads.
+# - `table.jl`, `write.jl`: the read facade and write orchestration.
+# - `columnconstruction.jl`: column-wide construction policy, including
+#   retained schemas, dictionaries, and recursive ArrowTypes.jl lowering.
 """
-    Arrow.jl
-
-A pure Julia implementation of the [apache arrow](https://arrow.apache.org/) memory format specification.
-
-This implementation supports the 1.0 version of the specification, including support for:
-  * All primitive data types
-  * All nested data types
-  * Dictionary encodings, nested dictionary encodings, and messages
-  * Extension types
-  * Streaming, file, record batch, and replacement and isdelta dictionary messages
-  * Buffer compression/decompression via the standard LZ4 frame and Zstd formats
+    Arrow
 
-It currently doesn't include support for:
-  * Tensors or sparse tensors
-  * Flight RPC
-  * C data interface
-
-Third-party data formats:
-  * csv and parquet support via the existing [CSV.jl](https://github.com/JuliaData/CSV.jl) and [Parquet.jl](https://github.com/JuliaIO/Parquet.jl) packages
-  * Other [Tables.jl](https://github.com/JuliaData/Tables.jl)-compatible packages automatically supported ([DataFrames.jl](https://github.com/JuliaData/DataFrames.jl), [JSONTables.jl](https://github.com/JuliaData/JSONTables.jl), [JuliaDB.jl](https://github.com/JuliaData/JuliaDB.jl), [SQLite.jl](https://github.com/JuliaDatabases/SQLite.jl), [MySQL.jl](https://github.com/JuliaDatabases/MySQL.jl), [JDBC.jl](https://github.com/JuliaDatabases/JDBC.jl), [ODBC.jl](https://github.com/JuliaDatabases/ODBC.jl), [XLSX.jl](https://github.com/felipenoris/XLSX.jl), etc.)
-  * No current Julia packages support ORC or Avro data formats
-
-See docs for official Arrow.jl API with the [User Manual](@ref) and reference docs for [`Arrow.Table`](@ref), [`Arrow.write`](@ref), and [`Arrow.Stream`](@ref).
+Read and write the Apache Arrow IPC file and stream formats. [`Arrow.Table`](@ref) reads
+a path, an `IO`, a byte vector, or an [`Arrow.AbstractArrowSource`](@ref) as Tables.jl
+columns; [`Arrow.Stream`](@ref) reads one record batch at a time; [`Arrow.write`](@ref)
+and [`Arrow.Writer`](@ref) write any Tables.jl table. The names are public but not
+exported, apart from `ArrowTypes`: call them as `Arrow.Table` and so on.
 """
 module Arrow
 
-using Base.Iterators
-using Mmap
+using Tables
+import DataAPI
+import DataStrings, DataDecimals, Durations
+import PooledArrays
+using SentinelArrays: ChainedVector, ChainedVectorIndex
+import ArrowTypes
 import Dates
-using DataAPI,
-    Tables,
-    SentinelArrays,
-    PooledArrays,
-    CodecLz4,
-    CodecZstd,
-    TimeZones,
-    BitIntegers,
-    ConcurrentUtilities,
-    StringViews
-
-export ArrowTypes
-
-using Base: @propagate_inbounds
-import Base: ==
-
-const FILE_FORMAT_MAGIC_BYTES = b"ARROW1"
-const CONTINUATION_INDICATOR_BYTES = 0xffffffff
-
-# vendored flatbuffers code for now
-include("FlatBuffers/FlatBuffers.jl")
-using .FlatBuffers
-
-include("metadata/Flatbuf.jl")
-using .Flatbuf
-const Meta = Flatbuf
+import UUIDs
+import CodecLz4
+import CodecZstd
+import TranscodingStreams
+using CodecLz4: LZ4FrameCompressor
+
+const CLZ4 = CodecLz4
+const CZSTD = CodecZstd
+const ZSTD = CZSTD.LibZstd
+const TS = TranscodingStreams
+
+isdefined(Tables, :Scan) || error(
+    "Arrow 3.0's scan support needs Tables.jl's `Tables.Scan` " *
+    "interface; upgrade Tables.jl to 1.14 or later",
+)
+
+include(joinpath("FlatBuffers", "FlatBuffers.jl"))
+const FB = FlatBuffers
+
+# Generated metadata bindings + shape verifier (regenerate with
+# `julia tools/fbsgen.jl src/metadata/fbs src/metadata`).
+module Meta
+using EnumX
+using ..FlatBuffers
+include(joinpath("metadata", "Schema.jl"))
+include(joinpath("metadata", "File.jl"))
+include(joinpath("metadata", "Message.jl"))
+include(joinpath("metadata", "VerifierRuntime.jl"))
+include(joinpath("metadata", "Verifier.jl"))
+end
 
-using ArrowTypes
-include("utils.jl")
-include("arraytypes/arraytypes.jl")
-include("eltypes.jl")
+include("ArrowCore.jl")
+using .ArrowCore
+import .ArrowCore: release!
+const AC = ArrowCore
+
+include("ipc_read.jl")
+include("ipc_dictionary.jl")
+include("ipc_write.jl")
+include("cdata.jl")
+include("cstream.jl")
+include("source.jl")
+include("arrowtypes.jl")
+include("columns.jl")
+
+# The public facade. `table.jl` includes the private scan-plan module after
+# its public/storage type seam is defined; `write.jl` includes the private
+# column-construction module after the `DictEncode` marker is defined.
 include("table.jl")
 include("write.jl")
-include("append.jl")
-include("show.jl")
-
-const ZSTD_COMPRESSOR = Lockable{ZstdCompressor}[]
-const ZSTD_DECOMPRESSOR = Lockable{ZstdDecompressor}[]
-const LZ4_FRAME_COMPRESSOR = Lockable{LZ4FrameCompressor}[]
-const LZ4_FRAME_DECOMPRESSOR = Lockable{LZ4FrameDecompressor}[]
-
-function init_zstd_compressor()
-    zstd = ZstdCompressor(; level=3)
-    CodecZstd.TranscodingStreams.initialize(zstd)
-    return Lockable(zstd)
-end
+include("cdata_table.jl")
+include("sharedvalues.jl")
 
-function init_zstd_decompressor()
-    zstd = ZstdDecompressor()
-    CodecZstd.TranscodingStreams.initialize(zstd)
-    return Lockable(zstd)
-end
+"""
+    Arrow.ValidationError
 
-function init_lz4_frame_compressor()
-    lz4 = LZ4FrameCompressor(; compressionlevel=4)
-    CodecLz4.TranscodingStreams.initialize(lz4)
-    return Lockable(lz4)
+Thrown when input is not valid Arrow data, or uses something this package does not
+read: corrupt, truncated, or inconsistent metadata or buffers, bytes that are not Arrow
+at all, or big-endian data. The message names the problem.
+"""
+AC.ValidationError
+
+# Julia 1.11 added `public`. Keep the source parseable on the supported
+# Julia 1.10 floor while giving tooling an exact, non-exporting API boundary
+# on newer Julia versions.
+@static if VERSION >= v"1.11"
+    Core.eval(
+        @__MODULE__,
+        Expr(
+            :public,
+            :Table,
+            :Stream,
+            :read,
+            :release!,
+            :col,
+            :colcmp,
+            :colin,
+            :isnull,
+            :ArrowVector,
+            :Primitive,
+            :BoolVector,
+            :ListVector,
+            :ListValue,
+            :MapVector,
+            :MapValue,
+            :StructVector,
+            :DictEncoded,
+            :RunEndEncoded,
+            :write,
+            :Writer,
+            :append,
+            :tobuffer,
+            :getmetadata,
+            :DictEncode,
+            :AbstractArrowSource,
+            :sourcelength,
+            :readrange,
+            :concurrentreads,
+            :CArrowSchema,
+            :CArrowArray,
+            :CArrowArrayStream,
+            :to_c_data,
+            :from_c_data,
+            :export_stream!,
+            :Limits,
+            :AllocationLimitError,
+            :ValidationError,
+        ),
+    )
 end
 
-function init_lz4_frame_decompressor()
-    lz4 = LZ4FrameDecompressor()
-    CodecLz4.TranscodingStreams.initialize(lz4)
-    return Lockable(lz4)
-end
+# The one name Arrow 2.x exported. Packages that define custom-type mappings
+# reach the interface as `Arrow.ArrowTypes` or through `using Arrow`.
+export ArrowTypes
 
-function access_threaded(f, v::Vector)
-    tid = Threads.threadid()
-    0 < tid <= length(v) || _length_assert()
-    if @inbounds isassigned(v, tid)
-        @inbounds x = v[tid]
-    else
-        x = f()
-        @inbounds v[tid] = x
-    end
-    return x
-end
-@noinline _length_assert() = @assert false "0 < tid <= v"
-
-zstd_compressor() = access_threaded(init_zstd_compressor, ZSTD_COMPRESSOR)
-zstd_decompressor() = access_threaded(init_zstd_decompressor, ZSTD_DECOMPRESSOR)
-lz4_frame_compressor() = access_threaded(init_lz4_frame_compressor, LZ4_FRAME_COMPRESSOR)
-lz4_frame_decompressor() =
-    access_threaded(init_lz4_frame_decompressor, LZ4_FRAME_DECOMPRESSOR)
-
-function __init__()
-    nt = @static if isdefined(Base.Threads, :maxthreadid)
-        Threads.maxthreadid()
-    else
-        Threads.nthreads()
-    end
-    resize!(empty!(LZ4_FRAME_COMPRESSOR), nt)
-    resize!(empty!(ZSTD_COMPRESSOR), nt)
-    resize!(empty!(LZ4_FRAME_DECOMPRESSOR), nt)
-    resize!(empty!(ZSTD_DECOMPRESSOR), nt)
-    return
-end
+# FileIO.jl's `load("x.arrow")` and `save("x.arrow", table)` call these; the
+# FileIO extension defines their methods.
+function fileio_load end
+function fileio_save end
+
+# Precompile the common write/read/scan shapes last, once every layer above
+# is defined.
+include("precompile.jl")
 
-end  # module Arrow
+end # module Arrow
diff --git a/src/ArrowCore.jl b/src/ArrowCore.jl
new file mode 100644
index 00000000..5ff8c16c
--- /dev/null
+++ b/src/ArrowCore.jl
@@ -0,0 +1,4012 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+    ArrowCore
+
+The runtime-tagged, C-data-shaped core of Arrow.jl. It depends only on Base
+and the Mmap standard library; the IPC, C-data, scan, and facade layers in
+`src/` sit on top of it.
+
+Design rules:
+
+1. One physical data model. `ArrayData` = layout + buffers + children +
+   dictionary, mirroring the Arrow C data interface's `ArrowArray`. Logical
+   type parameters such as timezone and precision/scale are fields on
+   `ArrowType` descriptors. Names and nullability are fields on `Field`.
+   None parameterize the Core storage types. Struct materialization returns
+   `Vector{Pair{String,Any}}` on the dynamic path; static element types are
+   the caller's claim through `getvalue(::Type{T}, ...)`/`materialize(::Type{T}, ...)`.
+
+2. Memory validity is GC reachability, plus one revocation bit. Every
+   buffer is a `BufferSlice` into an `OwnerRegion` — a (pointer, length,
+   alignment, root, cell) record whose `root` anchors the backing storage
+   and whose `ReleaseCell` supports `release!`: regions sharing one
+   underlying lifetime share one cell, so a release revokes every sibling and
+   runs the release action (mmap unmap, foreign release callback) exactly
+   once, and later access is a clean error. Slices are bounds-checked
+   against the region at construction; loads are a final bounds check, one
+   monotonic closed-flag load, and the raw read. Foreign extents are
+   trusted declarations, and mapped files are exposed to external changes.
+
+3. One structural layout registry. `layoutspec(type)` returns the buffer
+   roles / child arity / offset width for each of the format-1.5 layouts.
+   Generic code (buffer walking, structural validation, the IPC adapter's
+   node/buffer accounting in src/ipc_read.jl) is driven by the registry;
+   per-layout SEMANTICS (element access, semantic validation) are ordinary
+   methods grouped per layout below. Adding a layout means one registry
+   entry plus bounded method groups in the layers that support it.
+
+4. Validation is staged: structural checks are O(buffers) and run at
+   construction/adaptation time. Data-intrinsic semantic checks are O(n)
+   when an adapter or caller requests them; a successful result is cached.
+   Benign concurrent callers may repeat the same scan. Field-dependent
+   dictionary contracts run on every validation call. Advisory contracts —
+   Field.nullable enforcement, Date64 day divisibility, time-of-day range,
+   decimal precision, and body UTF-8 — are opt-in via `validate_full`: the
+   ecosystem's gold files violate them and the reference implementation
+   reads those files. Framing-stage checks (checked spans, metadata
+   verification, resource limits before metadata-directed allocation)
+   belong to the adapters.
+
+The registry, staged validation, element access, and materialization cover
+every format-1.5 layout, including binary views, list views, and run-end
+encoding. `validate_full` additionally enforces canonical bit-packed form
+(zeroed trailing bits and padding); on-wire buffer padding is a writer
+guarantee, not a reader requirement — the spec permits unpadded buffers and
+this reader accepts them. Core has no codec dependency; the IPC adapter
+implements compression. Bulk access is `materialize` (dynamic, one function
+barrier per layout) and `materialize(::Type{T}, …)` (a static element claim,
+resolved without boxing except at the dictionary/run-end wrapper edge).
+"""
+module ArrowCore
+
+using Base: Checked
+import Mmap
+const checked_add = Checked.checked_add
+const checked_sub = Checked.checked_sub
+const checked_mul = Checked.checked_mul
+
+export OwnerRegion,
+    BufferSlice,
+    heapregion,
+    mmapregion,
+    release!,
+    ReleaseCell,
+    ReleaseCounter,
+    increment!,
+    ArrowType,
+    NullType,
+    BoolType,
+    IntType,
+    FloatType,
+    DecimalType,
+    FixedSizeBinaryType,
+    BinaryType,
+    Utf8Type,
+    DateType,
+    TimeType,
+    TimestampType,
+    DurationType,
+    IntervalType,
+    ListType,
+    FixedSizeListType,
+    StructType,
+    MapType,
+    UnionType,
+    DictionaryType,
+    ViewType,
+    ListViewType,
+    RunEndEncodedType,
+    Field,
+    Schema,
+    ArrayData,
+    RecordBatch,
+    RecordBatchSource,
+    nextbatch!,
+    LayoutSpec,
+    layoutspec,
+    BufferRole,
+    validate_structural,
+    validate_semantic,
+    validate_full,
+    ValidationError,
+    nullcount,
+    getvalue,
+    materialize,
+    fromjulia,
+    fromviewentries,
+    batch
+
+# ---------------------------------------------------------------------------
+# §1 Memory: regions as GC anchors (constrained model)
+# ---------------------------------------------------------------------------
+#
+# Buffer validity is GC REACHABILITY — Julia's native memory-safety
+# contract — plus one explicit revocation layer. A region's `root` is
+# whatever keeps the memory alive (the wrapped Julia array, the Mmap-stdlib
+# array, a C-data adapter's owner object); views hold their region, the
+# region holds its root, so memory a view can reach is memory that is
+# valid. `release!` is the deterministic release path on top: one
+# `ReleaseCell` per underlying lifetime revokes every region over it and
+# runs the eager release action exactly once (unmap now; run the foreign
+# release now), turning use-after-release into `InvalidStateException`
+# instead of undefined behavior. What stays out of scope, so the contract
+# is informed:
+#   * Data-race shielding for loads concurrent WITH release!: quiescing
+#     readers first is the caller's contract, as with `Base.close` on a
+#     shared IO. Loads take no locks.
+#   * External-truncation protection: a shared mapping's pages can vanish
+#     under any implementation. Same exposure as every mmap-based reader.
+
+"An atomic counter for the test suite's exactly-once release bookkeeping."
+mutable struct ReleaseCounter
+    @atomic n::Int
+end
+ReleaseCounter() = ReleaseCounter(0)
+Base.getindex(c::ReleaseCounter) = @atomic c.n
+# CAS loop rather than `@atomic c.n += 1`: the atomic read-modify-write
+# builtin is not implemented in JuliaC's trim verifier, while
+# compare-and-swap is; contention here is negligible.
+function increment!(c::ReleaseCounter)
+    while true
+        old = @atomic c.n
+        _, ok = @atomicreplace c.n old => old + 1
+        ok && return old + 1
+    end
+end
+
+"""
+    ReleaseCell(action::Ptr{Cvoid}, arg)
+    ReleaseCell()
+
+The revocation state one release action guards. Every `OwnerRegion` carries
+a cell; regions that share one underlying lifetime (all buffers imported
+from one C-data tree) share ONE cell, so closing any of them revokes every
+sibling before the single release action runs. The action is a
+`@cfunction(f, Cvoid, (Ptr{Cvoid},))` trampoline receiving
+`pointer_from_objref(arg)` — pure C ABI, the same idiom the C-data
+adapter's release callbacks use and the form the trim verifier accepts
+(an `Any`-argument cfunction is not) — or `C_NULL` when the backing
+storage is a borrow with no eager action (a heap vector — running a
+borrowed object's finalizers is not ours to do). `arg` must be a mutable
+heap object; the cell's reference keeps it alive across the call. Build
+trampolines at runtime, never in a module-level const (a serialized
+cfunction pointer is garbage after precompile reload).
+"""
+mutable struct ReleaseCell
+    @atomic closed::Bool
+    const action::Ptr{Cvoid}
+    const arg::Any
+end
+ReleaseCell(action::Ptr{Cvoid}, arg) = ReleaseCell(false, action, arg)
+ReleaseCell() = ReleaseCell(false, Ptr{Cvoid}(C_NULL), nothing)
+
+# Revoke every region sharing the cell (later raw access throws
+# `InvalidStateException`) and run the cell's release action exactly once.
+# Idempotent. Not a data-race shield for accesses concurrent with the release:
+# quiescing readers first is the caller's contract, as with `Base.close` on a
+# shared IO. (Comments, not docstrings: `?Arrow.release!` lists only the
+# public methods.)
+function release!(cell::ReleaseCell)
+    (@atomicswap :acquire_release cell.closed = true) && return nothing
+    if cell.action != C_NULL
+        arg = cell.arg
+        GC.@preserve arg ccall(cell.action, Cvoid, (Ptr{Cvoid},), pointer_from_objref(arg))
+    end
+    return nothing
+end
+
+"""
+    OwnerRegion
+
+One contiguous memory region, the object that keeps it alive, and the
+[`ReleaseCell`](@ref) that can revoke it. The region is valid while it is
+reachable — `root` anchors the backing storage (a borrowed Julia array, the
+Mmap-stdlib array, or an adapter's owner object) — or until `release!` runs
+its cell's release action, after which every raw access through `sliceptr`
+throws. Slices reject geometry outside the declared `len` at construction;
+loads retain a final bounds check before the raw read.
+
+The scoped-borrow contract for wrapped Julia arrays: the caller must not
+mutate or resize the array while the region or any cached validation result
+remains in use. Mutation can invalidate a semantic certificate; resizing can
+reallocate the storage and invalidate its pointer.
+"""
+struct OwnerRegion
+    ptr::Ptr{UInt8}
+    len::Int64
+    alignment::Base.Int   # guaranteed ptr alignment, capped at 64; loads consult it
+    root::Any             # GC anchor; never dispatched on, only stored
+    cell::ReleaseCell
+
+    function OwnerRegion(
+        ptr::Ptr{UInt8},
+        len::Integer;
+        root=nothing,
+        cell::ReleaseCell=ReleaseCell(),
+    )
+        len >= 0 || throw(ArgumentError("region length must be non-negative"))
+        n = Int64(len)
+        (ptr != C_NULL || n == 0) ||
+            throw(ArgumentError("a non-empty region requires a non-NULL pointer"))
+        (root !== nothing || n == 0) ||
+            throw(ArgumentError("a non-empty region requires a GC root"))
+        # BufferSlice bounds are only meaningful if every declared byte also
+        # has a representable pointer address. Reject a foreign extent whose
+        # final byte would wrap native pointer arithmetic.
+        if n > 0
+            lastaddr = UInt128(UInt(ptr)) + UInt128(n - 1)
+            lastaddr <= UInt128(typemax(UInt)) ||
+                throw(ArgumentError("region extent wraps the native address space"))
+        end
+        # OR-ing in 64 caps the detected alignment at 64 bytes without a
+        # branch; a NULL (necessarily empty) region reports the cap, since
+        # nothing loads from it.
+        align = ptr == C_NULL ? 64 : (1 << trailing_zeros(UInt(ptr) | UInt(64)))
+        return new(ptr, n, align, root, cell)
+    end
+end
+
+# Release the region's backing storage through its `ReleaseCell`: every region
+# sharing the cell is revoked (later raw access throws `InvalidStateException`)
+# and the cell's release action runs exactly once. An mmap region unmaps now
+# (for hosts where a GC-timed unmap is not enough, such as deleting a mapped
+# file on Windows); an imported C-data tree runs the producer's release
+# callback; a borrowed heap region is revoked with no eager action. Idempotent.
+function release!(r::OwnerRegion)
+    return release!(r.cell)
+end
+
+# A deep copy shares the region and its cell: the bytes belong to the root and
+# are freed through the cell once, so a copy with its own cell would read them
+# after they are released and release them again.
+Base.deepcopy_internal(r::OwnerRegion, ::IdDict) = r
+Base.deepcopy_internal(c::ReleaseCell, ::IdDict) = c
+
+"""
+    heapregion(v::Vector{T}) -> OwnerRegion
+
+Borrow a Julia array as a region (zero-copy). The array's storage is the `root`,
+so the bytes stay valid while the region is reachable even if `v` is resized
+afterwards. On Julia 1.10 the array itself is the root, and resizing it
+reallocates the bytes the region points at.
+"""
+function heapregion(v::Vector{T}) where {T}
+    isbitstype(T) || throw(ArgumentError("heapregion requires an isbits element type"))
+    return OwnerRegion(Ptr{UInt8}(pointer(v)), sizeof(v); root=_storageroot(v))
+end
+
+# `_storageroot(v)`: the object that owns a vector's bytes, and the one Mmap
+# registers its unmap finalizer on — the array's backing `Memory` from Julia
+# 1.11 (`finalize(arr)` is then a no-op), the array itself before. A release
+# cell targets that object so `release!` truly unmaps now.
+@static if VERSION >= v"1.11"
+    _storageroot(v::Vector) = v.ref.mem
+    function _release_mmap(p::Ptr{Cvoid})::Cvoid
+        finalize(unsafe_pointer_to_objref(p)::Memory{UInt8})
+        return nothing
+    end
+else
+    _storageroot(v::Vector) = v
+    function _release_mmap(p::Ptr{Cvoid})::Cvoid
+        finalize(unsafe_pointer_to_objref(p)::Vector{UInt8})
+        return nothing
+    end
+end
+
+# Map from a caller-owned open `io` (the caller closes it; the mapping
+# outlives the descriptor); `label` names the mapping in errors. With
+# `eager=false`, `release!` only revokes the region and the mapping is unmapped
+# when its root is garbage collected: the form for memory that unowned views
+# still read after a release.
+function _mmapregion(io::IO, label; eager::Bool=true)
+    arr = Mmap.mmap(io, Vector{UInt8})
+    isempty(arr) && throw(ArgumentError("cannot map empty file: $label"))
+    cell =
+        eager ?
+        ReleaseCell(@cfunction(_release_mmap, Cvoid, (Ptr{Cvoid},)), _storageroot(arr)) :
+        ReleaseCell()
+    return OwnerRegion(Ptr{UInt8}(pointer(arr)), length(arr); root=arr, cell=cell)
+end
+
+"Unmap a mapped region's memory now. Nothing may read the region afterward."
+_unmap!(r::OwnerRegion) = finalize(_storageroot(r.root::Vector{UInt8}))
+
+"""
+    mmapregion(path) -> OwnerRegion
+
+Map a file read-only via the Mmap STDLIB (cross-platform) and wrap the
+mapped array as the region's `root`. The stdlib's own machinery unmaps when
+the array is collected — validity is reachability, like every other region.
+
+The caller must prevent external writes or truncation of the mapped file
+while the region or any cached validation result remains in use: a shared
+mapping cannot keep a semantic certificate valid when another process
+changes its bytes, and truncation can make an in-range load fault.
+"""
+function mmapregion(path::AbstractString)
+    io = open(path, "r")
+    try
+        # The mapping outlives the descriptor.
+        return _mmapregion(io, path)
+    finally
+        close(io)
+    end
+end
+
+# --- BufferSlice ------------------------------------------------------------
+
+"""
+    BufferSlice
+
+A bounds-checked window into an `OwnerRegion` — the only currency for Arrow
+buffer data in this module. Constructing a slice validates
+`offset + len <= region.len` with checked arithmetic, so downstream code can
+assume every slice is in-bounds and concentrate on layout logic.
+
+An all-default `BufferSlice()` is the canonical empty buffer (used for
+absent validity bitmaps, empty data buffers).
+"""
+struct BufferSlice
+    region::Union{Nothing,OwnerRegion}
+    offset::Int64
+    len::Int64
+    function BufferSlice(region::OwnerRegion, offset::Integer, len::Integer)
+        offset >= 0 || throw(ArgumentError("negative buffer offset"))
+        len >= 0 || throw(ArgumentError("negative buffer length"))
+        checked_add(Int64(offset), Int64(len)) <= region.len || throw(
+            ArgumentError(
+                "buffer [offset=$offset len=$len] exceeds region of $(region.len) bytes",
+            ),
+        )
+        return new(region, Int64(offset), Int64(len))
+    end
+    BufferSlice() = new(nothing, 0, 0)
+end
+
+Base.length(b::BufferSlice) = b.len
+isempty_buffer(b::BufferSlice) = b.len == 0
+@inline function sliceptr(b::BufferSlice)
+    b.region === nothing && return Ptr{UInt8}(0)
+    r = b.region::OwnerRegion
+    (@atomic :monotonic r.cell.closed) &&
+        throw(InvalidStateException("the backing region was released", :closed))
+    return r.ptr + b.offset
+end
+
+"Sub-slice with checked arithmetic (relative bounds against the parent slice)."
+function subslice(b::BufferSlice, offset::Integer, len::Integer)
+    offset >= 0 || throw(ArgumentError("negative subslice offset"))
+    len >= 0 || throw(ArgumentError("negative subslice length"))
+    b.region === nothing && (len == 0 && offset == 0) && return b
+    b.region === nothing && throw(ArgumentError("cannot subslice the empty buffer"))
+    checked_add(Int64(offset), Int64(len)) <= b.len || throw(
+        ArgumentError("subslice [offset=$offset len=$len] exceeds slice of $(b.len) bytes"),
+    )
+    return BufferSlice(b.region, checked_add(b.offset, Int64(offset)), Int64(len))
+end
+
+"""
+Load a `T` at byte offset `byteoff` (0-based) within the slice. Handles the
+misaligned case with a byte-wise load: alignment is a property of the region
+(Arrow controls only its own allocations; mmap and foreign pointers can be
+anything), so the branch lives here, in one place, instead of as a copy
+workaround scattered through per-type code.
+"""
+@inline function loadat(b::BufferSlice, ::Type{T}, byteoff::Int64) where {T}
+    # Raw Arrow bytes may only materialize pointer-free values. Loading a
+    # struct with managed references would treat attacker-controlled bytes as
+    # GC pointers and can crash Julia before it can report an ordinary error.
+    isbitstype(T) || throw(ArgumentError("loadat requires an isbits type, got $T"))
+    # Bounds: byteoff + sizeof(T) <= len. byteoff is computed by callers from
+    # validated element indices, but re-check cheaply: this is the last line
+    # of defense before a raw pointer dereference.
+    width = Int64(sizeof(T))
+    # Express this as subtraction, not `byteoff + width <= len`: a hostile
+    # byte offset near typemax(Int64) must not wrap through the last bounds
+    # check and reach pointer arithmetic.
+    (byteoff >= 0 && width <= b.len && byteoff <= b.len - width) ||
+        throw(BoundsError(b, byteoff))
+    b.region === nothing && throw(ArgumentError("empty buffer has no data"))
+    # Raw pointers do not keep Julia owners alive. Preserve the slice through
+    # the full dereference so its region and opaque root remain reachable.
+    GC.@preserve b begin
+        p = sliceptr(b) + byteoff
+        required = datatype_alignment(T)
+        relative = checked_add(b.offset, byteoff)
+        region = b.region::OwnerRegion
+        if region.alignment >= required && relative % required == 0
+            return unsafe_load(Ptr{T}(p))
+        else
+            return _load_unaligned(T, p)
+        end
+    end
+end
+
+datatype_alignment(::Type{T}) where {T} = Base.datatype_alignment(T)
+
+@inline function _load_unaligned(::Type{T}, p::Ptr{UInt8}) where {T}
+    bytes = ntuple(i -> unsafe_load(p + (i - 1)), Val(sizeof(T)))
+    return reinterpret_bytes(T, bytes)
+end
+@inline reinterpret_bytes(::Type{T}, bytes::NTuple{N,UInt8}) where {T,N} =
+    reinterpret(T, bytes)
+
+"Copy the slice into a fresh `Vector{UInt8}`."
+function slicebytes(b::BufferSlice)
+    b.len == 0 && return UInt8[]
+    b.region === nothing && throw(ArgumentError("empty buffer has no data"))
+    out = Vector{UInt8}(undef, b.len)
+    # Preserve both owners across the raw copy. Neither pointer roots its
+    # source or destination allocation.
+    GC.@preserve b out begin
+        unsafe_copyto!(pointer(out), sliceptr(b), b.len)
+    end
+    return out
+end
+
+"Read one bit (0-based bit index) from a validity/values bitmap slice."
+@inline function getbit(b::BufferSlice, i::Int64)
+    byte = loadat(b, UInt8, i >> 3)
+    return (byte >> (i & 7)) & 0x01 == 0x01
+end
+
+# ---------------------------------------------------------------------------
+# §2 Type system: runtime descriptors, Field, Schema
+# ---------------------------------------------------------------------------
+
+"""
+    ArrowType
+
+Abstract supertype of the runtime logical-type descriptors. These are small
+immutable structs whose *fields* carry the logical type parameters
+(timestamp unit and timezone, decimal precision/scale/width, ...). Two
+timestamp columns with different timezones have the SAME Julia type —
+schema diversity costs data, not method instances.
+"""
+abstract type ArrowType end
+
+"""
+Read-only, defensively-copied vector storage for the frozen data model.
+Its type does not encode the length, so schema width and nesting depth do
+not create a new family of container types. The backing field is internal;
+normal mutation APIs such as `setindex!` and `push!` are unavailable.
+"""
+struct FrozenVector{T} <: AbstractVector{T}
+    _data::Vector{T}
+    FrozenVector{T}(data::Vector{T}, ::Nothing) where {T} = new{T}(data)
+end
+FrozenVector{T}(xs::FrozenVector{T}) where {T} = xs
+FrozenVector{T}(xs) where {T} = FrozenVector{T}(collect(T, xs), nothing)
+Base.size(v::FrozenVector) = size(getfield(v, :_data))
+Base.length(v::FrozenVector) = length(getfield(v, :_data))
+Base.getindex(v::FrozenVector, i::Int) = getfield(v, :_data)[i]
+Base.IndexStyle(::Type{<:FrozenVector}) = IndexLinear()
+
+@enum TimeUnit::UInt8 SECOND MILLISECOND MICROSECOND NANOSECOND
+@enum DateUnit::UInt8 DAY MILLISECOND_DATE
+@enum IntervalUnit::UInt8 YEAR_MONTH DAY_TIME MONTH_DAY_NANO
+@enum UnionMode::UInt8 SparseMode DenseMode
+@enum Endianness::UInt8 LittleEndian BigEndian
+_native_endianness() = Base.ENDIAN_BOM == 0x04030201 ? LittleEndian : BigEndian
+
+"Null: every slot null; no buffers."
+struct NullType <: ArrowType end
+"Boolean: bit-packed values."
+struct BoolType <: ArrowType end
+"Integer of `bits` width, `signed` or not."
+struct IntType <: ArrowType
+    bits::Int      # 8/16/32/64 per the spec; 128 is Polars' Int128/UInt128 extension
+    signed::Bool
+end
+"IEEE floating point of `bits` width (16/32/64)."
+struct FloatType <: ArrowType
+    bits::Int      # 16/32/64
+end
+"Decimal of `precision` digits and `scale`, stored in `bits` (32/64/128/256)."
+struct DecimalType <: ArrowType
+    precision::Int
+    scale::Int
+    bits::Int      # 32/64/128/256 (format 1.5)
+end
+"Fixed-width binary of `nbytes` per slot."
+struct FixedSizeBinaryType <: ArrowType
+    nbytes::Int
+end
+"Variable-length binary; `large` selects Int64 offsets."
+struct BinaryType <: ArrowType
+    large::Bool    # Int64 offsets when true
+end
+"UTF-8 string; `large` selects Int64 offsets."
+struct Utf8Type <: ArrowType
+    large::Bool
+end
+"Date in days (Int32) or milliseconds (Int64) since the epoch."
+struct DateType <: ArrowType
+    unit::DateUnit # DAY => Int32 storage, MILLISECOND => Int64
+end
+"Time of day in `unit`, stored in `bits` (32 for s/ms, 64 for us/ns)."
+struct TimeType <: ArrowType
+    unit::TimeUnit
+    bits::Int      # 32 (s/ms) or 64 (us/ns)
+end
+"Timestamp in `unit` since the epoch, with an optional `timezone`."
+struct TimestampType <: ArrowType
+    unit::TimeUnit
+    timezone::Union{Nothing,String}   # a VALUE — one method instance total
+end
+"Elapsed time in `unit`, Int64 storage."
+struct DurationType <: ArrowType
+    unit::TimeUnit
+end
+"Calendar interval in `unit` (year-month, day-time, or month-day-nano)."
+struct IntervalType <: ArrowType
+    unit::IntervalUnit                # includes MONTH_DAY_NANO (format 1.2)
+end
+"Variable-length list; `large` selects Int64 offsets."
+struct ListType <: ArrowType
+    large::Bool
+end
+"List of exactly `listsize` child slots per parent slot."
+struct FixedSizeListType <: ArrowType
+    listsize::Int
+end
+"Struct: named children declared by `Field.children`."
+struct StructType <: ArrowType end
+"Map: a list of key/value struct entries; `keyssorted` per entry."
+struct MapType <: ArrowType
+    keyssorted::Bool
+end
+"Union in sparse or dense `mode` over the children's declared `typeids`."
+struct UnionType <: ArrowType
+    mode::UnionMode
+    typeids::FrozenVector{Int8}       # declared type-id domain, child order
+end
+UnionType(mode::UnionMode, typeids) = UnionType(mode, FrozenVector{Int8}(typeids))
+"Dictionary-encoded: `indextype` is the physical index; values live in `ArrayData.dictionary`."
+struct DictionaryType <: ArrowType
+    indextype::IntType
+    valuetype::ArrowType
+    ordered::Bool
+end
+"Utf8View / BinaryView (format 1.4): 16-byte entries plus variadic data buffers."
+struct ViewType <: ArrowType
+    utf8::Bool
+end
+"ListView / LargeListView (format 1.4): per-slot child offsets and sizes."
+struct ListViewType <: ArrowType
+    large::Bool
+end
+"Run-end encoded (format 1.3): signed run ends and values of any Arrow type."
+struct RunEndEncodedType <: ArrowType end
+
+"""
+    Field
+
+One column/child descriptor: name, logical type, nullability, metadata, and
+child fields. Dictionary columns are `DictionaryType` here; the IPC-level
+dictionary *id* is NOT a Field concern — it is IPC bookkeeping and lives in
+the adapter (Core dictionaries are object references; the id↔dictionary
+table is the adapter's).
+"""
+struct Field
+    name::String
+    type::ArrowType
+    nullable::Bool
+    metadata::Union{Nothing,FrozenVector{Pair{String,String}}}
+    children::FrozenVector{Field}
+end
+_freezemetadata(::Nothing) = nothing
+_freezemetadata(metadata::FrozenVector{Pair{String,String}}) = metadata
+function _freezemetadata(metadata::Union{AbstractVector,Tuple})
+    all(kv -> kv isa Pair, metadata) ||
+        throw(ArgumentError("metadata sequences must contain Pair values"))
+    return FrozenVector{Pair{String,String}}(
+        String(first(kv)) => String(last(kv)) for kv in metadata
+    )
+end
+_freezemetadata(metadata) =
+    FrozenVector{Pair{String,String}}(String(k) => String(v) for (k, v) in pairs(metadata))
+Field(name, type; nullable=true, metadata=nothing, children=()) = Field(
+    String(name),
+    type,
+    Bool(nullable),
+    _freezemetadata(metadata),
+    FrozenVector{Field}(children),
+)
+# Narrower than the struct's implicit (Any...) convert constructor so this
+# ADDS a positional-with-conversion method instead of overwriting it (which
+# precompilation forbids); exact-typed calls still take the implicit one.
+Field(name::AbstractString, type::ArrowType, nullable, metadata, children) =
+    Field(name, type; nullable=nullable, metadata=metadata, children=children)
+
+"""
+    Schema
+
+An ordered set of top-level `Field`s plus optional schema-level metadata:
+the shape of every record batch that carries it.
+"""
+struct Schema
+    fields::FrozenVector{Field}
+    metadata::Union{Nothing,FrozenVector{Pair{String,String}}}
+    endianness::Endianness
+end
+Schema(fields; metadata=nothing, endianness=_native_endianness()) =
+    Schema(FrozenVector{Field}(fields), _freezemetadata(metadata), endianness)
+
+# ---------------------------------------------------------------------------
+# §3 Layout registry (structural facts only)
+# ---------------------------------------------------------------------------
+
+# OFFSETS are RANGE offsets (len+1 entries bounding variable-size slots);
+# ELEMENT_OFFSETS are per-element child positions (len entries — dense union).
+# The distinction is structural, so it lives in the registry, not in
+# per-layout special cases inside the validator.
+"The role of one buffer in a layout's buffer sequence (see `LayoutSpec`)."
+@enum BufferRole::UInt8 VALIDITY DATA OFFSETS ELEMENT_OFFSETS SIZES VIEWS TYPE_IDS
+
+"""
+    LayoutSpec
+
+The STRUCTURAL facts for one physical layout: which buffers it has (in
+order), how many children, its offset width, whether the trailing data
+buffers are variadic (view layouts). This is everything generic code needs
+to walk a layout — and nothing more. Semantics (what the bytes mean, how to
+access element `i`) are per-layout methods, not registry rows.
+
+`childcount == -1` means "declared by Field.children" (struct/union);
+`fixedwidth` is bytes-per-element for fixed-stride DATA buffers, 0 when the
+data buffer is byte-addressed (varbinary) or absent, and -1 for bit-packed.
+"""
+struct LayoutSpec
+    buffers::FrozenVector{BufferRole}
+    childcount::Int
+    offsetwidth::Int    # 0, 4, or 8 — width of the OFFSETS buffer entries
+    fixedwidth::Int
+    variadic::Bool
+end
+# Narrower than the implicit convert constructor (see Field above).
+LayoutSpec(buffers::AbstractVector, childcount, offsetwidth, fixedwidth, variadic) =
+    LayoutSpec(
+        FrozenVector{BufferRole}(buffers),
+        childcount,
+        offsetwidth,
+        fixedwidth,
+        variadic,
+    )
+
+primwidth(t::IntType) = t.bits ÷ 8
+primwidth(t::FloatType) = t.bits ÷ 8
+primwidth(t::DecimalType) = t.bits ÷ 8
+primwidth(t::DateType) = t.unit == DAY ? 4 : 8
+primwidth(t::TimeType) = t.bits ÷ 8
+primwidth(::TimestampType) = 8
+primwidth(::DurationType) = 8
+primwidth(t::IntervalType) = t.unit == YEAR_MONTH ? 4 : t.unit == DAY_TIME ? 8 : 16
+primwidth(t::FixedSizeBinaryType) = t.nbytes
+
+# The buffer-role sequences are shared constants: `layoutspec` runs on
+# every buffer-by-role lookup, so a per-call vector would allocate in the
+# element accessors' inner loops.
+const NO_BUFFERS = FrozenVector{BufferRole}(())
+const VALIDITY_ONLY = FrozenVector{BufferRole}((VALIDITY,))
+const VALIDITY_DATA = FrozenVector{BufferRole}((VALIDITY, DATA))
+const VALIDITY_OFFSETS = FrozenVector{BufferRole}((VALIDITY, OFFSETS))
+const VALIDITY_OFFSETS_DATA = FrozenVector{BufferRole}((VALIDITY, OFFSETS, DATA))
+const VALIDITY_VIEWS = FrozenVector{BufferRole}((VALIDITY, VIEWS))
+const VALIDITY_ELEMENT_OFFSETS_SIZES =
+    FrozenVector{BufferRole}((VALIDITY, ELEMENT_OFFSETS, SIZES))
+const TYPE_IDS_ONLY = FrozenVector{BufferRole}((TYPE_IDS,))
+const TYPE_IDS_ELEMENT_OFFSETS = FrozenVector{BufferRole}((TYPE_IDS, ELEMENT_OFFSETS))
+
+"""
+    layoutspec(t::ArrowType) -> LayoutSpec
+
+The structural facts of `t`'s physical layout: one method per descriptor
+type (the registry's extension point); generic code reaches it through the
+closed-set ladder `layoutspec_of`.
+"""
+layoutspec(::NullType) = LayoutSpec(NO_BUFFERS, 0, 0, 0, false)
+layoutspec(::BoolType) = LayoutSpec(VALIDITY_DATA, 0, 0, -1, false)
+layoutspec(t::IntType) = LayoutSpec(VALIDITY_DATA, 0, 0, primwidth(t), false)
+layoutspec(t::FloatType) = LayoutSpec(VALIDITY_DATA, 0, 0, primwidth(t), false)
+layoutspec(t::DecimalType) = LayoutSpec(VALIDITY_DATA, 0, 0, primwidth(t), false)
+layoutspec(t::DateType) = LayoutSpec(VALIDITY_DATA, 0, 0, primwidth(t), false)
+layoutspec(t::TimeType) = LayoutSpec(VALIDITY_DATA, 0, 0, primwidth(t), false)
+layoutspec(t::TimestampType) = LayoutSpec(VALIDITY_DATA, 0, 0, 8, false)
+layoutspec(t::DurationType) = LayoutSpec(VALIDITY_DATA, 0, 0, 8, false)
+layoutspec(t::IntervalType) = LayoutSpec(VALIDITY_DATA, 0, 0, primwidth(t), false)
+layoutspec(t::FixedSizeBinaryType) = LayoutSpec(VALIDITY_DATA, 0, 0, t.nbytes, false)
+layoutspec(t::BinaryType) = LayoutSpec(VALIDITY_OFFSETS_DATA, 0, t.large ? 8 : 4, 0, false)
+layoutspec(t::Utf8Type) = LayoutSpec(VALIDITY_OFFSETS_DATA, 0, t.large ? 8 : 4, 0, false)
+layoutspec(t::ListType) = LayoutSpec(VALIDITY_OFFSETS, 1, t.large ? 8 : 4, 0, false)
+layoutspec(::FixedSizeListType) = LayoutSpec(VALIDITY_ONLY, 1, 0, 0, false)
+layoutspec(::StructType) = LayoutSpec(VALIDITY_ONLY, -1, 0, 0, false)
+layoutspec(::MapType) = LayoutSpec(VALIDITY_OFFSETS, 1, 4, 0, false)
+layoutspec(t::UnionType) =
+    t.mode == SparseMode ? LayoutSpec(TYPE_IDS_ONLY, -1, 0, 0, false) :
+    LayoutSpec(TYPE_IDS_ELEMENT_OFFSETS, -1, 4, 0, false)
+layoutspec(t::DictionaryType) =
+    LayoutSpec(VALIDITY_DATA, 0, 0, primwidth(t.indextype), false)
+layoutspec(::ViewType) = LayoutSpec(VALIDITY_VIEWS, 0, 0, 16, true)
+# ListView has one offset and one size per parent slot. These are not
+# the length+1 monotone range offsets used by List/Utf8/Binary.
+layoutspec(t::ListViewType) =
+    LayoutSpec(VALIDITY_ELEMENT_OFFSETS_SIZES, 1, t.large ? 8 : 4, 0, false)
+# REE: no top-level validity; run_ends and values are CHILDREN, not buffers.
+layoutspec(::RunEndEncodedType) = LayoutSpec(NO_BUFFERS, 2, 0, 0, false)
+
+"""
+    layoutspec_of(t::ArrowType) -> LayoutSpec
+
+The closed-set dispatch ladder over the runtime descriptors. This is the
+trim-compile story for a runtime-tagged core: dispatch
+on an abstract-typed field is dynamic, which JuliaC `--trim=safe` rejects —
+but the descriptor set is CLOSED (it is the layout registry), so one
+`isa` ladder devirtualizes every generic call site statically. Multiple
+dispatch remains the extension surface (each branch calls the ordinary
+`layoutspec` method); the ladder is only the entry point generic code uses
+when the descriptor's concrete type is unknown. Branches are ordered by
+expected frequency.
+"""
+@inline function layoutspec_of(t::ArrowType)::LayoutSpec
+    t isa IntType && return layoutspec(t)
+    t isa FloatType && return layoutspec(t)
+    t isa Utf8Type && return layoutspec(t)
+    t isa BoolType && return layoutspec(t)
+    t isa ListType && return layoutspec(t)
+    t isa StructType && return layoutspec(t)
+    t isa DictionaryType && return layoutspec(t)
+    t isa TimestampType && return layoutspec(t)
+    t isa DateType && return layoutspec(t)
+    t isa TimeType && return layoutspec(t)
+    t isa DurationType && return layoutspec(t)
+    t isa BinaryType && return layoutspec(t)
+    t isa FixedSizeBinaryType && return layoutspec(t)
+    t isa FixedSizeListType && return layoutspec(t)
+    t isa MapType && return layoutspec(t)
+    t isa UnionType && return layoutspec(t)
+    t isa DecimalType && return layoutspec(t)
+    t isa IntervalType && return layoutspec(t)
+    t isa NullType && return layoutspec(t)
+    t isa ViewType && return layoutspec(t)
+    t isa ListViewType && return layoutspec(t)
+    t isa RunEndEncodedType && return layoutspec(t)
+    throw(ArgumentError("unregistered ArrowType"))
+end
+
+# Junk descriptors get a clean error instead of a MethodError wherever the
+# raw method table is called directly.
+layoutspec(::Any) = throw(ArgumentError("unregistered ArrowType"))
+
+# ---------------------------------------------------------------------------
+# §4 ArrayData
+# ---------------------------------------------------------------------------
+
+"""
+    ArrayData
+
+The one physical array representation (≅ C `ArrowArray`): buffers + children
++ optional dictionary, plus logical length and a lazily-computed, cached
+null count. Mutable only for the two caches (`nullcount`, `semachecked`);
+everything user-visible is immutable after construction.
+
+`offset` (element offset into the buffers) is carried for C-data import
+compatibility; the accessors below apply it uniformly.
+"""
+mutable struct ArrayData
+    const type::ArrowType
+    const len::Int64
+    const offset::Int64
+    const buffers::FrozenVector{BufferSlice}
+    const children::FrozenVector{ArrayData}
+    const dictionary::Union{Nothing,ArrayData}
+    const owner::Any                  # adapter lifetime anchor, if needed
+    @atomic nullcount::Int64      # -1 = unknown, computed on demand
+    @atomic semachecked::Bool     # data-intrinsic semantic checks passed
+end
+
+function ArrayData(
+    type::ArrowType,
+    len::Integer,
+    buffers;
+    offset::Integer=0,
+    children=(),
+    dictionary::Union{Nothing,ArrayData}=nothing,
+    owner=nothing,
+    nullcount::Integer=-1,
+)
+    return _arraydata(type, len, buffers, offset, children, dictionary, owner, nullcount)
+end
+
+# Positional twin of the keyword constructor: Julia's kwcall machinery does
+# not statically resolve over an abstract-typed leading argument, so
+# trim-verified adapters (the C-data import walk) construct through this
+# single generic method instead.
+function _arraydata(
+    @nospecialize(type::ArrowType),
+    len::Integer,
+    buffers,
+    offset::Integer,
+    children,
+    dictionary::Union{Nothing,ArrayData},
+    owner,
+    nullcount::Integer,
+)
+    len >= 0 || throw(ArgumentError("negative array length"))
+    offset >= 0 || throw(ArgumentError("negative array offset"))
+    -1 <= nullcount <= len ||
+        throw(ArgumentError("null count must be -1 or in [0, length]"))
+    return ArrayData(
+        type,
+        Int64(len),
+        Int64(offset),
+        FrozenVector{BufferSlice}(buffers),
+        FrozenVector{ArrayData}(children),
+        dictionary,
+        owner,
+        Int64(nullcount),
+        false,
+    )
+end
+
+Base.length(d::ArrayData) = d.len
+
+"""
+    copy(data::ArrayData) -> ArrayData
+
+Detach all buffer slices, children, and dictionary values into Julia-owned
+byte arrays. Preserve the layout and element offset. The result has no
+foreign owner or release callback and remains usable after the source is
+released. Keep its `Field` to materialize named values with `materialize`.
+
+The source must remain valid and unchanged during the copy. This copies
+whole declared buffer slices, which can include values outside a logical
+array slice. Semantic validation is not inherited. `deepcopy` does not
+detach: the copy shares the source's buffers and their release.
+"""
+function Base.copy(d::ArrayData)
+    return ArrayData(
+        d.type,
+        d.len,
+        [_databuffer(slicebytes(b)) for b in d.buffers];
+        offset=d.offset,
+        children=map(copy, d.children),
+        dictionary=d.dictionary === nothing ? nothing : copy(d.dictionary),
+        nullcount=@atomic(:monotonic, d.nullcount),
+    )
+end
+
+# Adapter-private certificate set. An entry means that one immutable
+# dictionary pool snapshot already passed structural, intrinsic semantic, and
+# Field-contract validation under the adapter's canonical value Field.
+const _ValidatedDictionaries = IdDict{ArrayData,Nothing}
+@inline _dictionary_validated(::Nothing, ::ArrayData) = false
+@inline _dictionary_validated(memo::_ValidatedDictionaries, d::ArrayData) = haskey(memo, d)
+
+@inline _slotindex0(d::ArrayData, i::Int64) =
+    checked_add(d.offset, checked_sub(i, Int64(1)))
+@inline _slotbyteoff(d::ArrayData, i::Int64, width::Integer) =
+    checked_mul(_slotindex0(d, i), Int64(width))
+
+# Buffer-by-role lookup, driven by the registry. Structural validation
+# guarantees position/arity, so adapters and accessors never hand-count.
+function rolebuffer(d::ArrayData, role::BufferRole)
+    spec = layoutspec_of(d.type)
+    idx = findfirst(==(role), spec.buffers)
+    idx === nothing &&
+        throw(ArgumentError("layout $(descriptorname(d.type)) has no $role buffer"))
+    return d.buffers[idx]
+end
+
+validitybuffer(d::ArrayData) = rolebuffer(d, VALIDITY)
+
+"""
+    isvalid_at(d, i)
+
+Element validity for 1-based logical index `i`. An empty validity slice
+means "no nulls recorded" — every element valid (the spec's empty-bitmap
+convention). Layouts with no validity buffer (null, union, REE) answer
+through their own accessors.
+"""
+@inline function isvalid_at(d::ArrayData, i::Integer)
+    v = validitybuffer(d)
+    isempty_buffer(v) && return true
+    return getbit(v, _slotindex0(d, Int64(i)))
+end
+
+"""
+    nullcount(d) -> Int64
+
+Cached lazy null count (the polars `unset_bit_count_cache` idea). The benign
+race — two tasks computing the same value and both storing it — is
+harmless; `:monotonic` ordering is all the cache needs.
+"""
+function nullcount(d::ArrayData)
+    nc = @atomic :monotonic d.nullcount
+    nc >= 0 && return nc
+    nc = _count_nulls(d)
+    @atomic :monotonic d.nullcount = nc
+    return nc
+end
+
+function _count_nulls(d::ArrayData)
+    d.type isa NullType && return d.len
+    spec = layoutspec_of(d.type)
+    isempty(spec.buffers) && return Int64(0)
+    spec.buffers[1] == VALIDITY || return Int64(0)   # unions: no top-level nulls
+    v = d.buffers[1]
+    isempty_buffer(v) && return Int64(0)
+    return d.len - _countsetbits(v, d.offset, d.len)
+end
+
+"Set bits among the `len` bitmap bits that start at 0-based bit `start`."
+function _countsetbits(v::BufferSlice, start::Int64, len::Int64)
+    len > 0 || return Int64(0)
+    start >= 0 || throw(BoundsError(v, start))
+    stop = checked_add(start, len)           # exclusive
+    firstbyte, lastbyte = start >> 3, (stop - 1) >> 3
+    nbytes = lastbyte - firstbyte + 1
+    # One bounds check covers every byte the bits touch, as getbit's would.
+    (nbytes <= v.len && firstbyte <= v.len - nbytes) || throw(BoundsError(v, lastbyte))
+    n = Int64(0)
+    GC.@preserve v begin
+        p = sliceptr(v) + firstbyte
+        for k = 0:(nbytes - 1)
+            byte = unsafe_load(p + k)
+            k == 0 && (byte &= 0xff << (start & 7))
+            k == nbytes - 1 && (byte &= 0xff >> (7 - ((stop - 1) & 7)))
+            n += count_ones(byte)
+        end
+    end
+    return n
+end
+
+# ---------------------------------------------------------------------------
+# §5 Staged validation
+# ---------------------------------------------------------------------------
+
+struct ValidationError <: Exception
+    msg::String
+end
+Base.showerror(io::IO, e::ValidationError) = print(io, "Arrow.ValidationError: ", e.msg)
+
+function expected_validity_bytes(len::Int64)
+    len >= 0 || throw(ArgumentError("negative bitmap length"))
+    # `len + 7` can overflow a hostile logical extent; the requirement is
+    # then unsatisfiable, which is a validation failure, not a raw
+    # `OverflowError`.
+    len <= typemax(Int64) - 7 ||
+        throw(ValidationError("required bitmap bytes overflow Int64 for $len slots"))
+    return (len + 7) >> 3
+end
+
+# Structural requirements multiply untrusted logical extents. When the
+# product overflows Int64 no real buffer or child can satisfy it, so it
+# surfaces as the same ValidationError an undersized one gets, not as a
+# raw `OverflowError`. Both operands are non-negative at every call site.
+@inline function _required_extent(count::Int64, width::Int64, what::AbstractString)
+    count == 0 ||
+        width <= div(typemax(Int64), count) ||
+        throw(ValidationError("required $what overflows Int64 ($count × $width)"))
+    return count * width
+end
+
+# Runtime descriptor equality must compare values, not only Julia types.
+# One more closed-set ladder (no fieldcount/getfield reflection — that is
+# dynamic and trim-hostile); each branch compares its descriptor's fields
+# explicitly.
+# Non-recursive: the spec forbids dictionary-encoded dictionary VALUES, so
+# a DictionaryType's valuetype is never itself a DictionaryType (enforced in
+# _validate_descriptor) and one nested ladder suffices — which is what lets
+# both levels inline at abstract call sites for trim.
+@inline function _typeequal_nondict(a::ArrowType, b::ArrowType)
+    a isa IntType && return b isa IntType && a.bits == b.bits && a.signed == b.signed
+    a isa FloatType && return b isa FloatType && a.bits == b.bits
+    a isa Utf8Type && return b isa Utf8Type && a.large == b.large
+    a isa BoolType && return b isa BoolType
+    a isa ListType && return b isa ListType && a.large == b.large
+    a isa StructType && return b isa StructType
+    a isa TimestampType &&
+        return b isa TimestampType && a.unit == b.unit && a.timezone == b.timezone
+    a isa DateType && return b isa DateType && a.unit == b.unit
+    a isa TimeType && return b isa TimeType && a.unit == b.unit && a.bits == b.bits
+    a isa DurationType && return b isa DurationType && a.unit == b.unit
+    a isa BinaryType && return b isa BinaryType && a.large == b.large
+    a isa FixedSizeBinaryType && return b isa FixedSizeBinaryType && a.nbytes == b.nbytes
+    a isa FixedSizeListType && return b isa FixedSizeListType && a.listsize == b.listsize
+    a isa MapType && return b isa MapType && a.keyssorted == b.keyssorted
+    a isa UnionType && return b isa UnionType && a.mode == b.mode && a.typeids == b.typeids
+    a isa DecimalType && return b isa DecimalType &&
+           a.precision == b.precision &&
+           a.scale == b.scale &&
+           a.bits == b.bits
+    a isa IntervalType && return b isa IntervalType && a.unit == b.unit
+    a isa NullType && return b isa NullType
+    a isa ViewType && return b isa ViewType && a.utf8 == b.utf8
+    a isa ListViewType && return b isa ListViewType && a.large == b.large
+    a isa RunEndEncodedType && return b isa RunEndEncodedType
+    return false
+end
+
+@inline function typeequal(a::ArrowType, b::ArrowType)
+    if a isa DictionaryType
+        return b isa DictionaryType &&
+               a.indextype.bits == b.indextype.bits &&
+               a.indextype.signed == b.indextype.signed &&
+               _typeequal_nondict(a.valuetype, b.valuetype) &&
+               a.ordered == b.ordered
+    end
+    b isa DictionaryType && return false
+    return _typeequal_nondict(a, b)
+end
+
+"""
+    descriptorname(t::ArrowType) -> Symbol
+
+Closed-set name ladder for error messages: `nameof(typeof(x))` on an
+abstract-typed value is itself a dynamic call, so diagnostics use this
+instead.
+"""
+@inline function descriptorname(t::ArrowType)::Symbol
+    t isa IntType && return :IntType
+    t isa FloatType && return :FloatType
+    t isa Utf8Type && return :Utf8Type
+    t isa BoolType && return :BoolType
+    t isa ListType && return :ListType
+    t isa StructType && return :StructType
+    t isa DictionaryType && return :DictionaryType
+    t isa TimestampType && return :TimestampType
+    t isa DateType && return :DateType
+    t isa TimeType && return :TimeType
+    t isa DurationType && return :DurationType
+    t isa BinaryType && return :BinaryType
+    t isa FixedSizeBinaryType && return :FixedSizeBinaryType
+    t isa FixedSizeListType && return :FixedSizeListType
+    t isa MapType && return :MapType
+    t isa UnionType && return :UnionType
+    t isa DecimalType && return :DecimalType
+    t isa IntervalType && return :IntervalType
+    t isa NullType && return :NullType
+    t isa ViewType && return :ViewType
+    t isa ListViewType && return :ListViewType
+    t isa RunEndEncodedType && return :RunEndEncodedType
+    return :UnknownArrowType
+end
+
+_validate_descriptor(::Utf8Type) = nothing
+_validate_descriptor(::BoolType) = nothing
+_validate_descriptor(::ListType) = nothing
+_validate_descriptor(::StructType) = nothing
+_validate_descriptor(::BinaryType) = nothing
+_validate_descriptor(::MapType) = nothing
+_validate_descriptor(::NullType) = nothing
+_validate_descriptor(::ViewType) = nothing
+_validate_descriptor(::ListViewType) = nothing
+_validate_descriptor(::RunEndEncodedType) = nothing
+_validate_descriptor(::Any) = throw(ArgumentError("unregistered ArrowType"))
+
+@inline function _validate_descriptor_of(t::ArrowType)
+    t isa IntType && return _validate_descriptor(t)
+    t isa FloatType && return _validate_descriptor(t)
+    t isa Utf8Type && return _validate_descriptor(t)
+    t isa BoolType && return _validate_descriptor(t)
+    t isa ListType && return _validate_descriptor(t)
+    t isa StructType && return _validate_descriptor(t)
+    t isa DictionaryType && return _validate_descriptor(t)
+    t isa TimestampType && return _validate_descriptor(t)
+    t isa DateType && return _validate_descriptor(t)
+    t isa TimeType && return _validate_descriptor(t)
+    t isa DurationType && return _validate_descriptor(t)
+    t isa BinaryType && return _validate_descriptor(t)
+    t isa FixedSizeBinaryType && return _validate_descriptor(t)
+    t isa FixedSizeListType && return _validate_descriptor(t)
+    t isa MapType && return _validate_descriptor(t)
+    t isa UnionType && return _validate_descriptor(t)
+    t isa DecimalType && return _validate_descriptor(t)
+    t isa IntervalType && return _validate_descriptor(t)
+    t isa NullType && return _validate_descriptor(t)
+    t isa ViewType && return _validate_descriptor(t)
+    t isa ListViewType && return _validate_descriptor(t)
+    t isa RunEndEncodedType && return _validate_descriptor(t)
+    throw(ArgumentError("unregistered ArrowType"))
+end
+_validate_descriptor(t::IntType) =
+    t.bits in (8, 16, 32, 64, 128) ||
+    throw(ValidationError("integer bit width must be 8, 16, 32, 64, or 128"))
+_validate_descriptor(t::FloatType) =
+    t.bits in (16, 32, 64) ||
+    throw(ValidationError("floating-point bit width must be 16, 32, or 64"))
+function _validate_descriptor(t::DecimalType)
+    maxprecision =
+        t.bits == 32 ? 9 : t.bits == 64 ? 18 : t.bits == 128 ? 38 : t.bits == 256 ? 76 : 0
+    maxprecision != 0 ||
+        throw(ValidationError("decimal bit width must be 32, 64, 128, or 256"))
+    1 <= t.precision <= maxprecision || throw(
+        ValidationError(
+            "decimal precision $(t.precision) is invalid for $(t.bits)-bit storage",
+        ),
+    )
+    typemin(Int32) <= t.scale <= typemax(Int32) || throw(
+        ValidationError("decimal scale $(t.scale) does not fit the Arrow Int32 wire field"),
+    )
+    return nothing
+end
+_validate_descriptor(t::FixedSizeBinaryType) =
+    0 <= t.nbytes <= typemax(Int32) ||
+    throw(ValidationError("fixed-size-binary width must be in [0, $(typemax(Int32))]"))
+_validate_descriptor(t::DateType) =
+    t.unit in (DAY, MILLISECOND_DATE) ||
+    throw(ValidationError("invalid Arrow date unit $(repr(t.unit))"))
+function _validate_descriptor(t::TimeType)
+    t.unit in (SECOND, MILLISECOND, MICROSECOND, NANOSECOND) ||
+        throw(ValidationError("invalid Arrow time unit $(repr(t.unit))"))
+    valid = t.unit in (SECOND, MILLISECOND) ? t.bits == 32 : t.bits == 64
+    valid || throw(
+        ValidationError("time unit $(t.unit) is incompatible with $(t.bits)-bit storage"),
+    )
+    return nothing
+end
+function _validate_descriptor(t::TimestampType)
+    t.unit in (SECOND, MILLISECOND, MICROSECOND, NANOSECOND) ||
+        throw(ValidationError("invalid Arrow timestamp unit $(repr(t.unit))"))
+    (t.timezone === nothing || isvalid(t.timezone)) ||
+        throw(ValidationError("timestamp timezone is not valid UTF-8"))
+    return nothing
+end
+_validate_descriptor(t::DurationType) =
+    t.unit in (SECOND, MILLISECOND, MICROSECOND, NANOSECOND) ||
+    throw(ValidationError("invalid Arrow duration unit $(repr(t.unit))"))
+_validate_descriptor(t::IntervalType) =
+    t.unit in (YEAR_MONTH, DAY_TIME, MONTH_DAY_NANO) ||
+    throw(ValidationError("invalid Arrow interval unit $(repr(t.unit))"))
+_validate_descriptor(t::FixedSizeListType) =
+    0 <= t.listsize <= typemax(Int32) ||
+    throw(ValidationError("fixed-size-list size must be in [0, $(typemax(Int32))]"))
+_validate_descriptor(t::UnionType) =
+    t.mode in (SparseMode, DenseMode) ||
+    throw(ValidationError("invalid Arrow union mode $(repr(t.mode))"))
+function _validate_descriptor(t::DictionaryType)
+    _validate_descriptor(t.indextype)
+    t.indextype.bits <= 64 ||
+        throw(ValidationError("dictionary index bit width must be 8, 16, 32, or 64"))
+    # The spec forbids dictionary-encoded dictionary values; enforcing it
+    # here is also what keeps descriptor equality non-recursive (typeequal).
+    t.valuetype isa DictionaryType &&
+        throw(ValidationError("dictionary values cannot themselves be dictionary-encoded"))
+    _validate_descriptor_of(t.valuetype)
+    return nothing
+end
+
+function _validate_schema(s::Schema)
+    s.endianness in (LittleEndian, BigEndian) ||
+        throw(ValidationError("invalid Arrow schema endianness $(repr(s.endianness))"))
+    s.endianness == _native_endianness() || throw(
+        ValidationError(
+            "non-native Arrow schema endianness must be normalized before Core access",
+        ),
+    )
+    return s
+end
+
+"""
+    validate_structural(field, data)
+
+Stage-2 validation: O(buffers), registry-driven, run at
+construction/adaptation time. Checks buffer arity against the layout, and
+every buffer's byte length against what the logical length requires — with
+checked arithmetic, because these lengths come from untrusted metadata.
+Recurses into children and the dictionary.
+
+BufferSlice construction has already bounded every slice inside its region,
+so this stage never touches memory — it is pure arithmetic on declared
+sizes. (The framing stage — resource limits before metadata-directed decode
+allocation and checked message-body spans — belongs to the adapters; see
+src/ipc_read.jl.)
+"""
+validate_structural(f::Field, d::ArrayData) = _validate_structural(f, d, nothing)
+
+function _validate_structural(
+    f::Field,
+    d::ArrayData,
+    validated_dictionaries::Union{Nothing,_ValidatedDictionaries},
+)
+    isvalid(f.name) || throw(ValidationError("field name is not valid UTF-8"))
+    typeequal(f.type, d.type) || throw(
+        ValidationError(
+            "field/type mismatch: $(descriptorname(f.type)) vs $(descriptorname(d.type))",
+        ),
+    )
+    _validate_descriptor_of(d.type)
+    spec = layoutspec_of(d.type)
+    nfixed = length(spec.buffers)
+    buffers_ok = spec.variadic ? length(d.buffers) >= nfixed : length(d.buffers) == nfixed
+    buffers_ok || throw(
+        ValidationError(
+            "$(descriptorname(d.type)): expected $(spec.variadic ? "at least " : "")$nfixed buffers, got $(length(d.buffers))",
+        ),
+    )
+    # `len` and `offset` are individually non-negative (constructor
+    # invariant), but hostile metadata can still declare a sum past Int64 —
+    # surface that as ValidationError, not a raw OverflowError.
+    d.len <= typemax(Int64) - d.offset || throw(
+        ValidationError("array length $(d.len) plus offset $(d.offset) overflows Int64"),
+    )
+    total::Int64 = d.len + d.offset
+    declared_nulls = @atomic :monotonic d.nullcount
+    for (i, role) in enumerate(spec.buffers)
+        b = d.buffers[i]
+        if role == VALIDITY
+            if isempty_buffer(b)
+                declared_nulls > 0 && throw(
+                    ValidationError("absent validity bitmap with positive null count"),
+                )
+                continue
+            end
+            b.len >= expected_validity_bytes(total) || throw(
+                ValidationError(
+                    "validity bitmap too small: $(b.len) bytes for $total slots",
+                ),
+            )
+        elseif role == DATA
+            if spec.fixedwidth > 0
+                need = _required_extent(total, Int64(spec.fixedwidth), "data buffer bytes")
+                b.len >= need ||
+                    throw(ValidationError("data buffer too small: $(b.len) < $need bytes"))
+            elseif spec.fixedwidth == -1   # bit-packed (Bool)
+                b.len >= expected_validity_bytes(total) ||
+                    throw(ValidationError("bit-packed data buffer too small"))
+            end
+            # fixedwidth == 0 (varbinary DATA): bounded by offsets in the
+            # semantic stage — nothing structural to require here.
+        elseif role == OFFSETS
+            # Canonical empty offset-based arrays may omit the offsets
+            # buffer. A sliced empty array (`offset > 0`) still needs the
+            # physical prefix that its offset addresses.
+            isempty_buffer(b) && d.len == 0 && d.offset == 0 && continue
+            # `total + 1` offset slots: the +1 itself can overflow a hostile
+            # extent.
+            total < typemax(Int64) ||
+                throw(ValidationError("required offsets buffer bytes overflow Int64"))
+            need = _required_extent(
+                total + Int64(1),
+                Int64(spec.offsetwidth),
+                "offsets buffer bytes",
+            )
+            b.len >= need ||
+                throw(ValidationError("offsets buffer too small: $(b.len) < $need bytes"))
+        elseif role == ELEMENT_OFFSETS
+            need = _required_extent(total, Int64(spec.offsetwidth), "element-offsets bytes")
+            b.len >= need || throw(
+                ValidationError("element-offsets buffer too small: $(b.len) < $need bytes"),
+            )
+        elseif role == SIZES
+            need = _required_extent(total, Int64(spec.offsetwidth), "sizes buffer bytes")
+            b.len >= need || throw(ValidationError("sizes buffer too small"))
+        elseif role == TYPE_IDS
+            b.len >= total || throw(ValidationError("type_ids buffer too small"))
+        elseif role == VIEWS
+            need = _required_extent(total, Int64(16), "views buffer bytes")
+            b.len >= need || throw(ValidationError("views buffer too small"))
+        end
+    end
+    # Child arity: registry-declared, or Field-declared for struct/union.
+    expected_children = spec.childcount == -1 ? length(f.children) : spec.childcount
+    if !(d.type isa DictionaryType)
+        length(f.children) == expected_children || throw(
+            ValidationError(
+                "$(descriptorname(d.type)): expected $expected_children child fields, got $(length(f.children))",
+            ),
+        )
+    end
+    length(d.children) == expected_children || throw(
+        ValidationError(
+            "$(descriptorname(d.type)): expected $expected_children children, got $(length(d.children))",
+        ),
+    )
+    for (cf, cd) in zip(childfields(f), d.children)
+        _validate_structural(cf, cd, validated_dictionaries)
+    end
+    if d.type isa DictionaryType
+        d.dictionary === nothing &&
+            throw(ValidationError("dictionary-encoded array without a dictionary"))
+        dictionary = d.dictionary::ArrayData
+        _dictionary_validated(validated_dictionaries, dictionary) || _validate_structural(
+            dictvaluefield(f, d.type),
+            dictionary,
+            validated_dictionaries,
+        )
+    elseif d.dictionary !== nothing
+        throw(ValidationError("dictionary values attached to a non-dictionary array"))
+    end
+    fslt = d.type
+    if fslt isa FixedSizeListType
+        need = _required_extent(total, Int64(fslt.listsize), "fixed-size-list child length")
+        length(d.children[1]) >= need || throw(
+            ValidationError(
+                "fixed-size-list child too short: $(length(d.children[1])) < $need",
+            ),
+        )
+    end
+    # Struct and sparse-union children are parent-length arrays indexed at
+    # parent.offset + i (each child then applies its own offset), so every
+    # child must cover offset+len slots.
+    if d.type isa StructType || (d.type isa UnionType && d.type.mode == SparseMode)
+        for (ci, child) in enumerate(d.children)
+            length(child) >= total || throw(
+                ValidationError(
+                    "child $ci too short for parent extent: $(length(child)) < $total",
+                ),
+            )
+        end
+    end
+    ut = d.type
+    if ut isa UnionType
+        length(ut.typeids) == length(f.children) ||
+            throw(ValidationError("union type-id count must equal child count"))
+        length(unique(ut.typeids)) == length(ut.typeids) ||
+            throw(ValidationError("union type ids must be unique"))
+        all(>=(0), ut.typeids) ||
+            throw(ValidationError("union type ids must be in [0, 127]"))
+    end
+    if d.type isa MapType
+        entries = f.children[1]
+        entries.type isa StructType ||
+            throw(ValidationError("map child must be an entries struct"))
+        !entries.nullable ||
+            throw(ValidationError("map entries field must be non-nullable"))
+        length(entries.children) == 2 ||
+            throw(ValidationError("map entries struct must have key and value children"))
+        !entries.children[1].nullable ||
+            throw(ValidationError("map keys must be non-nullable"))
+    end
+    if d.type isa RunEndEncodedType
+        runfield, valuefield = f.children
+        runfield.name == "run_ends" && valuefield.name == "values" ||
+            throw(ValidationError("REE children must be named run_ends and values"))
+        runtype0 = runfield.type
+        runtype0 isa IntType ||
+            throw(ValidationError("REE run ends must be signed int16, int32, or int64"))
+        runtype = runtype0::IntType
+        (runtype.signed && runtype.bits in (16, 32, 64)) ||
+            throw(ValidationError("REE run ends must be signed int16, int32, or int64"))
+        !runfield.nullable || throw(ValidationError("REE run ends must be non-nullable"))
+        # The parent has no validity bitmap, so a positive count is
+        # malformed; unknown (-1) is legal for any layout.
+        declared_nulls <= 0 || throw(ValidationError("REE parent null count must be zero"))
+        length(d.children[1]) == length(d.children[2]) ||
+            throw(ValidationError("REE run-end and value child lengths must match"))
+        d.len == 0 ||
+            length(d.children[1]) > 0 ||
+            throw(
+                ValidationError("a nonempty REE array requires at least one physical run"),
+            )
+        maxrunend =
+            runtype.bits == 16 ? Int64(typemax(Int16)) :
+            runtype.bits == 32 ? Int64(typemax(Int32)) : typemax(Int64)
+        total <= maxrunend || throw(
+            ValidationError(
+                "REE logical extent $total exceeds the $(runtype.bits)-bit run-end range",
+            ),
+        )
+    end
+    return d
+end
+
+# Child Fields for traversal. For list-ish layouts the child field is the
+# Field's single declared child; dictionary values reuse the field with the
+# value type.
+childfields(f::Field) = f.children
+# Dictionary values have their own nullability. The index field's
+# nullable flag describes only the indices and cannot constrain the pool.
+dictvaluefield(f::Field, t::DictionaryType) =
+    Field(f.name, t.valuetype; nullable=true, children=f.children)
+
+const MILLISECONDS_PER_DAY = Int64(86_400_000)
+
+# Date64 whole-day divisibility and Decimal precision are ADVISORY in
+# practice: the spec phrases Date64 as "evenly divisible by 86400000" and
+# precision as "total number of decimal digits", but the reference C++
+# implementation neither enforces them on read nor honors them on write — the
+# apache/arrow-testing gold corpus itself carries Date64 values off day
+# boundaries and decimal(3,2) values with five digits. Rejecting those in
+# `validate_semantic` would make a conforming reader refuse canonical data,
+# so both checks live in the opt-in `validate_full` tier
+# (`_validate_full_content`), where strict callers can still demand them.
+function _validate_advisory_values(t::DateType, d::ArrayData)
+    t.unit == MILLISECOND_DATE || return nothing
+    data = rolebuffer(d, DATA)
+    for i = 1:(d.len)
+        isvalid_at(d, i) || continue
+        value = loadat(data, Int64, _slotbyteoff(d, Int64(i), 8))
+        value % MILLISECONDS_PER_DAY == 0 ||
+            throw(ValidationError("Date64 value $value is not a whole day in milliseconds"))
+    end
+    return nothing
+end
+
+function _decimal_limb(
+    t::DecimalType,
+    data::BufferSlice,
+    byteoff::Int64,
+    nlimbs::Int,
+    limb::Int,
+)::UInt64
+    limb <= nlimbs || return UInt64(0)
+    source_limb = _native_endianness() == LittleEndian ? limb : nlimbs - limb + 1
+    base = checked_add(byteoff, Int64(8 * (source_limb - 1)))
+    return t.bits == 32 ? UInt64(loadat(data, UInt32, base)) : loadat(data, UInt64, base)
+end
+
+function _decimal_fits_precision(t::DecimalType, data::BufferSlice, byteoff::Int64)
+    # Core accepts only native-endian array buffers. Arrow decimal storage is
+    # a two's-complement integer, so put native chunks into least-significant
+    # limb order before comparing its magnitude with 10^p. Work in fixed
+    # UInt256-style arithmetic so Core stays Base-only and Decimal256 does not
+    # require BigInt allocations or BitIntegers. (No closures here: captured
+    # and reassigned locals box, which defeats trim verification.)
+    nlimbs = cld(t.bits, 64)
+    l1 = _decimal_limb(t, data, byteoff, nlimbs, 1)
+    l2 = _decimal_limb(t, data, byteoff, nlimbs, 2)
+    l3 = _decimal_limb(t, data, byteoff, nlimbs, 3)
+    l4 = _decimal_limb(t, data, byteoff, nlimbs, 4)
+    signbit = t.bits == 32 ? UInt64(1) << 31 : UInt64(1) << 63
+    negative =
+        ((nlimbs == 1 ? l1 : nlimbs == 2 ? l2 : nlimbs == 3 ? l3 : l4) & signbit) != 0
+    if negative && t.bits == 32
+        l1 |= typemax(UInt64) << 32
+    end
+    m1 = nlimbs >= 1 ? (negative ? ~l1 : l1) : UInt64(0)
+    m2 = nlimbs >= 2 ? (negative ? ~l2 : l2) : UInt64(0)
+    m3 = nlimbs >= 3 ? (negative ? ~l3 : l3) : UInt64(0)
+    m4 = nlimbs >= 4 ? (negative ? ~l4 : l4) : UInt64(0)
+    if negative
+        m1 += UInt64(1)
+        c = m1 == 0
+        m2 += c ? UInt64(1) : UInt64(0)
+        c &= m2 == 0
+        m3 += c ? UInt64(1) : UInt64(0)
+        c &= m3 == 0
+        m4 += c ? UInt64(1) : UInt64(0)
+    end
+
+    L1, L2, L3, L4 = UInt64(1), UInt64(0), UInt64(0), UInt64(0)
+    for _ = 1:(t.precision)
+        p1 = UInt128(L1) * 10
+        p2 = UInt128(L2) * 10 + (p1 >> 64)
+        p3 = UInt128(L3) * 10 + (p2 >> 64)
+        p4 = UInt128(L4) * 10 + (p3 >> 64)
+        L1 = UInt64(p1 & UInt128(typemax(UInt64)))
+        L2 = UInt64(p2 & UInt128(typemax(UInt64)))
+        L3 = UInt64(p3 & UInt128(typemax(UInt64)))
+        L4 = UInt64(p4 & UInt128(typemax(UInt64)))
+    end
+    m4 < L4 && return true
+    m4 > L4 && return false
+    m3 < L3 && return true
+    m3 > L3 && return false
+    m2 < L2 && return true
+    m2 > L2 && return false
+    return m1 < L1
+end
+
+function _validate_advisory_values(t::DecimalType, d::ArrayData)
+    data = rolebuffer(d, DATA)
+    width = Int64(primwidth(t))
+    for i = 1:(d.len)
+        isvalid_at(d, i) || continue
+        byteoff = _slotbyteoff(d, Int64(i), width)
+        _decimal_fits_precision(t, data, byteoff) || throw(
+            ValidationError(
+                "Decimal value at element $i does not fit precision $(t.precision)",
+            ),
+        )
+    end
+    return nothing
+end
+
+# Time-of-day range is advisory for the same reason as Date64 divisibility:
+# the 1.0.0 gold corpus carries out-of-range Time32 values that C++ reads.
+function _validate_advisory_values(t::TimeType, d::ArrayData)
+    units_per_day =
+        t.unit == SECOND ? Int64(86_400) :
+        t.unit == MILLISECOND ? MILLISECONDS_PER_DAY :
+        t.unit == MICROSECOND ? Int64(86_400_000_000) : Int64(86_400_000_000_000)
+    data = rolebuffer(d, DATA)
+    for i = 1:(d.len)
+        isvalid_at(d, i) || continue
+        value = if t.bits == 32
+            Int64(loadat(data, Int32, _slotbyteoff(d, Int64(i), Int64(4))))
+        else
+            loadat(data, Int64, _slotbyteoff(d, Int64(i), Int64(8)))
+        end
+        0 <= value < units_per_day || throw(
+            ValidationError(
+                "Time value $value is outside [0, $units_per_day) for $(t.unit)",
+            ),
+        )
+    end
+    return nothing
+end
+
+"""
+    validate_semantic(field, data)
+
+Stage-3 validation. This public stage composes structural validation before
+any content access, so callers cannot accidentally certify malformed buffer
+geometry by skipping `validate_structural`. Data-intrinsic checks are cached
+on the ArrayData (`semachecked`); benign concurrent callers may repeat the
+same scan. Field-dependent dictionary contracts run on every call because
+the same data can be checked against another Field. Per-slot nullability
+enforcement is advisory and lives in the opt-in `validate_full` tier.
+"""
+function validate_semantic(f::Field, d::ArrayData)
+    return _validate_semantic(f, d, nothing)
+end
+
+function _validate_semantic(
+    f::Field,
+    d::ArrayData,
+    validated_dictionaries::Union{Nothing,_ValidatedDictionaries},
+)
+    _validate_structural(f, d, validated_dictionaries)
+    _validate_semantic_intrinsic(f, d, validated_dictionaries)
+    _validate_field_contracts(f, d, validated_dictionaries)
+    return d
+end
+
+function _validate_semantic_intrinsic(
+    f::Field,
+    d::ArrayData,
+    validated_dictionaries::Union{Nothing,_ValidatedDictionaries},
+)
+    t = d.type
+    if !(@atomic :monotonic d.semachecked)
+        spec = layoutspec_of(t)
+        oi = findfirst(==(OFFSETS), spec.buffers)
+        if oi !== nothing && spec.offsetwidth != 0
+            wide = spec.offsetwidth == 8
+            offs = d.buffers[oi]
+            if !(isempty_buffer(offs) && d.len == 0 && d.offset == 0)
+                databytes = if t isa Utf8Type || t isa BinaryType
+                    di = findfirst(==(DATA), spec.buffers)
+                    d.buffers[di].len
+                else
+                    isempty(d.children) ? Int64(0) : Int64(length(d.children[1]))
+                end
+                _load_offset(offs, wide, d.offset) >= 0 ||
+                    throw(ValidationError("negative first offset"))
+                last = _monotonicoffsets(offs, wide, d.offset, d.len)
+                last <= databytes || throw(
+                    ValidationError("final offset $last exceeds data extent $databytes"),
+                )
+            end
+        end
+        if t isa DictionaryType
+            dictlen = length(d.dictionary)
+            data = rolebuffer(d, DATA)
+            w = primwidth(t.indextype)
+            if !_dictindicesinrange(d, t.indextype, dictlen)
+                for i = 1:(d.len)
+                    isvalid_at(d, i) || continue
+                    idx = _load_int(data, t.indextype, _slotbyteoff(d, Int64(i), w))
+                    0 <= idx < dictlen || throw(
+                        ValidationError(
+                            "dictionary index $idx out of bounds [0, $dictlen)",
+                        ),
+                    )
+                end
+            end
+        end
+        if t isa UnionType
+            ids = rolebuffer(d, TYPE_IDS)
+            # Dense-mode-only bookkeeping; sparse unions never read it.
+            lastoffset = t.mode == DenseMode ? fill(Int64(-1), length(d.children)) : Int64[]
+            for i = 1:(d.len)
+                tid = loadat(ids, Int8, _slotindex0(d, Int64(i)))
+                pos = findfirst(==(tid), t.typeids)
+                pos === nothing &&
+                    throw(ValidationError("union type id $tid not in declared domain"))
+                if t.mode == DenseMode
+                    off = loadat(
+                        rolebuffer(d, ELEMENT_OFFSETS),
+                        Int32,
+                        _slotbyteoff(d, Int64(i), 4),
+                    )
+                    0 <= off < length(d.children[pos]) || throw(
+                        ValidationError(
+                            "dense union offset $off out of bounds for child $pos",
+                        ),
+                    )
+                    Int64(off) >= lastoffset[pos] || throw(
+                        ValidationError(
+                            "dense union offsets must be nondecreasing within child $pos",
+                        ),
+                    )
+                    lastoffset[pos] = Int64(off)
+                end
+            end
+        end
+        t isa ViewType && _validate_view_values(t, d)
+        t isa ListViewType && _validate_listview_values(t, d)
+        t isa RunEndEncodedType && _validate_ree_values(d)
+        actual_nulls = _count_nulls(d)
+        declared_nulls = @atomic :monotonic d.nullcount
+        if declared_nulls >= 0 && declared_nulls != actual_nulls
+            throw(
+                ValidationError(
+                    "declared null count $declared_nulls does not match bitmap count $actual_nulls",
+                ),
+            )
+        elseif declared_nulls < 0
+            # Promote the unknown sentinel to the counted value: later
+            # structural checks on this same array then enforce the
+            # absent-bitmap rule against a known count instead of skipping it.
+            @atomic :monotonic d.nullcount = actual_nulls
+        end
+        @atomic :monotonic d.semachecked = true
+    end
+    # The cache flag is per-node, so recurse even when this node is cached:
+    # each child short-circuits on its own flag.
+    for (cf, cd) in zip(childfields(f), d.children)
+        _validate_semantic_intrinsic(cf, cd, validated_dictionaries)
+    end
+    if t isa DictionaryType
+        dictionary = d.dictionary::ArrayData
+        _dictionary_validated(validated_dictionaries, dictionary) ||
+            _validate_semantic_intrinsic(
+                dictvaluefield(f, t),
+                dictionary,
+                validated_dictionaries,
+            )
+    end
+    return d
+end
+
+# -- view layouts (format 1.4) ----------------------------------------------
+
+# One 16-byte view entry: length, then either 12 inline bytes (length <= 12,
+# zero-padded) or prefix + buffer index + offset into one of the variadic
+# data buffers that follow validity and views.
+const VIEW_INLINE_MAX = Int32(12)
+
+@inline _viewbase(d::ArrayData, i::Int64) = _slotbyteoff(d, i, 16)
+
+function _viewdatabuffer(d::ArrayData, bufidx::Int32)
+    nvariadic = length(d.buffers) - 2
+    0 <= bufidx < nvariadic ||
+        throw(ValidationError("view buffer index $bufidx outside [0, $nvariadic)"))
+    return d.buffers[3 + Int(bufidx)]
+end
+
+"""
+Whether every valid slot's dictionary index lies in `[0, dictlen)`: one
+bounds check for the index window, then a branch-free pass. `false` sends
+the caller to the per-slot loop that names the offending index.
+"""
+function _dictindicesinrange(d::ArrayData, it::IntType, dictlen::Int64)
+    d.len == 0 && return true
+    w = Int64(primwidth(it))
+    src = subslice(rolebuffer(d, DATA), checked_mul(d.offset, w), checked_mul(d.len, w))
+    validity = validitybuffer(d)
+    ok = GC.@preserve d begin
+        p = sliceptr(src)
+        if it.signed
+            w == 1 ? _indicesinrange(Ptr{Int8}(p), d, validity, dictlen) :
+            w == 2 ? _indicesinrange(Ptr{Int16}(p), d, validity, dictlen) :
+            w == 4 ? _indicesinrange(Ptr{Int32}(p), d, validity, dictlen) :
+            _indicesinrange(Ptr{Int64}(p), d, validity, dictlen)
+        else
+            w == 1 ? _indicesinrange(Ptr{UInt8}(p), d, validity, dictlen) :
+            w == 2 ? _indicesinrange(Ptr{UInt16}(p), d, validity, dictlen) :
+            w == 4 ? _indicesinrange(Ptr{UInt32}(p), d, validity, dictlen) :
+            _indicesinrange(Ptr{UInt64}(p), d, validity, dictlen)
+        end
+    end
+    return ok
+end
+
+function _indicesinrange(
+    p::Ptr{T},
+    d::ArrayData,
+    validity::BufferSlice,
+    dictlen::Int64,
+) where {T}
+    ok = true
+    if isempty_buffer(validity)
+        for i = 1:(d.len)
+            # A UInt64 above typemax(Int64) reinterprets negative and fails.
+            x =
+                T === UInt64 ? reinterpret(Int64, unsafe_load(p, i)) :
+                Int64(unsafe_load(p, i))
+            ok &= (0 <= x) & (x < dictlen)
+        end
+    else
+        for i = 1:(d.len)
+            x =
+                T === UInt64 ? reinterpret(Int64, unsafe_load(p, i)) :
+                Int64(unsafe_load(p, i))
+            ok &= !getbit(validity, _slotindex0(d, Int64(i))) | ((0 <= x) & (x < dictlen))
+        end
+    end
+    return ok
+end
+
+"""
+Semantic checks for Utf8View/BinaryView: non-null long entries must point
+inside their indicated variadic buffer, and the inline prefix MUST be a copy
+of the referenced data's first four bytes (the spec's comparison-fast-path
+contract). Null entries' bytes are unrestricted by the spec, so only valid
+slots are checked. Canonical zero-padding of short entries' unused inline
+bytes is a writer recommendation no validation tier enforces:
+`validate_full`'s canonical-form checks cover bit-packed buffers only.
+"""
+function _validate_view_values(t::ViewType, d::ArrayData)
+    d.len == 0 && return nothing
+    views = rolebuffer(d, VIEWS)
+    # One bounds check for every entry, then raw loads per row.
+    entries = subslice(views, _viewbase(d, Int64(1)), checked_mul(d.len, Int64(16)))
+    validity = validitybuffer(d)
+    GC.@preserve d begin
+        p = sliceptr(entries)
+        for i = 1:(d.len)
+            (isempty_buffer(validity) || getbit(validity, _slotindex0(d, Int64(i)))) ||
+                continue
+            e = p + 16 * (i - 1)
+            len = unsafe_load(Ptr{Int32}(e))
+            len >= 0 || throw(ValidationError("negative view length $len"))
+            len <= VIEW_INLINE_MAX && continue
+            bufidx = unsafe_load(Ptr{Int32}(e + 8))
+            off = Int64(unsafe_load(Ptr{Int32}(e + 12)))
+            data = _viewdatabuffer(d, bufidx)
+            off >= 0 || throw(ValidationError("negative view offset $off"))
+            # Both operands are 32-bit loads, so the sum cannot overflow Int64.
+            off + Int64(len) <= data.len || throw(
+                ValidationError(
+                    "view range [$off, $(off + len)) escapes data buffer $bufidx",
+                ),
+            )
+            unsafe_load(Ptr{UInt32}(e + 4)) ==
+            unsafe_load(Ptr{UInt32}(sliceptr(data) + off)) ||
+                throw(ValidationError("view prefix does not match referenced data"))
+        end
+    end
+    return nothing
+end
+
+@inline function _listview_range(t::ListViewType, d::ArrayData, i::Int64)
+    wide = t.large
+    slot = _slotindex0(d, i)
+    offs = rolebuffer(d, ELEMENT_OFFSETS)
+    sizes = rolebuffer(d, SIZES)
+    off =
+        wide ? loadat(offs, Int64, checked_mul(slot, Int64(8))) :
+        Int64(loadat(offs, Int32, checked_mul(slot, Int64(4))))
+    sz =
+        wide ? loadat(sizes, Int64, checked_mul(slot, Int64(8))) :
+        Int64(loadat(sizes, Int32, checked_mul(slot, Int64(4))))
+    return off, sz
+end
+
+"""
+Semantic checks for ListView/LargeListView. The spec's invariants bind EVERY
+slot, null included: `0 <= offsets[i]`, `0 <= sizes[i]`, and
+`offsets[i] + sizes[i] <= child length`. Out-of-order and overlapping ranges
+are legal — that is the layout's point.
+"""
+function _validate_listview_values(t::ListViewType, d::ArrayData)
+    childlen = Int64(length(d.children[1]))
+    for i = 1:(d.len)
+        off, sz = _listview_range(t, d, Int64(i))
+        (off >= 0 && sz >= 0) ||
+            throw(ValidationError("list-view offset and size must be non-negative"))
+        # Subtraction form: `off + sz` on two hostile 64-bit loads can
+        # overflow Int64 (which must read as invalid data, not a raw
+        # `OverflowError`); the message widens to Int128 so the true
+        # endpoint prints either way.
+        (off <= childlen && sz <= childlen - off) || throw(
+            ValidationError(
+                "list-view range [$off, $(Int128(off) + Int128(sz))) escapes " *
+                "child length $childlen",
+            ),
+        )
+    end
+    return nothing
+end
+
+"""
+Semantic checks for run-end encoding: a signed 16/32/64-bit run-ends child
+with no nulls, equal-length children (one value per run), run ends positive
+and strictly ascending, and the last run end covering every logical slot
+(`>= offset + length` — equality holds for unsliced arrays). The REE parent
+has no validity bitmap and its null count field is zero or the unknown
+sentinel `-1`; logical nulls live in the values child's runs. The structural
+stage has already established the run-ends descriptor (signed 16/32/64-bit),
+the equal child lengths, and the parent null count.
+"""
+function _validate_ree_values(d::ArrayData)
+    runs, values = d.children[1], d.children[2]
+    nullcount(runs) == 0 || throw(ValidationError("a run end cannot be null"))
+    total = checked_add(d.offset, d.len)
+    data = rolebuffer(runs, DATA)
+    # The typeassert re-concretizes the structurally established descriptor —
+    # without it `primwidth`/`_load_int` see `ArrowType` and the trim
+    # verifier reports unresolved calls.
+    rti = runs.type::IntType
+    w = primwidth(rti)
+    prev = Int64(0)
+    for i = 1:(runs.len)
+        re = _load_int(data, rti, _slotbyteoff(runs, Int64(i), w))
+        re > prev ||
+            throw(ValidationError("run ends must be positive and strictly ascending"))
+        prev = re
+    end
+    d.len == 0 ||
+        prev >= total ||
+        throw(ValidationError("run ends cover $prev of $total logical slots"))
+    return nothing
+end
+
+"""
+The run whose end first reaches 1-based logical position `offset + i` —
+binary search over the run-ends child, the REE random-access primitive.
+"""
+function _ree_runindex(d::ArrayData, i::Int64)
+    runs = d.children[1]
+    rt = runs.type::IntType
+    data = rolebuffer(runs, DATA)
+    w = primwidth(rt)
+    target = checked_add(d.offset, i)
+    lo, hi = Int64(1), runs.len
+    while lo < hi
+        mid = (lo + hi) >>> 1
+        re = _load_int(data, rt, _slotbyteoff(runs, mid, w))
+        re >= target ? (hi = mid) : (lo = mid + 1)
+    end
+    return lo
+end
+
+function _logical_null_at(f::Field, d::ArrayData, i::Int64)
+    t = d.type
+    t isa NullType && return true
+    if t isa RunEndEncodedType
+        run = _ree_runindex(d, i)
+        return _logical_null_at(f.children[2], d.children[2], run)
+    end
+    if t isa UnionType
+        cf, cd, childi = _union_child(f, d, i)
+        return _logical_null_at(cf, cd, childi)
+    end
+    spec = layoutspec_of(t)
+    return !isempty(spec.buffers) && spec.buffers[1] == VALIDITY && !isvalid_at(d, i)
+end
+
+function _union_child(f::Field, d::ArrayData, i::Int64)
+    t = d.type::UnionType
+    tid = loadat(rolebuffer(d, TYPE_IDS), Int8, _slotindex0(d, i))
+    pos = findfirst(==(tid), t.typeids)
+    pos === nothing && throw(ValidationError("union type id $tid not in declared domain"))
+    childi = if t.mode == DenseMode
+        off = loadat(rolebuffer(d, ELEMENT_OFFSETS), Int32, _slotbyteoff(d, i, 4))
+        checked_add(Int64(off), Int64(1))
+    else
+        checked_add(d.offset, i)
+    end
+    return f.children[pos], d.children[pos], childi
+end
+
+function _validate_field_contract_at(f::Field, d::ArrayData, i::Int64)
+    t = d.type
+    if t isa UnionType
+        if !f.nullable && _logical_null_at(f, d, i)
+            throw(
+                ValidationError(
+                    "non-nullable field $(repr(f.name)) contains a null at element $i",
+                ),
+            )
+        end
+        # A union has no parent validity bitmap. Its selected child supplies
+        # both the value and any logical null, so validate that child even
+        # when the union Field itself permits nulls. Unselected child slots
+        # are not part of this selected union value and must remain ignored.
+        cf, cd, childi = _union_child(f, d, i)
+        _validate_field_contract_at(cf, cd, childi)
+        return nothing
+    end
+    if t isa RunEndEncodedType
+        # Same bitmap-less shape as unions: the selected VALUES run supplies
+        # the value and any logical null. The runs child was already checked
+        # whole (no nulls, ascending) by the intrinsic stage.
+        if !f.nullable && _logical_null_at(f, d, i)
+            throw(
+                ValidationError(
+                    "non-nullable field $(repr(f.name)) contains a null at element $i",
+                ),
+            )
+        end
+        _validate_field_contract_at(f.children[2], d.children[2], _ree_runindex(d, i))
+        return nothing
+    end
+
+    slotnull = t isa NullType || !isvalid_at(d, i)
+    if slotnull
+        f.nullable || throw(
+            ValidationError(
+                "non-nullable field $(repr(f.name)) contains a null at element $i",
+            ),
+        )
+        # Child storage below a null parent value is unspecified. In
+        # particular, null Struct/FixedSizeList slots and null List/Map
+        # ranges mask nulls in otherwise non-nullable child Fields.
+        return nothing
+    end
+
+    if t isa StructType
+        childi = checked_add(d.offset, i)
+        for (cf, cd) in zip(f.children, d.children)
+            _validate_field_contract_at(cf, cd, childi)
+        end
+    elseif t isa FixedSizeListType
+        base = checked_mul(_slotindex0(d, i), Int64(t.listsize))
+        cf, cd = f.children[1], d.children[1]
+        for j = 1:(t.listsize)
+            _validate_field_contract_at(cf, cd, checked_add(base, Int64(j)))
+        end
+    elseif t isa Union{ListType,MapType}
+        lo, hi = _offsets_at(d, i, layoutspec(t).offsetwidth == 8)
+        lo == hi && return nothing
+        cf, cd = f.children[1], d.children[1]
+        for childi = checked_add(lo, Int64(1)):hi
+            _validate_field_contract_at(cf, cd, childi)
+        end
+    elseif t isa ListViewType
+        off, sz = _listview_range(t, d, i)
+        sz == 0 && return nothing
+        cf, cd = f.children[1], d.children[1]
+        for childi = checked_add(off, Int64(1)):checked_add(off, sz)
+            _validate_field_contract_at(cf, cd, childi)
+        end
+    end
+    return nothing
+end
+
+function _validate_dictionary_contracts(
+    f::Field,
+    d::ArrayData,
+    validated_dictionaries::Union{Nothing,_ValidatedDictionaries},
+)
+    if d.type isa DictionaryType
+        # Dictionary values form an independent array. Index nullability never
+        # constrains pool nullability, but nested Field contracts inside the
+        # pool still apply to every pool value, even when the dictionary array
+        # itself is nested below a masked parent.
+        dictionary = d.dictionary::ArrayData
+        _dictionary_validated(validated_dictionaries, dictionary) ||
+            _validate_field_contracts(
+                dictvaluefield(f, d.type),
+                dictionary,
+                validated_dictionaries,
+            )
+    end
+    for (cf, cd) in zip(f.children, d.children)
+        _validate_dictionary_contracts(cf, cd, validated_dictionaries)
+    end
+    return nothing
+end
+
+# `Field.nullable` is ADVISORY schema metadata in the ecosystem: the
+# reference C++ implementation neither enforces it on read nor rejects a
+# non-nullable field whose data holds nulls, and the apache/arrow-testing
+# gold corpus carries exactly that (a `nullable=false` union whose selected
+# child is null). The semantic stage therefore validates only the
+# structurally-load-bearing dictionary contracts; the per-slot nullability
+# walk (`_validate_field_contract_at`) runs in the opt-in `validate_full`
+# tier for callers who want the declaration enforced.
+function _validate_field_contracts(
+    f::Field,
+    d::ArrayData,
+    validated_dictionaries::Union{Nothing,_ValidatedDictionaries},
+)
+    _validate_dictionary_contracts(f, d, validated_dictionaries)
+    return nothing
+end
+
+function _validate_nullability(f::Field, d::ArrayData)
+    for i = 1:(d.len)
+        _validate_field_contract_at(f, d, Int64(i))
+    end
+    # Dictionary pools are independent arrays: their nested Field contracts
+    # apply to every pool value regardless of which indices reference them
+    # (and regardless of masking above the dictionary array), so each pool
+    # gets its own root walk.
+    _validate_pool_nullability(f, d)
+    return nothing
+end
+
+function _validate_pool_nullability(f::Field, d::ArrayData)
+    if d.type isa DictionaryType
+        _validate_nullability(dictvaluefield(f, d.type), d.dictionary::ArrayData)
+    end
+    for (cf, cd) in zip(f.children, d.children)
+        _validate_pool_nullability(cf, cd)
+    end
+    return nothing
+end
+
+"""
+    validate_full(field, data)
+
+Stage-4 (opt-in) content validation. It composes semantic (and therefore
+structural) validation before the more expensive whole-content checks.
+"""
+function validate_full(f::Field, d::ArrayData)
+    validate_semantic(f, d)
+    # The nullability walk enters ONCE at the root: it routes through
+    # unions/REE and applies parent-null masking itself, so recursing it per
+    # child would flag masked slots that are not part of any public-domain value.
+    _validate_nullability(f, d)
+    _validate_full_content(f, d)
+    return d
+end
+
+# Canonical bit-packed form: the spec recommends writers zero the unused
+# trailing bits of the final byte and any padding bytes, and forbids readers
+# from relying on either — so enforcement is full-tier only. Sliced arrays
+# are exempt: trailing bits inside a shared bitmap window can legitimately
+# belong to a sibling slice.
+function _validate_canonical_bits(d::ArrayData)
+    d.offset == 0 && d.len > 0 || return nothing
+    spec = layoutspec_of(d.type)
+    for (idx, role) in enumerate(spec.buffers)
+        role == VALIDITY || (role == DATA && d.type isa BoolType) || continue
+        b = d.buffers[idx]
+        nbytes = Int64(cld(d.len, 8))
+        # Absent or short bitmaps are the structural tier's concern.
+        b.len >= nbytes || continue
+        tail = d.len % 8
+        if tail != 0
+            mask = UInt8(0xff) << tail
+            loadat(b, UInt8, nbytes - 1) & mask == 0x00 || throw(
+                ValidationError(
+                    "canonical form requires zeroed unused bits in the final " *
+                    "byte of a bit-packed buffer",
+                ),
+            )
+        end
+        for i = nbytes:(b.len - 1)
+            loadat(b, UInt8, i) == 0x00 || throw(
+                ValidationError(
+                    "canonical form requires zeroed padding in bit-packed buffers",
+                ),
+            )
+        end
+    end
+    return nothing
+end
+
+# Closed-set ladder over the three advisory-check descriptors (same
+# devirtualization story as layoutspec_of).
+@inline function _validate_advisory_values_of(d::ArrayData)
+    t = d.type
+    t isa DateType && return _validate_advisory_values(t, d)
+    t isa TimeType && return _validate_advisory_values(t, d)
+    t isa DecimalType && return _validate_advisory_values(t, d)
+    return nothing
+end
+
+function _validate_full_content(f::Field, d::ArrayData)
+    _validate_advisory_values_of(d)
+    _validate_canonical_bits(d)
+    if d.type isa Utf8Type || (d.type isa ViewType && d.type.utf8)
+        for i = 1:(d.len)
+            isvalid_at(d, i) || continue
+            s = getvalue(f, d, i)::String
+            # A malformed byte sequence iterates as invalid Chars; checking
+            # every Char is the stdlib idiom for whole-string validity.
+            all(isvalid, s) || throw(ValidationError("invalid UTF-8 at element $i"))
+        end
+    end
+    for (cf, cd) in zip(childfields(f), d.children)
+        _validate_full_content(cf, cd)
+    end
+    if d.type isa DictionaryType
+        _validate_full_content(dictvaluefield(f, d.type), d.dictionary)
+    end
+    return nothing
+end
+
+# ---------------------------------------------------------------------------
+# §6 Element access (per-layout semantics; the facade's raw material)
+# ---------------------------------------------------------------------------
+
+# Julia storage type for each descriptor: what getvalue returns for valid
+# elements. Timestamps etc. return their raw storage integers here — the
+# *facade* owns the Dates conversion layer; keeping Core conversion-free is
+# what lets the C-data and IPC adapters share it unchanged.
+juliatype(::BoolType) = Bool
+juliatype(t::IntType) =
+    t.signed ?
+    (
+        t.bits == 8 ? Int8 :
+        t.bits == 16 ? Int16 : t.bits == 32 ? Int32 : t.bits == 128 ? Int128 : Int64
+    ) :
+    (
+        t.bits == 8 ? UInt8 :
+        t.bits == 16 ? UInt16 : t.bits == 32 ? UInt32 : t.bits == 128 ? UInt128 : UInt64
+    )
+juliatype(t::FloatType) = t.bits == 16 ? Float16 : t.bits == 32 ? Float32 : Float64
+juliatype(::TimestampType) = Int64
+juliatype(::DurationType) = Int64
+juliatype(t::DateType) = t.unit == DAY ? Int32 : Int64
+juliatype(t::TimeType) = t.bits == 32 ? Int32 : Int64
+juliatype(::Utf8Type) = String
+juliatype(::BinaryType) = Vector{UInt8}
+juliatype(t::FixedSizeBinaryType) = Vector{UInt8}
+juliatype(t::ViewType) = t.utf8 ? String : Vector{UInt8}
+juliatype(t::DecimalType) = t.bits == 32 ? Int32 : t.bits == 64 ? Int64 : Vector{UInt8}
+juliatype(t::IntervalType) =
+    t.unit == YEAR_MONTH ? Int32 :
+    t.unit == DAY_TIME ? NamedTuple{(:days, :millis),Tuple{Int32,Int32}} :
+    NamedTuple{(:months, :days, :nanos),Tuple{Int32,Int32,Int64}}
+juliatype(::StructType) = Vector{Pair{String,Any}}
+juliatype(::MapType) = Vector{Pair{Any,Any}}
+
+@inline function _load_int(b::BufferSlice, t::IntType, byteoff::Int64)::Int64
+    # Literal load widths avoid a runtime DataType in the raw-load path, which
+    # produces code that the trim verifier cannot resolve.
+    if t.signed
+        t.bits == 64 && return loadat(b, Int64, byteoff)
+        t.bits == 32 && return Int64(loadat(b, Int32, byteoff))
+        t.bits == 16 && return Int64(loadat(b, Int16, byteoff))
+        return Int64(loadat(b, Int8, byteoff))
+    else
+        if t.bits == 64
+            u = loadat(b, UInt64, byteoff)
+            # Explicit range check: a stored UInt64 above typemax(Int64) is
+            # out of domain for every Int64-typed consumer (dictionary
+            # lengths and run ends are Int64), and a bare `Int64(u)` would
+            # leak an `InexactError` through the validation tier.
+            u <= UInt64(typemax(Int64)) ||
+                throw(ValidationError("unsigned 64-bit value $u exceeds the Int64 range"))
+            return Int64(u)
+        end
+        t.bits == 32 && return Int64(loadat(b, UInt32, byteoff))
+        t.bits == 16 && return Int64(loadat(b, UInt16, byteoff))
+        return Int64(loadat(b, UInt8, byteoff))
+    end
+end
+
+"""
+    getvalue(field, data, i) -> Union{Missing, value}
+
+Read logical element `i` (1-based). Layout dispatch is the closed-set `isa`
+ladder over the runtime descriptor — a type-test chain per call, not a
+dynamic dispatch. This is Core's honest contract:
+scalar access through the erased representation pays a boundary cost;
+`materialize` resolves the layout once and loops through a function
+barrier.
+"""
+function getvalue(f::Field, d::ArrayData, i::Integer)
+    1 <= i <= d.len || throw(BoundsError(d, i))
+    return _value_of(d.type, f, d, Int64(i))
+end
+
+# Reader adapters can attach one cumulative allocation budget without making
+# the dependency-free Core know the adapter's budget type. The ordinary
+# methods below remain the trim-safe API. Budgeted overloads only preflight
+# package-owned output containers, then call the same audited extraction.
+function _charge_materialization! end
+function _materialization_remaining end
+function _materialization_limit_exceeded! end
+
+@inline function _materializedvectorbytes(::Type{T}, n::Integer) where {T}
+    n >= 0 || throw(ValidationError("materialized vector length is negative"))
+    payload = checked_mul(Int64(n), Int64(Base.elsize(Vector{T})))
+    # Julia stores one selector byte per element beside an isbits-Union
+    # vector's ordinary payload.
+    Base.isbitsunion(T) && (payload = checked_add(payload, Int64(n)))
+    # Supported Julia runtimes allocate at most one 64-byte object for an
+    # empty Vector after warm-up. Charging the nonempty 128-byte header model
+    # per empty nested value rejects compact Arrow columns by hundreds of
+    # megabytes even though their materialized empty containers are small.
+    payload == 0 && return Int64(64)
+    # Julia 1.11's `Memory` backing store may round a just-over-half-full
+    # allocation to the next size class. The measured worst case approaches
+    # twice the requested payload. Reserve that full capacity plus both the
+    # Vector and Memory headers; using the logical payload alone can let one
+    # package-owned allocation exceed the caller's budget by almost 2x.
+    capacity = checked_mul(Int64(2), payload)
+    return checked_add(Int64(128), capacity)
+end
+
+# Conservative Julia heap-object size for a newly boxed inline value: an
+# 8-byte object tag plus the payload, rounded to the 16-byte GC size class.
+@inline function _materializedobjectbytes(payload::Integer)
+    payload >= 0 || throw(ValidationError("materialized object size is negative"))
+    total = checked_add(Int64(payload), Int64(8))
+    return checked_mul(Int64(16), cld(total, Int64(16)))
+end
+
+mutable struct _MaterializationEstimate{B}
+    budget::B
+    bytes::Int64
+    limit::Int64
+end
+
+_MaterializationEstimate(budget) =
+    _MaterializationEstimate(budget, Int64(0), _materialization_remaining(budget))
+
+@inline function _addestimate!(
+    estimate::_MaterializationEstimate,
+    amount::Int64,
+    what::AbstractString,
+)
+    amount >= 0 || throw(ValidationError("materialization estimate is negative"))
+    amount <= estimate.limit - estimate.bytes ||
+        _materialization_limit_exceeded!(estimate.budget, what)
+    estimate.bytes += amount
+    return nothing
+end
+
+@inline _reservevector!(
+    estimate::_MaterializationEstimate,
+    ::Type{T},
+    n::Integer,
+    what::AbstractString,
+) where {T} = _addestimate!(estimate, _materializedvectorbytes(T, n), what)
+
+@inline _reserveobject!(
+    estimate::_MaterializationEstimate,
+    payload::Integer,
+    what::AbstractString,
+) = _addestimate!(estimate, _materializedobjectbytes(payload), what)
+
+@inline function _commitestimate!(estimate::_MaterializationEstimate, what::AbstractString)
+    _charge_materialization!(estimate.budget, estimate.bytes, what)
+    return nothing
+end
+
+_value(::Any, ::Field, ::ArrayData, ::Int64) =
+    throw(ArgumentError("unregistered ArrowType"))
+
+# -- primitives -------------------------------------------------------------
+
+# Primitive accessors branch to LITERAL load widths: `loadat(b, T, off)` with
+# a runtime `T::DataType` leaves the raw-load path unresolved under trim
+# verification, and a concrete branch is faster anyway.
+function _value(t::IntType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    b = rolebuffer(d, DATA)
+    if t.signed
+        t.bits == 64 && return loadat(b, Int64, _slotbyteoff(d, i, 8))
+        t.bits == 32 && return loadat(b, Int32, _slotbyteoff(d, i, 4))
+        t.bits == 16 && return loadat(b, Int16, _slotbyteoff(d, i, 2))
+        t.bits == 128 && return loadat(b, Int128, _slotbyteoff(d, i, 16))
+        return loadat(b, Int8, _slotbyteoff(d, i, 1))
+    else
+        t.bits == 64 && return loadat(b, UInt64, _slotbyteoff(d, i, 8))
+        t.bits == 32 && return loadat(b, UInt32, _slotbyteoff(d, i, 4))
+        t.bits == 16 && return loadat(b, UInt16, _slotbyteoff(d, i, 2))
+        t.bits == 128 && return loadat(b, UInt128, _slotbyteoff(d, i, 16))
+        return loadat(b, UInt8, _slotbyteoff(d, i, 1))
+    end
+end
+
+function _value(t::FloatType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    b = rolebuffer(d, DATA)
+    t.bits == 64 && return loadat(b, Float64, _slotbyteoff(d, i, 8))
+    t.bits == 32 && return loadat(b, Float32, _slotbyteoff(d, i, 4))
+    return loadat(b, Float16, _slotbyteoff(d, i, 2))
+end
+
+function _value(t::Union{TimestampType,DurationType}, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    return loadat(rolebuffer(d, DATA), Int64, _slotbyteoff(d, i, 8))
+end
+
+function _value(t::DateType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    b = rolebuffer(d, DATA)
+    return t.unit == DAY ? loadat(b, Int32, _slotbyteoff(d, i, 4)) :
+           loadat(b, Int64, _slotbyteoff(d, i, 8))
+end
+
+function _value(t::TimeType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    b = rolebuffer(d, DATA)
+    return t.bits == 32 ? loadat(b, Int32, _slotbyteoff(d, i, 4)) :
+           loadat(b, Int64, _slotbyteoff(d, i, 8))
+end
+
+function _value(t::DecimalType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    w = primwidth(t)
+    # 128/256-bit decimals surface as raw native-endian bytes (BigInt/Int256
+    # conversion is the facade's); 32/64 as integers. Core RecordBatches
+    # accept native-endian buffers only.
+    if t.bits == 32
+        return loadat(rolebuffer(d, DATA), Int32, _slotbyteoff(d, i, w))
+    elseif t.bits == 64
+        return loadat(rolebuffer(d, DATA), Int64, _slotbyteoff(d, i, w))
+    else
+        b = rolebuffer(d, DATA)
+        off = _slotbyteoff(d, i, w)
+        return [loadat(b, UInt8, checked_add(off, Int64(k))) for k = 0:(w - 1)]
+    end
+end
+
+function _value(t::IntervalType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    b = rolebuffer(d, DATA)
+    if t.unit == YEAR_MONTH
+        return loadat(b, Int32, _slotbyteoff(d, i, 4))
+    elseif t.unit == DAY_TIME
+        off = _slotbyteoff(d, i, 8)
+        return (
+            days=loadat(b, Int32, off),
+            millis=loadat(b, Int32, checked_add(off, Int64(4))),
+        )
+    else # MONTH_DAY_NANO
+        off = _slotbyteoff(d, i, 16)
+        return (
+            months=loadat(b, Int32, off),
+            days=loadat(b, Int32, checked_add(off, Int64(4))),
+            nanos=loadat(b, Int64, checked_add(off, Int64(8))),
+        )
+    end
+end
+
+function _value(::BoolType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    return getbit(rolebuffer(d, DATA), _slotindex0(d, i))
+end
+
+function _value(::NullType, f::Field, d::ArrayData, i::Int64)
+    return missing
+end
+
+function _value(t::FixedSizeBinaryType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    b = rolebuffer(d, DATA)
+    off = _slotbyteoff(d, i, t.nbytes)
+    return slicebytes(subslice(b, off, t.nbytes))
+end
+
+# -- varbinary --------------------------------------------------------------
+
+"Concrete-width offset load: `idx0` is the 0-based entry index."
+@inline function _load_offset(offs::BufferSlice, wide::Bool, idx0::Int64)::Int64
+    return wide ? loadat(offs, Int64, checked_mul(idx0, Int64(8))) :
+           Int64(loadat(offs, Int32, checked_mul(idx0, Int64(4))))
+end
+
+"""
+The last of the `n + 1` offsets that start at 0-based entry `start0` of
+`offs`, after checking that they never decrease. One bounds check covers the
+window, and the check runs branch-free so it vectorizes.
+"""
+function _monotonicoffsets(offs::BufferSlice, wide::Bool, start0::Int64, n::Int64)::Int64
+    w = wide ? Int64(8) : Int64(4)
+    first = checked_mul(start0, w)
+    span = checked_mul(checked_add(n, Int64(1)), w)
+    (first >= 0 && span <= offs.len && first <= offs.len - span) ||
+        throw(BoundsError(offs, checked_add(start0, n)))
+    last = GC.@preserve offs begin
+        p = sliceptr(offs) + first
+        wide ? _monotonic(Ptr{Int64}(p), n) : _monotonic(Ptr{Int32}(p), n)
+    end
+    return last
+end
+
+function _monotonic(p::Ptr{T}, n::Int64)::Int64 where {T}
+    ok = true
+    for i = 1:n
+        ok &= unsafe_load(p, i) <= unsafe_load(p, i + 1)
+    end
+    if !ok
+        for i = 1:n
+            unsafe_load(p, i) <= unsafe_load(p, i + 1) ||
+                throw(ValidationError("offsets not monotonically non-decreasing at $i"))
+        end
+    end
+    return Int64(unsafe_load(p, n + 1))
+end
+
+@inline function _offsets_at(d::ArrayData, i::Int64, wide::Bool)
+    offs = rolebuffer(d, OFFSETS)
+    lo = _load_offset(offs, wide, d.offset + i - 1)
+    hi = _load_offset(offs, wide, d.offset + i)
+    return lo, hi
+end
+
+function _value(t::Union{Utf8Type,BinaryType}, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    lo, hi = _offsets_at(d, i, layoutspec(t).offsetwidth == 8)
+    data = rolebuffer(d, DATA)
+    n = hi - lo
+    n == 0 && return t isa Utf8Type ? "" : UInt8[]
+    # Semantic validation bounded final offsets against the data extent, but
+    # subslice re-checks: accessors stay safe even when a caller skipped
+    # validate_semantic (they just pay per-access checking).
+    bytes = slicebytes(subslice(data, lo, n))
+    return t isa Utf8Type ? String(bytes) : bytes
+end
+
+# -- nested -----------------------------------------------------------------
+
+# Dynamic recursion mirrors `_typedchild`: scalar children inline into their
+# parent's loop, while composite children cross one compiled function barrier.
+# Calling public `getvalue` for every scalar child allocates a dispatch box per
+# element; recursively inlining every composite instead breaks trim inference.
+@inline function _dynamicchild(f::Field, d::ArrayData, i::Int64)
+    1 <= i <= d.len || throw(BoundsError(d, i))
+    t = d.type
+    t isa IntType && return _value(t, f, d, i)
+    t isa FloatType && return _value(t, f, d, i)
+    t isa BoolType && return _value(t, f, d, i)
+    t isa Utf8Type && return _value(t, f, d, i)
+    t isa BinaryType && return _value(t, f, d, i)
+    t isa FixedSizeBinaryType && return _value(t, f, d, i)
+    t isa TimestampType && return _value(t, f, d, i)
+    t isa DateType && return _value(t, f, d, i)
+    t isa TimeType && return _value(t, f, d, i)
+    t isa DurationType && return _value(t, f, d, i)
+    t isa DecimalType && return _value(t, f, d, i)
+    t isa IntervalType && return _value(t, f, d, i)
+    t isa ViewType && return _value(t, f, d, i)
+    t isa NullType && return _value(t, f, d, i)
+    return _dynamicchildbox(f, d, i)
+end
+
+function _dynamicchildbox(f::Field, d::ArrayData, i::Int64)
+    return _value_of(d.type, f, d, i)
+end
+
+function _value(t::ListType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    lo, hi = _offsets_at(d, i, layoutspec(t).offsetwidth == 8)
+    child, cf = d.children[1], f.children[1]
+    # Explicit Vector{Any}: an Any-first comprehension re-narrows its result
+    # at runtime, which is both trim-hostile and wasted work — typed element
+    # containers are the facade's job.
+    out = Vector{Any}(undef, Int(hi - lo))
+    for k = 1:Int(hi - lo)
+        out[k] = _dynamicchild(cf, child, checked_add(lo, Int64(k)))
+    end
+    return out
+end
+
+function _value(t::FixedSizeListType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    child, cf = d.children[1], f.children[1]
+    base = checked_mul(_slotindex0(d, i), Int64(t.listsize))
+    out = Vector{Any}(undef, t.listsize)
+    for j = 1:(t.listsize)
+        out[j] = _dynamicchild(cf, child, checked_add(base, Int64(j)))
+    end
+    return out
+end
+
+function _value(::StructType, f::Field, d::ArrayData, i::Int64)
+    # Core's struct scalar is an ordered Vector{Pair{String,Any}} — always.
+    # A NamedTuple carries its names in the TYPE domain, so building one from
+    # runtime schema names is intrinsically dynamic (and cannot represent
+    # Arrow's duplicate/empty/non-Symbol names at all). The typed NamedTuple
+    # surface belongs to the facade and to callers' static claims through
+    # `getvalue(::Type{T}, ...)`; Core stays concrete and trim-clean.
+    isvalid_at(d, i) || return missing
+    childindex = checked_add(d.offset, i)
+    n = length(f.children)
+    out = Vector{Pair{String,Any}}(undef, n)
+    for j = 1:n
+        out[j] = Pair{String,Any}(
+            f.children[j].name,
+            _dynamicchild(f.children[j], d.children[j], childindex),
+        )
+    end
+    return out
+end
+
+function _value(t::MapType, f::Field, d::ArrayData, i::Int64)
+    # Map = List<Struct<key,value>>; reuse the list walk and pair up.
+    isvalid_at(d, i) || return missing
+    lo, hi = _offsets_at(d, i, false)
+    entries, ef = d.children[1], f.children[1]
+    kf, vf = ef.children[1], ef.children[2]
+    kd, vd = entries.children[1], entries.children[2]
+    out = Vector{Pair{Any,Any}}(undef, Int(hi - lo))
+    for k = 1:Int(hi - lo)
+        entryindex = checked_add(entries.offset, checked_add(lo, Int64(k)))
+        out[k] = Pair{Any,Any}(
+            _dynamicchild(kf, kd, entryindex),
+            _dynamicchild(vf, vd, entryindex),
+        )
+    end
+    return out
+end
+
+function _value(t::UnionType, f::Field, d::ArrayData, i::Int64)
+    tid = loadat(rolebuffer(d, TYPE_IDS), Int8, _slotindex0(d, i))
+    pos = findfirst(==(tid), t.typeids)
+    pos === nothing && throw(ValidationError("union type id $tid not in declared domain"))
+    child, cf = d.children[pos], f.children[pos]
+    if t.mode == DenseMode
+        off = loadat(rolebuffer(d, ELEMENT_OFFSETS), Int32, _slotbyteoff(d, i, 4))
+        return _dynamicchild(cf, child, checked_add(Int64(off), Int64(1)))
+    else
+        return _dynamicchild(cf, child, checked_add(d.offset, i))
+    end
+end
+
+function _value(t::DictionaryType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    w = primwidth(t.indextype)
+    idx = _load_int(rolebuffer(d, DATA), t.indextype, _slotbyteoff(d, i, w))
+    dict = d.dictionary
+    dict === nothing &&
+        throw(ValidationError("dictionary-encoded array without a dictionary"))
+    return _dynamicchild(dictvaluefield(f, t), dict, checked_add(Int64(idx), Int64(1)))
+end
+
+function _value(t::ViewType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    views = rolebuffer(d, VIEWS)
+    base = _viewbase(d, i)
+    len = loadat(views, Int32, base)
+    len >= 0 || throw(ValidationError("negative view length $len"))
+    n = Int64(len)
+    # Semantic validation certified geometry and prefixes; subslice re-checks
+    # bounds so unvalidated access still cannot escape a buffer.
+    bytes = if len <= VIEW_INLINE_MAX
+        slicebytes(subslice(views, checked_add(base, Int64(4)), n))
+    else
+        bufidx = loadat(views, Int32, checked_add(base, Int64(8)))
+        off = Int64(loadat(views, Int32, checked_add(base, Int64(12))))
+        off >= 0 || throw(ValidationError("negative view offset $off"))
+        slicebytes(subslice(_viewdatabuffer(d, bufidx), off, n))
+    end
+    return t.utf8 ? String(bytes) : bytes
+end
+
+function _value(t::ListViewType, f::Field, d::ArrayData, i::Int64)
+    isvalid_at(d, i) || return missing
+    off, sz = _listview_range(t, d, i)
+    (off >= 0 && sz >= 0) ||
+        throw(ValidationError("list-view offset and size must be non-negative"))
+    child, cf = d.children[1], f.children[1]
+    out = Vector{Any}(undef, Int(sz))
+    for k = 1:Int(sz)
+        out[k] = _dynamicchild(cf, child, checked_add(off, Int64(k)))
+    end
+    return out
+end
+
+_value(::RunEndEncodedType, f::Field, d::ArrayData, i::Int64) =
+    _dynamicchild(f.children[2], d.children[2], _ree_runindex(d, i))
+
+# Preflight the containers allocated by one dynamic Core value. This walk uses
+# only validated offsets and scalar buffer loads. In particular, a hostile
+# FixedSizeList width is charged before the child loop starts.
+function _prechargevalue!(
+    ::Type{T},
+    t::Union{IntType,FloatType},
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    T === Any && _reserveobject!(estimate, primwidth(t), "boxed numeric value")
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    ::Union{TimestampType,DurationType},
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    T === Any && _reserveobject!(estimate, 8, "boxed temporal value")
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    t::DateType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    T === Any && _reserveobject!(estimate, t.unit == DAY ? 4 : 8, "boxed date value")
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    t::TimeType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    T === Any && _reserveobject!(estimate, t.bits == 32 ? 4 : 8, "boxed time value")
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    t::IntervalType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    payload = t.unit == YEAR_MONTH ? 4 : t.unit == DAY_TIME ? 8 : 16
+    T === Any && _reserveobject!(estimate, payload, "boxed interval value")
+    return nothing
+end
+
+_prechargevalue!(
+    ::Type,
+    ::Union{BoolType,NullType},
+    ::Field,
+    ::ArrayData,
+    ::Int64,
+    estimate,
+) = nothing
+
+function _prechargevalue!(
+    ::Type{T},
+    t::DecimalType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    if t.bits > 64
+        _reservevector!(estimate, UInt8, primwidth(t), "decimal value")
+    elseif T === Any
+        _reserveobject!(estimate, primwidth(t), "boxed decimal value")
+    end
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type,
+    t::FixedSizeBinaryType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+)
+    isvalid_at(d, i) || return nothing
+    _reservevector!(estimate, UInt8, t.nbytes, "fixed-size binary value")
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type,
+    t::Union{Utf8Type,BinaryType},
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+)
+    isvalid_at(d, i) || return nothing
+    lo, hi = _offsets_at(d, i, layoutspec(t).offsetwidth == 8)
+    # `_value` returns Base's singleton empty String without allocating. Keep
+    # that exact fast path out of the per-value reserve. Empty Binary values
+    # still allocate a fresh UInt8 vector and remain charged below.
+    t isa Utf8Type && hi == lo && return nothing
+    _reservevector!(estimate, UInt8, hi - lo, "binary value")
+    return nothing
+end
+
+function _prechargevalue!(::Type, t::ViewType, f::Field, d::ArrayData, i::Int64, estimate)
+    isvalid_at(d, i) || return nothing
+    len = loadat(rolebuffer(d, VIEWS), Int32, _viewbase(d, i))
+    len >= 0 || throw(ValidationError("negative view length $len"))
+    _reservevector!(estimate, UInt8, len, "view value")
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    t::ListType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    lo, hi = _offsets_at(d, i, layoutspec(t).offsetwidth == 8)
+    _prechargelist!(T, f, d, lo, hi - lo, estimate)
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    t::ListViewType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    off, n = _listview_range(t, d, i)
+    (off >= 0 && n >= 0) ||
+        throw(ValidationError("list-view offset and size must be non-negative"))
+    _prechargelist!(T, f, d, off, n, estimate)
+    return nothing
+end
+
+function _prechargelist!(
+    ::Type{T},
+    f::Field,
+    d::ArrayData,
+    off::Int64,
+    n::Int64,
+    estimate,
+) where {T}
+    child, cf = d.children[1], f.children[1]
+    if T === Any
+        _reservevector!(estimate, Any, n, "list value")
+        for k = 1:Int(n)
+            _prechargechild!(Any, cf, child, checked_add(off, Int64(k)), estimate)
+        end
+    else
+        CE = eltype(Base.nonmissingtype(T))
+        _reservevector!(estimate, CE, n, "typed list value")
+        for k = 1:Int(n)
+            _prechargechild!(CE, cf, child, checked_add(off, Int64(k)), estimate)
+        end
+    end
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    t::FixedSizeListType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    child, cf = d.children[1], f.children[1]
+    base = checked_mul(_slotindex0(d, i), Int64(t.listsize))
+    if T === Any
+        CE = Any
+        _reservevector!(estimate, CE, t.listsize, "fixed-size list value")
+    else
+        CE = eltype(Base.nonmissingtype(T))
+        _reservevector!(estimate, CE, t.listsize, "typed fixed-size list value")
+    end
+    for k = 1:(t.listsize)
+        _prechargechild!(CE, cf, child, checked_add(base, Int64(k)), estimate)
+    end
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    ::StructType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    E = T === Any ? Any : Base.nonmissingtype(T)
+    childindex = checked_add(d.offset, i)
+    if E === Any || E === Vector{Pair{String,Any}}
+        _reservevector!(estimate, Pair{String,Any}, length(f.children), "struct value")
+        for k in eachindex(f.children)
+            _prechargechild!(Any, f.children[k], d.children[k], childindex, estimate)
+        end
+        return nothing
+    end
+    E <: NamedTuple || return nothing
+    Base.allocatedinline(T) ||
+        _reserveobject!(estimate, sizeof(E), "boxed typed struct value")
+    _prechargetypedstruct!(E, f, d, childindex, estimate)
+    return nothing
+end
+
+@generated function _prechargetypedstruct!(
+    ::Type{E},
+    f::Field,
+    d::ArrayData,
+    childindex::Int64,
+    estimate,
+) where {E<:NamedTuple}
+    calls = Expr[
+        :(_prechargechild!(
+            $(fieldtype(E, j)),
+            f.children[$j],
+            d.children[$j],
+            childindex,
+            estimate,
+        )) for j = 1:fieldcount(E)
+    ]
+    return quote
+        $(calls...)
+        return nothing
+    end
+end
+
+function _prechargevalue!(::Type, t::MapType, f::Field, d::ArrayData, i::Int64, estimate)
+    isvalid_at(d, i) || return nothing
+    lo, hi = _offsets_at(d, i, false)
+    _reservevector!(estimate, Pair{Any,Any}, hi - lo, "map value")
+    entries, ef = d.children[1], f.children[1]
+    for k = 1:Int(hi - lo)
+        entryindex = checked_add(entries.offset, checked_add(lo, Int64(k)))
+        for j = 1:2
+            _prechargechild!(Any, ef.children[j], entries.children[j], entryindex, estimate)
+        end
+    end
+    return nothing
+end
+
+function _prechargevalue!(::Type, t::UnionType, f::Field, d::ArrayData, i::Int64, estimate)
+    cf, child, childindex = _union_child(f, d, i)
+    _prechargechild!(Any, cf, child, childindex, estimate)
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    t::DictionaryType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    isvalid_at(d, i) || return nothing
+    w = primwidth(t.indextype)
+    index = _load_int(rolebuffer(d, DATA), t.indextype, _slotbyteoff(d, i, w))
+    dictionary = d.dictionary
+    dictionary === nothing &&
+        throw(ValidationError("dictionary-encoded array without a dictionary"))
+    _prechargechild!(
+        T,
+        dictvaluefield(f, t),
+        dictionary,
+        checked_add(Int64(index), Int64(1)),
+        estimate,
+    )
+    return nothing
+end
+
+function _prechargevalue!(
+    ::Type{T},
+    ::RunEndEncodedType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    _prechargechild!(T, f.children[2], d.children[2], _ree_runindex(d, i), estimate)
+    return nothing
+end
+
+_prechargevalue!(::Type, ::ArrowType, ::Field, ::ArrayData, ::Int64, estimate) = nothing
+
+# Like the value path, preflight keeps leaves inline and gives recursive
+# composites one concrete compiled edge. The walk itself must not create an
+# uncharged dispatch allocation for every child it inspects.
+@inline function _prechargechild!(
+    ::Type{T},
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    1 <= i <= d.len || throw(BoundsError(d, i))
+    t = d.type
+    t isa IntType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa FloatType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa BoolType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa Utf8Type && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa BinaryType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa FixedSizeBinaryType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa TimestampType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa DateType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa TimeType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa DurationType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa DecimalType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa IntervalType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa ViewType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa NullType && return _prechargevalue!(T, t, f, d, i, estimate)
+    return _prechargechildbox!(T, f, d, i, estimate)
+end
+
+function _prechargechildbox!(
+    ::Type{T},
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    return _prechargevalue_of!(T, d.type, f, d, i, estimate)
+end
+
+@inline function _prechargevalue_of!(
+    ::Type{T},
+    t::ArrowType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+    estimate,
+) where {T}
+    t isa IntType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa FloatType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa Utf8Type && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa BoolType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa ListType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa StructType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa DictionaryType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa TimestampType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa DateType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa TimeType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa DurationType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa BinaryType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa FixedSizeBinaryType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa FixedSizeListType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa MapType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa UnionType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa DecimalType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa IntervalType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa NullType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa ViewType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa ListViewType && return _prechargevalue!(T, t, f, d, i, estimate)
+    t isa RunEndEncodedType && return _prechargevalue!(T, t, f, d, i, estimate)
+    return _prechargevalue!(T, t, f, d, i, estimate)
+end
+
+function getvalue(f::Field, d::ArrayData, i::Integer, budget)
+    1 <= i <= d.len || throw(BoundsError(d, i))
+    estimate = _MaterializationEstimate(budget)
+    _prechargevalue_of!(Any, d.type, f, d, Int64(i), estimate)
+    _commitestimate!(estimate, "materialized value")
+    return _value_of(d.type, f, d, Int64(i))
+end
+
+"""
+    materialize(field, data) -> Vector
+
+Bulk conversion to native Julia values: resolve the layout ONCE, then run
+a specialized loop behind a function barrier — the loop body compiles per
+LAYOUT (a small closed set), never per schema.
+"""
+materialize(f::Field, d::ArrayData) = _materialize_of(d.type, f, d)
+
+function materialize(f::Field, d::ArrayData, budget)
+    estimate = _MaterializationEstimate(budget)
+    _reservevector!(estimate, Any, d.len, "materialized column")
+    for i = 1:(d.len)
+        _prechargevalue_of!(Any, d.type, f, d, Int64(i), estimate)
+    end
+    _commitestimate!(estimate, "materialized column")
+    return materialize(f, d)
+end
+
+# The same closed-set ladder as `layoutspec_of`, for element access and the
+# materialize function barrier: generic entry devirtualizes here; per-layout
+# `_value` methods stay the extension surface.
+@inline function _value_of(t::ArrowType, f::Field, d::ArrayData, i::Int64)
+    t isa IntType && return _value(t, f, d, i)
+    t isa FloatType && return _value(t, f, d, i)
+    t isa Utf8Type && return _value(t, f, d, i)
+    t isa BoolType && return _value(t, f, d, i)
+    t isa ListType && return _value(t, f, d, i)
+    t isa StructType && return _value(t, f, d, i)
+    t isa DictionaryType && return _value(t, f, d, i)
+    t isa TimestampType && return _value(t, f, d, i)
+    t isa DateType && return _value(t, f, d, i)
+    t isa TimeType && return _value(t, f, d, i)
+    t isa DurationType && return _value(t, f, d, i)
+    t isa BinaryType && return _value(t, f, d, i)
+    t isa FixedSizeBinaryType && return _value(t, f, d, i)
+    t isa FixedSizeListType && return _value(t, f, d, i)
+    t isa MapType && return _value(t, f, d, i)
+    t isa UnionType && return _value(t, f, d, i)
+    t isa DecimalType && return _value(t, f, d, i)
+    t isa IntervalType && return _value(t, f, d, i)
+    t isa NullType && return _value(t, f, d, i)
+    t isa ViewType && return _value(t, f, d, i)
+    t isa ListViewType && return _value(t, f, d, i)
+    t isa RunEndEncodedType && return _value(t, f, d, i)
+    throw(ArgumentError("unregistered ArrowType"))
+end
+
+@inline function _materialize_of(t::ArrowType, f::Field, d::ArrayData)
+    t isa IntType && return _materialize_loop(t, f, d)
+    t isa FloatType && return _materialize_loop(t, f, d)
+    t isa Utf8Type && return _materialize_loop(t, f, d)
+    t isa BoolType && return _materialize_loop(t, f, d)
+    t isa ListType && return _materialize_loop(t, f, d)
+    t isa StructType && return _materialize_loop(t, f, d)
+    t isa DictionaryType && return _materialize_loop(t, f, d)
+    t isa TimestampType && return _materialize_loop(t, f, d)
+    t isa DateType && return _materialize_loop(t, f, d)
+    t isa TimeType && return _materialize_loop(t, f, d)
+    t isa DurationType && return _materialize_loop(t, f, d)
+    t isa BinaryType && return _materialize_loop(t, f, d)
+    t isa FixedSizeBinaryType && return _materialize_loop(t, f, d)
+    t isa FixedSizeListType && return _materialize_loop(t, f, d)
+    t isa MapType && return _materialize_loop(t, f, d)
+    t isa UnionType && return _materialize_loop(t, f, d)
+    t isa DecimalType && return _materialize_loop(t, f, d)
+    t isa IntervalType && return _materialize_loop(t, f, d)
+    t isa NullType && return _materialize_loop(t, f, d)
+    t isa ViewType && return _materialize_loop(t, f, d)
+    t isa ListViewType && return _materialize_loop(t, f, d)
+    t isa RunEndEncodedType && return _materialize_loop(t, f, d)
+    throw(ArgumentError("unregistered ArrowType"))
+end
+
+function _materialize_loop(t::T, f::Field, d::ArrayData) where {T<:ArrowType}
+    out = Vector{Any}(undef, d.len)
+    for i = 1:(d.len)
+        out[i] = _value(t, f, d, Int64(i))
+    end
+    # Vector{Any} by design: result-element typing is the caller's claim
+    # through `materialize(::Type{T}, ...)` (which the facade uses for closed
+    # claims), and a runtime narrow is trim-hostile. Tests compare with
+    # ==/isequal, which is eltype-agnostic.
+    return out
+end
+
+# ---------------------------------------------------------------------------
+# Typed element access: the caller asserts the element domain. With a
+# concrete static schema at the call site every load
+# resolves statically — the trim-compile contract dynamic access cannot
+# offer. The type is a CLAIM about the same value domain the dynamic
+# accessors return (storage integers for temporal, `Vector{Pair}` rows for
+# struct/map): the read produces exactly that type or refuses with a clear
+# error. `Any` is the dynamic path unchanged.
+#
+# Recursion architecture: it mirrors the dynamic path exactly. Recursive
+# edges route through `_typedchild` — a COMPILED function whose argument
+# types are all concrete (like public `getvalue` on the dynamic side) — so
+# the cycle's one non-inlined call is fully resolvable; the `@inline`
+# ladder and leaf methods flatten into it. An `@inline` ladder call
+# carrying an abstract descriptor as the recursive edge is unresolvable
+# under trim (no standalone specialization exists).
+# ---------------------------------------------------------------------------
+
+"""
+    getvalue(::Type{T}, field, data, i) -> T
+
+Statically typed element access: `T` asserts the element domain (what the
+dynamic accessors return for this layout — see `juliatype` for the leaf
+layouts), with `Missing <: T` required to admit nulls. The claim checks against the
+DESCRIPTOR up front — an empty or all-null column certifies nothing.
+Composites recurse: a `List<Int64>` column reads as
+`Vector{Vector{Int64}}`, and a `Struct` column may read as a `NamedTuple`
+row type whose names match the child fields in order. Mismatches refuse
+with `ArgumentError` — values are never converted. `T === Any` delegates
+to the dynamic path.
+"""
+function getvalue(::Type{T}, f::Field, d::ArrayData, i::Integer) where {T}
+    T === Any && return getvalue(f, d, i)
+    _checkclaim(T, f, d)
+    1 <= i <= d.len || throw(BoundsError(d, i))
+    return _typedvalue_of(T, d.type, f, d, Int64(i))::T
+end
+
+"""
+    materialize(::Type{T}, field, data) -> Vector{T}
+
+The bulk form of the typed [`getvalue`](@ref): every element under the
+static claim `T` (see `getvalue(::Type{T}, field, data, i)` for the claim
+rules), through one typed loop per layout.
+"""
+function materialize(::Type{T}, f::Field, d::ArrayData) where {T}
+    T === Any && return materialize(f, d)
+    _checkclaim(T, f, d)
+    return _typedmaterialize_of(T, d.type, f, d)::Vector{T}
+end
+
+function materialize(::Type{T}, f::Field, d::ArrayData, budget) where {T}
+    T === Any && return materialize(f, d, budget)
+    _checkclaim(T, f, d)
+    estimate = _MaterializationEstimate(budget)
+    _reservevector!(estimate, T, d.len, "typed materialized column")
+    # Fixed-width values charge nothing beyond the column under a typed
+    # claim (only `Any` boxes them), so they skip the per-value walk.
+    fixedwidth =
+        d.type isa Union{
+            IntType,
+            FloatType,
+            TimestampType,
+            DurationType,
+            DateType,
+            TimeType,
+            IntervalType,
+            BoolType,
+            NullType,
+        }
+    if !fixedwidth
+        for i = 1:(d.len)
+            _prechargevalue_of!(T, d.type, f, d, Int64(i), estimate)
+        end
+    end
+    _commitestimate!(estimate, "typed materialized column")
+    return _typedmaterialize_of(T, d.type, f, d)::Vector{T}
+end
+
+# The message names the layout via `nameof` (generic struct/type `show` is
+# trim-hostile, and an abstract descriptor argument would leave the throw
+# helper unresolvable); `juliatype(t)` tells a caller the expected claim.
+# Closed-set ladder to literal strings: `nameof(typeof(t))` on an abstract
+# descriptor is itself an unresolvable call under trim.
+@inline function _layoutname(t::ArrowType)
+    t isa IntType && return "IntType"
+    t isa FloatType && return "FloatType"
+    t isa BoolType && return "BoolType"
+    t isa Utf8Type && return "Utf8Type"
+    t isa BinaryType && return "BinaryType"
+    t isa FixedSizeBinaryType && return "FixedSizeBinaryType"
+    t isa TimestampType && return "TimestampType"
+    t isa DateType && return "DateType"
+    t isa TimeType && return "TimeType"
+    t isa DurationType && return "DurationType"
+    t isa ViewType && return "ViewType"
+    t isa DecimalType && return "DecimalType"
+    t isa IntervalType && return "IntervalType"
+    t isa MapType && return "MapType"
+    t isa StructType && return "StructType"
+    t isa ListType && return "ListType"
+    t isa ListViewType && return "ListViewType"
+    t isa FixedSizeListType && return "FixedSizeListType"
+    t isa DictionaryType && return "DictionaryType"
+    t isa RunEndEncodedType && return "RunEndEncodedType"
+    t isa UnionType && return "UnionType"
+    t isa NullType && return "NullType"
+    return "ArrowType"
+end
+@noinline _typedrefuse(::Type{E}, kind::String, f::Field) where {E} = throw(
+    ArgumentError(
+        "field $(f.name) materializes $(kind)-layout " *
+        "values; the claimed static element type does not match",
+    ),
+)
+@noinline _typednullrefuse(f::Field) = throw(
+    ArgumentError(
+        "field $(f.name) holds a null but the static " *
+        "element type does not admit missing",
+    ),
+)
+@inline _typedmissing(::Type{T}, f::Field) where {T} =
+    Missing <: T ? missing : _typednullrefuse(f)
+
+"""
+Descriptor-level claim preflight: `T` must match the element domain the
+schema DECLARES — acceptance never depends on which values a batch
+happens to contain (an empty or all-null column certifies nothing).
+Shapes, field counts, and names check ONCE here; the element loop stays
+check-free. Compiled (not `@inline`): its recursion keeps the claim
+intact through transparent wrappers, and a compiled concrete-arg edge is
+what makes that cycle trim-resolvable.
+"""
+function _checkclaim(::Type{T}, f::Field, d::ArrayData)::Nothing where {T}
+    t = d.type
+    if t isa ListType || t isa ListViewType || t isa FixedSizeListType
+        E = Base.nonmissingtype(T)
+        E <: Vector || _typedrefuse(E, _layoutname(t), f)
+        length(f.children) == 1 && length(d.children) == 1 ||
+            _typedrefuse(E, _layoutname(t), f)
+        return _checkclaim(eltype(E), f.children[1], d.children[1])
+    end
+    if t isa StructType
+        E = Base.nonmissingtype(T)
+        E === Vector{Pair{String,Any}} && return nothing
+        # An EXACT NamedTuple shape only: a Union or UnionAll of row types
+        # satisfies `<: NamedTuple` but has no field reflection — it must
+        # refuse here, not leak a generation error.
+        (E isa DataType && E <: NamedTuple) || _typedrefuse(E, _layoutname(t), f)
+        (fieldcount(E) == length(f.children) && fieldcount(E) == length(d.children)) ||
+            _typedrefuse(E, _layoutname(t), f)
+        return _checkstructclaim(E, f, d)
+    end
+    if t isa DictionaryType
+        dict = d.dictionary
+        dict === nothing &&
+            throw(ValidationError("dictionary-encoded array without a dictionary"))
+        return _checkclaim(T, dictvaluefield(f, t), dict)
+    end
+    if t isa RunEndEncodedType
+        (length(f.children) == 2 && length(d.children) == 2) ||
+            _typedrefuse(Base.nonmissingtype(T), _layoutname(t), f)
+        return _checkclaim(T, f.children[2], d.children[2])
+    end
+    t isa UnionType && _typedrefuse(Base.nonmissingtype(T), _layoutname(t), f)
+    if t isa NullType
+        Missing <: T || _typednullrefuse(f)
+        return nothing
+    end
+    E = Base.nonmissingtype(T)
+    E === _juliatype_of(t) || _typedrefuse(E, _layoutname(t), f)
+    return nothing
+end
+
+# Generated so every field index is a LITERAL: `fieldtype(E, j)` with a
+# runtime `j` yields an abstract `Type` and poisons the recursion, and the
+# name strings bake in at generation (no per-call conversion at all).
+@generated function _checkstructclaim(
+    ::Type{E},
+    f::Field,
+    d::ArrayData,
+)::Nothing where {E<:NamedTuple}
+    checks = Expr[]
+    for j = 1:fieldcount(E)
+        push!(
+            checks,
+            :(
+                $(String(fieldnames(E)[j])) == f.children[$j].name ||
+                _typedrefuse(E, _layoutname(d.type), f)
+            ),
+        )
+        push!(checks, :(_checkclaim($(fieldtype(E, j)), f.children[$j], d.children[$j])))
+    end
+    return quote
+        $(checks...)
+        return nothing
+    end
+end
+
+# Closed-set ladder for the preflight's leaf claims — scalars plus the
+# `Map` row vector (an abstract
+# `juliatype(t::ArrowType)` call would defeat trim resolution).
+@inline function _juliatype_of(t::ArrowType)
+    t isa IntType && return juliatype(t)
+    t isa FloatType && return juliatype(t)
+    t isa BoolType && return juliatype(t)
+    t isa Utf8Type && return juliatype(t)
+    t isa BinaryType && return juliatype(t)
+    t isa FixedSizeBinaryType && return juliatype(t)
+    t isa TimestampType && return juliatype(t)
+    t isa DateType && return juliatype(t)
+    t isa TimeType && return juliatype(t)
+    t isa DurationType && return juliatype(t)
+    t isa ViewType && return juliatype(t)
+    t isa DecimalType && return juliatype(t)
+    t isa IntervalType && return juliatype(t)
+    t isa MapType && return juliatype(t)
+    throw(ArgumentError("unregistered ArrowType"))
+end
+
+# The typed recursion edge, split for two masters. The logical-bounds guard
+# matches what the dynamic path gets from public `getvalue`: unvalidated
+# geometry must not read backing values past a child's logical length.
+# SCALAR leaves inline into the parent's loop so the buffer-slice
+# temporaries stay stack-allocated (a compiled boundary per child read
+# would allocate); COMPOSITE children route to `_typedchildbox`, a compiled
+# shell whose argument types are all concrete — the resolvable edge trim
+# requires. The generic ladder flattens reliably into a dedicated shell but
+# not into arbitrary hoisted contexts, so the shell is the only caller. The
+# `::T` asserts pin inference to the claim where the same-claim wrapper
+# cycle (Dictionary/REE) would widen to Any.
+@inline function _typedchild(::Type{T}, f::Field, d::ArrayData, i::Int64) where {T}
+    1 <= i <= d.len || throw(BoundsError(d, i))
+    t = d.type
+    t isa IntType && return _typedvalue(T, t, f, d, i)::T
+    t isa FloatType && return _typedvalue(T, t, f, d, i)::T
+    t isa BoolType && return _typedvalue(T, t, f, d, i)::T
+    t isa Utf8Type && return _typedvalue(T, t, f, d, i)::T
+    t isa BinaryType && return _typedvalue(T, t, f, d, i)::T
+    t isa FixedSizeBinaryType && return _typedvalue(T, t, f, d, i)::T
+    t isa TimestampType && return _typedvalue(T, t, f, d, i)::T
+    t isa DateType && return _typedvalue(T, t, f, d, i)::T
+    t isa TimeType && return _typedvalue(T, t, f, d, i)::T
+    t isa DurationType && return _typedvalue(T, t, f, d, i)::T
+    t isa DecimalType && return _typedvalue(T, t, f, d, i)::T
+    t isa IntervalType && return _typedvalue(T, t, f, d, i)::T
+    t isa ViewType && return _typedvalue(T, t, f, d, i)::T
+    t isa NullType && return _typedvalue(T, t, f, d, i)::T
+    return _typedchildbox(T, f, d, i)::T
+end
+
+function _typedchildbox(::Type{T}, f::Field, d::ArrayData, i::Int64) where {T}
+    return _typedvalue_of(T, d.type, f, d, i)::T
+end
+
+# The same closed-set ladder as `_value_of`, with the claimed type threaded.
+@inline function _typedvalue_of(
+    ::Type{T},
+    t::ArrowType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+) where {T}
+    t isa IntType && return _typedvalue(T, t, f, d, i)
+    t isa FloatType && return _typedvalue(T, t, f, d, i)
+    t isa Utf8Type && return _typedvalue(T, t, f, d, i)
+    t isa BoolType && return _typedvalue(T, t, f, d, i)
+    t isa ListType && return _typedvalue(T, t, f, d, i)
+    t isa StructType && return _typedvalue(T, t, f, d, i)
+    # Wrapper branches keep the claim intact, so they alone can recurse
+    # with an UNCHANGED signature: the ::T assert stops that cycle from
+    # widening every other branch to Any in fresh-process inference; the
+    # wrapper read itself pays one box.
+    t isa DictionaryType && return _typedvalue(T, t, f, d, i)::T
+    t isa TimestampType && return _typedvalue(T, t, f, d, i)
+    t isa DateType && return _typedvalue(T, t, f, d, i)
+    t isa TimeType && return _typedvalue(T, t, f, d, i)
+    t isa DurationType && return _typedvalue(T, t, f, d, i)
+    t isa BinaryType && return _typedvalue(T, t, f, d, i)
+    t isa FixedSizeBinaryType && return _typedvalue(T, t, f, d, i)
+    t isa FixedSizeListType && return _typedvalue(T, t, f, d, i)
+    t isa MapType && return _typedvalue(T, t, f, d, i)
+    t isa UnionType && return _typedvalue(T, t, f, d, i)
+    t isa DecimalType && return _typedvalue(T, t, f, d, i)
+    t isa IntervalType && return _typedvalue(T, t, f, d, i)
+    t isa NullType && return _typedvalue(T, t, f, d, i)
+    t isa ViewType && return _typedvalue(T, t, f, d, i)
+    t isa ListViewType && return _typedvalue(T, t, f, d, i)
+    t isa RunEndEncodedType && return _typedvalue(T, t, f, d, i)::T
+    throw(ArgumentError("unregistered ArrowType"))
+end
+
+# Closed leaf claims (scalars plus the `Map` row vector): the claim must
+# equal the layout's `juliatype`
+# exactly; the audited dynamic extraction runs and the assert makes the
+# result statically typed (and free when the claim is right).
+function _typedvalue(
+    ::Type{T},
+    t::Union{
+        IntType,
+        FloatType,
+        BoolType,
+        Utf8Type,
+        BinaryType,
+        FixedSizeBinaryType,
+        TimestampType,
+        DateType,
+        TimeType,
+        DurationType,
+        ViewType,
+        DecimalType,
+        IntervalType,
+        MapType,
+    },
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+) where {T}
+    isvalid_at(d, i) || return _typedmissing(T, f)
+    E = Base.nonmissingtype(T)
+    E === juliatype(t) || _typedrefuse(E, _layoutname(t), f)
+    # Invalid int/float widths fall through juliatype's 64-bit fallback:
+    # refuse them here (managed, fails closed) rather than let the raw
+    # extraction's own width ladder produce a mistyped value.
+    (t isa IntType || t isa FloatType) &&
+        primwidth(t) != Int64(sizeof(E)) &&
+        _typedrefuse(E, _layoutname(t), f)
+    return _value(t, f, d, i)::E
+end
+
+function _typedvalue(
+    ::Type{T},
+    t::Union{ListType,ListViewType},
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+) where {T}
+    isvalid_at(d, i) || return _typedmissing(T, f)
+    E = Base.nonmissingtype(T)
+    E <: Vector || _typedrefuse(E, _layoutname(t), f)
+    if t isa ListType
+        lo, hi = _offsets_at(d, i, layoutspec(t).offsetwidth == 8)
+        off = lo
+        n = hi - lo
+    else
+        off, n = _listview_range(t, d, i)
+        (off >= 0 && n >= 0) ||
+            throw(ValidationError("list-view offset and size must be non-negative"))
+    end
+    child, cf = d.children[1], f.children[1]
+    CE = eltype(E)
+    out = Vector{CE}(undef, Int(n))
+    for k = 1:Int(n)
+        out[k] = _typedchild(CE, cf, child, checked_add(off, Int64(k)))
+    end
+    return out
+end
+
+function _typedvalue(
+    ::Type{T},
+    t::FixedSizeListType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+) where {T}
+    isvalid_at(d, i) || return _typedmissing(T, f)
+    E = Base.nonmissingtype(T)
+    E <: Vector || _typedrefuse(E, _layoutname(t), f)
+    child, cf = d.children[1], f.children[1]
+    base = checked_mul(_slotindex0(d, i), Int64(t.listsize))
+    CE = eltype(E)
+    out = Vector{CE}(undef, t.listsize)
+    for j = 1:(t.listsize)
+        out[j] = _typedchild(CE, cf, child, checked_add(base, Int64(j)))
+    end
+    return out
+end
+
+function _typedvalue(::Type{T}, t::StructType, f::Field, d::ArrayData, i::Int64) where {T}
+    isvalid_at(d, i) || return _typedmissing(T, f)
+    E = Base.nonmissingtype(T)
+    E === Vector{Pair{String,Any}} && return _value(t, f, d, i)::E
+    E <: NamedTuple || _typedrefuse(E, _layoutname(t), f)
+    return _structrow(E, f, d, checked_add(d.offset, i))
+end
+
+# Generated so every field's claim is a LITERAL type and the row build is
+# a flat tuple expression: an `ntuple(Val(N))` closure erases per-field
+# types to `NTuple{N,Any}` at arity >= 4, and index-recursion trips the
+# inference recursion limiter. The preflight already checked names.
+@generated function _structrow(
+    ::Type{E},
+    f::Field,
+    d::ArrayData,
+    childindex::Int64,
+) where {E<:NamedTuple}
+    vals = Expr[
+        :(_typedchild($(fieldtype(E, j)), f.children[$j], d.children[$j], childindex))
+        for j = 1:fieldcount(E)
+    ]
+    return :(E(($(vals...),)))
+end
+
+function _typedvalue(
+    ::Type{T},
+    t::DictionaryType,
+    f::Field,
+    d::ArrayData,
+    i::Int64,
+) where {T}
+    isvalid_at(d, i) || return _typedmissing(T, f)
+    w = primwidth(t.indextype)
+    idx = _load_int(rolebuffer(d, DATA), t.indextype, _slotbyteoff(d, i, w))
+    dict = d.dictionary
+    dict === nothing &&
+        throw(ValidationError("dictionary-encoded array without a dictionary"))
+    return _typedchild(T, dictvaluefield(f, t), dict, checked_add(Int64(idx), Int64(1)))
+end
+
+_typedvalue(::Type{T}, t::RunEndEncodedType, f::Field, d::ArrayData, i::Int64) where {T} =
+    _typedchild(T, f.children[2], d.children[2], _ree_runindex(d, i))
+
+_typedvalue(::Type{T}, ::NullType, f::Field, ::ArrayData, ::Int64) where {T} =
+    _typedmissing(T, f)
+
+# Union rows take the WINNING child's runtime type: no static claim can
+# hold across children, so only the dynamic path reads unions.
+_typedvalue(::Type{T}, t::UnionType, f::Field, ::ArrayData, ::Int64) where {T} =
+    _typedrefuse(Base.nonmissingtype(T), _layoutname(t), f)
+
+@inline function _typedmaterialize_of(
+    ::Type{T},
+    t::ArrowType,
+    f::Field,
+    d::ArrayData,
+) where {T}
+    t isa IntType && return _typedmaterialize_loop(T, t, f, d)
+    t isa FloatType && return _typedmaterialize_loop(T, t, f, d)
+    t isa Utf8Type && return _typedmaterialize_loop(T, t, f, d)
+    t isa BoolType && return _typedmaterialize_loop(T, t, f, d)
+    t isa ListType && return _typedmaterialize_loop(T, t, f, d)
+    t isa StructType && return _typedmaterialize_loop(T, t, f, d)
+    t isa DictionaryType && return _typedmaterialize_loop(T, t, f, d)
+    t isa TimestampType && return _typedmaterialize_loop(T, t, f, d)
+    t isa DateType && return _typedmaterialize_loop(T, t, f, d)
+    t isa TimeType && return _typedmaterialize_loop(T, t, f, d)
+    t isa DurationType && return _typedmaterialize_loop(T, t, f, d)
+    t isa BinaryType && return _typedmaterialize_loop(T, t, f, d)
+    t isa FixedSizeBinaryType && return _typedmaterialize_loop(T, t, f, d)
+    t isa FixedSizeListType && return _typedmaterialize_loop(T, t, f, d)
+    t isa MapType && return _typedmaterialize_loop(T, t, f, d)
+    t isa UnionType && return _typedmaterialize_loop(T, t, f, d)
+    t isa DecimalType && return _typedmaterialize_loop(T, t, f, d)
+    t isa IntervalType && return _typedmaterialize_loop(T, t, f, d)
+    t isa NullType && return _typedmaterialize_loop(T, t, f, d)
+    t isa ViewType && return _typedmaterialize_loop(T, t, f, d)
+    t isa ListViewType && return _typedmaterialize_loop(T, t, f, d)
+    t isa RunEndEncodedType && return _typedmaterialize_loop(T, t, f, d)
+    throw(ArgumentError("unregistered ArrowType"))
+end
+
+function _typedmaterialize_loop(
+    ::Type{T},
+    t::TT,
+    f::Field,
+    d::ArrayData,
+) where {T,TT<:ArrowType}
+    bulk = _bulkmaterialize(T, t, f, d)
+    bulk === nothing || return bulk::Vector{T}
+    out = Vector{T}(undef, d.len)
+    for i = 1:(d.len)
+        out[i] = _typedvalue(T, t, f, d, Int64(i))
+    end
+    return out
+end
+
+# ---------------------------------------------------------------------------
+# Bulk fixed-width extraction: for closed isbits claims over plain
+# fixed-width layouts, one bounds-checked byte copy replaces ten million
+# per-element calls (the benchmark-dominant cost of materializing reads).
+# Nulls punch in afterward from the validity bitmap. Everything else
+# (strings, composites, bitmaps, decimal-as-bytes) keeps the element loop.
+# ---------------------------------------------------------------------------
+
+_bulkmaterialize(::Type{T}, ::ArrowType, ::Field, ::ArrayData) where {T} = nothing
+
+function _bulkmaterialize(
+    ::Type{T},
+    t::Union{IntType,FloatType,TimestampType,DateType,TimeType,DurationType,DecimalType},
+    f::Field,
+    d::ArrayData,
+) where {T}
+    E = Base.nonmissingtype(T)
+    isbitstype(E) || return nothing
+    E === juliatype(t) || return nothing
+    w = Int64(sizeof(E))
+    # The claim's byte size must equal the DESCRIPTOR's layout width: an
+    # invalid 24-bit descriptor falls through juliatype's fallback to a
+    # 64-bit Julia type, and copying at the claim's width would misread —
+    # such descriptors take the element loop (and validation refuses them).
+    primwidth(t) == w || return nothing
+    n = d.len
+    # The typed path serves unvalidated data too: subslice re-checks the
+    # extraction window against the buffer's declared bounds.
+    src = subslice(rolebuffer(d, DATA), checked_mul(d.offset, w), checked_mul(n, w))
+    # The BITMAP is the validity authority, exactly as per-element access:
+    # a caller-supplied null-count cache is only certified after semantic
+    # validation, and this path explicitly serves unvalidated data.
+    v = validitybuffer(d)
+    # When the claim admits no Missing, E === T: one byte copy builds the
+    # public vector.
+    if !(Missing <: T)
+        vals = Vector{E}(undef, n)
+        if n > 0
+            GC.@preserve vals d begin
+                unsafe_copyto!(Ptr{UInt8}(pointer(vals)), sliceptr(src), Int(src.len))
+            end
+        end
+        isempty_buffer(v) || _countsetbits(v, d.offset, n) == n || _typednullrefuse(f)
+        return vals
+    end
+    # A Missing-admitting vector has no contiguous byte view to copy into, so
+    # load each value straight from the buffer (unsafe_load is unaligned-safe)
+    # instead of staging a Vector{E} copy first.
+    out = Vector{T}(undef, n)
+    if n > 0
+        GC.@preserve d begin
+            p = Ptr{E}(sliceptr(src))
+            @inbounds for i = 1:n
+                out[i] = unsafe_load(p, i)
+            end
+        end
+    end
+    isempty_buffer(v) || _punchnulls!(out, v, d.offset, n)
+    return out
+end
+
+# Set out[i] = missing for each cleared bit among the `n` validity bits that
+# start at 0-based bit `start`, under one bounds check for the bitmap bytes.
+function _punchnulls!(out::Vector, v::BufferSlice, start::Int64, n::Int64)
+    n > 0 || return out
+    start >= 0 || throw(BoundsError(v, start))
+    stop = checked_add(start, n)
+    firstbyte, lastbyte = start >> 3, (stop - 1) >> 3
+    nbytes = lastbyte - firstbyte + 1
+    (nbytes <= v.len && firstbyte <= v.len - nbytes) || throw(BoundsError(v, lastbyte))
+    GC.@preserve v begin
+        p = sliceptr(v)
+        for i = 1:n
+            bit = start + (i - 1)
+            (unsafe_load(p + (bit >> 3)) >> (bit & 7)) & 0x01 == 0x00 && (out[i] = missing)
+        end
+    end
+    return out
+end
+
+# ---------------------------------------------------------------------------
+# §7 Builders: Julia data -> (Field, ArrayData)
+# ---------------------------------------------------------------------------
+
+# The write-side counterpart, kept intentionally small: enough construction
+# machinery to build every implemented layout without an IPC file in the
+# loop. These are "zero-copy wrap + bitmap build" fast paths; the
+# append-oriented builder layer is the facade's.
+
+@inline function _setbitmapbit!(bytes::Vector{UInt8}, i::Int)
+    bytes[1 + ((i - 1) >> 3)] |= UInt8(1) << ((i - 1) & 7)
+    return nothing
+end
+
+function _bitmapbuffer(present::AbstractVector{Bool})
+    any(!, present) || return BufferSlice()   # no nulls -> canonical empty
+    bytes = zeros(UInt8, expected_validity_bytes(Int64(length(present))))
+    for (i, p) in enumerate(present)
+        p && _setbitmapbit!(bytes, i)
+    end
+    return BufferSlice(heapregion(bytes), 0, length(bytes))
+end
+
+_databuffer(v::Vector{T}) where {T} = BufferSlice(heapregion(v), 0, sizeof(v))
+
+"Build Boolean data and validity buffers directly in Arrow's bit-packed form."
+function _build_bool(name, v::Vector{T}; nullable::Bool) where {T<:Union{Missing,Bool}}
+    bytes = zeros(UInt8, expected_validity_bytes(Int64(length(v))))
+    nc = 0
+    for (i, x) in enumerate(v)
+        if x === missing
+            nc += 1
+        elseif x
+            _setbitmapbit!(bytes, i)
+        end
+    end
+
+    validity = if nc == 0
+        BufferSlice()
+    else
+        validbytes = zeros(UInt8, length(bytes))
+        for (i, x) in enumerate(v)
+            x === missing || _setbitmapbit!(validbytes, i)
+        end
+        _databuffer(validbytes)
+    end
+    t = BoolType()
+    return Field(name, t; nullable=nullable),
+    ArrayData(t, length(v), [validity, _databuffer(bytes)]; nullcount=nc)
+end
+
+"Build non-null Boolean data through a caller-supplied direct bit fill."
+function _build_bool(name, len::Int, fillbits!::F; nullable::Bool) where {F}
+    len >= 0 || throw(ArgumentError("Boolean array length is negative"))
+    bytes = zeros(UInt8, expected_validity_bytes(Int64(len)))
+    fillbits!(bytes)
+    t = BoolType()
+    return Field(name, t; nullable=nullable),
+    ArrayData(t, len, [BufferSlice(), _databuffer(bytes)]; nullcount=0)
+end
+
+arrowtype_for(::Type{Bool}) = BoolType()
+arrowtype_for(::Type{T}) where {T<:Signed} = IntType(8 * sizeof(T), true)
+arrowtype_for(::Type{T}) where {T<:Unsigned} = IntType(8 * sizeof(T), false)
+arrowtype_for(::Type{Float16}) = FloatType(16)
+arrowtype_for(::Type{Float32}) = FloatType(32)
+arrowtype_for(::Type{Float64}) = FloatType(64)
+
+"""
+    fromjulia(name, v) -> (Field, ArrayData)
+
+Adapt a Julia vector to Core form. `Vector{T}` for fixed-width isbits `T`
+other than `Bool` is a ZERO-COPY wrap (the vector becomes the region's root;
+scoped-borrow contract: don't resize/mutate while in use). `Bool`
+(bit-packed), `Union{T,Missing}`, and String inputs build fresh buffers.
+"""
+function fromjulia(name, v::Vector{T}) where {T}
+    if T === Union{}
+        throw(
+            ArgumentError(
+                "fromjulia: bottom element type Union{} has no Arrow type; " *
+                "give the empty vector a declared element type",
+            ),
+        )
+    elseif T <:
+           Union{Int8,Int16,Int32,Int64,UInt8,UInt16,UInt32,UInt64,Float16,Float32,Float64}
+        t = arrowtype_for(T)
+        return Field(name, t; nullable=false),
+        ArrayData(t, length(v), [BufferSlice(), _databuffer(v)]; nullcount=0)
+    elseif T == Bool
+        return _build_bool(name, v; nullable=false)
+    elseif T == String
+        return _build_strings(name, v)
+    elseif T <: Union{
+        Missing,
+        Int8,
+        Int16,
+        Int32,
+        Int64,
+        UInt8,
+        UInt16,
+        UInt32,
+        UInt64,
+        Float16,
+        Float32,
+        Float64,
+        Bool,
+    }
+        return _build_nullable_primitive(name, v)
+    elseif T <: Union{Missing,String}
+        return _build_strings(name, v)
+    elseif T <: AbstractVector || T <: Union{Missing,<:AbstractVector}
+        return _build_list(name, v)
+    else
+        throw(ArgumentError("fromjulia: unsupported element type $T"))
+    end
+end
+
+function _build_nullable_primitive(name, v::Vector{T}; nullable::Bool=true) where {T}
+    S = Base.nonmissingtype(T)
+    if S === Union{}
+        t = NullType()
+        return Field(name, t; nullable=true),
+        ArrayData(t, length(v), BufferSlice[]; nullcount=length(v))
+    end
+    S === Bool && return _build_bool(name, v; nullable=nullable)
+    t = arrowtype_for(S)
+    # One pass fills the values and the validity bitmap.
+    n = length(v)
+    vals = Vector{S}(undef, n)
+    bits = zeros(UInt8, expected_validity_bytes(Int64(n)))
+    nc = 0
+    for i = 1:n
+        x = v[i]
+        if x === missing
+            nc += 1
+            vals[i] = zero(S)
+        else
+            vals[i] = S(x)
+            _setbitmapbit!(bits, i)
+        end
+    end
+    validity = nc == 0 ? BufferSlice() : BufferSlice(heapregion(bits), 0, length(bits))
+    data = _databuffer(vals)
+    # Nullability is the DECLARED element type's, not the observed count's:
+    # a Union{Missing,T} column with no missing values is still nullable.
+    return Field(name, t; nullable=nullable),
+    ArrayData(t, length(v), [validity, data]; nullcount=nc)
+end
+
+function _build_strings(name, v::Vector)
+    t = Utf8Type(false)
+    present = [x !== missing for x in v]
+    offsets = Vector{Int32}(undef, length(v) + 1)
+    offsets[1] = 0
+    nbytes = 0
+    for (i, x) in enumerate(v)
+        nbytes += x === missing ? 0 : ncodeunits(x)
+        nbytes <= typemax(Int32) ||
+            throw(ArgumentError("column $name exceeds the Int32 offset range"))
+        offsets[i + 1] = Int32(nbytes)
+    end
+    bytes = Vector{UInt8}(undef, nbytes)
+    pos = 1
+    for x in v
+        x === missing && continue
+        n = ncodeunits(x)
+        copyto!(bytes, pos, codeunits(x), 1, n)
+        pos += n
+    end
+    nc = count(!, present)
+    data = nbytes == 0 ? BufferSlice() : BufferSlice(heapregion(bytes), 0, nbytes)
+    return Field(name, t; nullable=eltype(v) >: Missing),
+    ArrayData(
+        t,
+        length(v),
+        [_bitmapbuffer(present), _databuffer(offsets), data];
+        nullcount=nc,
+    )
+end
+
+function _build_list(name, v::Vector)
+    present = [x !== missing for x in v]
+    offsets = Vector{Int32}(undef, length(v) + 1)
+    offsets[1] = 0
+    total = 0
+    for (i, x) in enumerate(v)
+        total += x === missing ? 0 : length(x)
+        total <= typemax(Int32) ||
+            throw(ArgumentError("column $name exceeds the Int32 offset range"))
+        offsets[i + 1] = Int32(total)
+    end
+    nonmissing = [x for x in v if x !== missing]
+    childtype = eltype(Base.nonmissingtype(eltype(v)))
+    flat = isempty(nonmissing) ? childtype[] : reduce(vcat, nonmissing)
+    cf, cd = fromjulia("item", collect(flat))
+    nc = count(!, present)
+    t = ListType(false)
+    return Field(name, t; nullable=eltype(v) >: Missing, children=[cf]),
+    ArrayData(
+        t,
+        length(v),
+        [_bitmapbuffer(present), _databuffer(offsets)];
+        children=[cd],
+        nullcount=nc,
+    )
+end
+
+"""
+    fromjulia_struct(name, nt::NamedTuple) -> (Field, ArrayData)
+
+Build a struct column from equal-length child vectors (no top-level nulls).
+"""
+function fromjulia_struct(name, nt::NamedTuple)
+    pairs = [fromjulia(String(k), v) for (k, v) in Base.pairs(nt)]
+    n = length(first(values(nt)))
+    all(length(v) == n for v in values(nt)) ||
+        throw(ArgumentError("struct children must have equal lengths"))
+    t = StructType()
+    return Field(name, t; nullable=false, children=[p[1] for p in pairs]),
+    ArrayData(t, n, [BufferSlice()]; children=[p[2] for p in pairs], nullcount=0)
+end
+
+"""
+    fromjulia_dict(name, values, indices0) -> (Field, ArrayData)
+
+Build a dictionary-encoded column from a value pool and 0-based Int32
+indices (`missing` for null slots).
+"""
+function fromjulia_dict(name, pool::Vector, indices0::Vector)
+    vf, vd = fromjulia(name, pool)
+    t = DictionaryType(IntType(32, true), vf.type, false)
+    present = [x !== missing for x in indices0]
+    inds = Int32[x === missing ? Int32(0) : Int32(x) for x in indices0]
+    nc = count(!, present)
+    return Field(name, t; nullable=nc > 0, children=vf.children),
+    ArrayData(
+        t,
+        length(indices0),
+        [_bitmapbuffer(present), _databuffer(inds)];
+        dictionary=vd,
+        nullcount=nc,
+    )
+end
+
+"""
+    fromviewentries(name, payloads::Vector{P}, buffers::Vector{Vector{UInt8}}; nullable=true) -> (Field, ArrayData)
+    fromviewentries(name, payloads::Vector{P}, buf, extra; nullable=true)
+
+Wrap a vector of Arrow view entries as a Utf8View column, ZERO-COPY. `P` is
+any 16-byte isbits type whose values are Arrow StringView entries — the
+representation DataStrings' `DataString` columns use:
+
+    bytes 0..3    Int32 content length (negative marks a null slot)
+    bytes 4..15   the content, zero-padded            (length ≤ 12)
+    bytes 4..7    the content's 4-byte prefix          (length > 12)
+    bytes 8..11   Int32 buffer index into `buffers` (0-based)
+    bytes 12..15  Int32 0-based byte offset within that buffer
+
+`payloads` becomes the views buffer and `buffers` the variadic data buffers,
+in order, without copying (the two-buffer form is `[buf, extra]`; a buffer
+may be empty, and an all-inline column may have none at all).
+
+The only work is the validity bitmap: a slot whose length is negative is
+null; the spec leaves a null slot's entry bytes unspecified, and neither
+this reader's nor the reference implementation's validation reads them.
+Long-entry geometry (offsets inside their buffer, prefixes matching the
+data) is checked where every builder's is — by
+`validate_semantic`/`validate_full` — not here. The scoped-borrow rule of
+every zero-copy wrap applies to every vector passed in.
+"""
+fromviewentries(
+    name,
+    payloads::Vector{P},
+    buf::Vector{UInt8},
+    extra::Vector{UInt8};
+    nullable::Bool=true,
+) where {P} = fromviewentries(name, payloads, Vector{UInt8}[buf, extra]; nullable=nullable)
+
+function fromviewentries(
+    name,
+    payloads::Vector{P},
+    buffers::Vector{Vector{UInt8}};
+    nullable::Bool=true,
+) where {P}
+    isbitstype(P) && sizeof(P) == 16 ||
+        throw(ArgumentError("view-entry payloads must be a 16-byte isbits type"))
+    # The entry words are values assembled by shifts; Arrow's byte layout is
+    # what those values spell out on a little-endian host, and Core reads
+    # view entries host-natively.
+    _native_endianness() == LittleEndian ||
+        throw(ArgumentError("fromviewentries requires a little-endian host"))
+    n = length(payloads)
+    present = Vector{Bool}(undef, n)
+    nnull = 0
+    GC.@preserve payloads begin
+        src = Ptr{Int32}(pointer(payloads))
+        for i = 1:n
+            ok = unsafe_load(src, 4 * i - 3) >= 0     # entry i's length word
+            present[i] = ok
+            nnull += !ok
+        end
+    end
+    t = ViewType(true)
+    slices = BufferSlice[_bitmapbuffer(present), _databuffer(payloads)]
+    for b in buffers
+        push!(slices, _databuffer(b))
+    end
+    return Field(name, t; nullable=nullable), ArrayData(t, n, slices; nullcount=nnull)
+end
+
+# ---------------------------------------------------------------------------
+# §8 RecordBatch + source protocol
+# ---------------------------------------------------------------------------
+
+"""
+    RecordBatch
+
+Schema + equal-length columns: the interchange unit between Core and every
+adapter. The IPC and C-stream adapters produce and consume batches; chunked
+columns are a facade convenience over them.
+"""
+struct RecordBatch
+    schema::Schema
+    columns::FrozenVector{ArrayData}
+    nrows::Int64
+    function RecordBatch(
+        schema::Schema,
+        columns,
+        nrows::Integer,
+        validated_dictionaries::Union{Nothing,_ValidatedDictionaries}=nothing,
+    )
+        _validate_schema(schema)
+        cols = FrozenVector{ArrayData}(columns)
+        n = Int64(nrows)
+        n >= 0 || throw(ArgumentError("negative row count"))
+        length(schema.fields) == length(cols) ||
+            throw(ArgumentError("schema/column count mismatch"))
+        for (f, c) in zip(schema.fields, cols)
+            length(c) == n || throw(ArgumentError("unequal column lengths"))
+            _validate_structural(f, c, validated_dictionaries)
+        end
+        return new(schema, cols, n)
+    end
+end
+"Copy a record batch with detached column buffers and the same immutable schema."
+Base.copy(b::RecordBatch) = RecordBatch(b.schema, map(copy, b.columns), b.nrows)
+
+RecordBatch(schema::Schema, columns) =
+    RecordBatch(schema, columns, isempty(columns) ? 0 : length(first(columns)))
+
+"Build a low-level `RecordBatch` from a `NamedTuple` of Julia vectors."
+function batch(nt::NamedTuple)
+    pairs = [fromjulia(String(k), v) for (k, v) in Base.pairs(nt)]
+    sch = Schema([p[1] for p in pairs])
+    return RecordBatch(sch, [p[2] for p in pairs])
+end
+
+"""
+    RecordBatchSource
+
+The shared pull-iteration protocol: implement
+`nextbatch!(src) -> Union{Nothing,RecordBatch}` and `schema(src)`. The IPC
+reader and C-stream importer present this shape, so a writer or dataset
+layer need not know which adapter produced the stream.
+"""
+abstract type RecordBatchSource end
+function nextbatch! end
+schema(src::RecordBatchSource) =
+    error("RecordBatchSource implementations must define schema(src)")
+
+end # module ArrowCore
diff --git a/src/ArrowTypes/LICENSE.md b/src/ArrowTypes/LICENSE.md
index 136e1c6a..d6456956 100644
--- a/src/ArrowTypes/LICENSE.md
+++ b/src/ArrowTypes/LICENSE.md
@@ -1,15 +1,202 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
\ No newline at end of file
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/src/ArrowTypes/NOTICE b/src/ArrowTypes/NOTICE
new file mode 100644
index 00000000..fc6b69b3
--- /dev/null
+++ b/src/ArrowTypes/NOTICE
@@ -0,0 +1,5 @@
+Apache Arrow Julia
+Copyright 2016-2026 The Apache Software Foundation
+
+This product includes software developed at
+The Apache Software Foundation (https://www.apache.org/).
diff --git a/src/ArrowTypes/Project.toml b/src/ArrowTypes/Project.toml
index 0166f602..1f2d1de8 100644
--- a/src/ArrowTypes/Project.toml
+++ b/src/ArrowTypes/Project.toml
@@ -18,11 +18,19 @@
 name = "ArrowTypes"
 uuid = "31f734f8-188a-4ce0-8406-c8a06bd891cd"
 authors = ["quinnj <quinn.jacobd@gmail.com>"]
-version = "2.3.0"
+version = "2.4.0"
 
 [deps]
 Sockets = "6462fe0b-24de-5631-8697-dd941f90decc"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
+[extras]
+OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+
+[targets]
+test = ["OffsetArrays", "Test"]
+
 [compat]
+OffsetArrays = "0.11, 1"
 julia = "1.0"
diff --git a/src/ArrowTypes/README.md b/src/ArrowTypes/README.md
new file mode 100644
index 00000000..93ddecb6
--- /dev/null
+++ b/src/ArrowTypes/README.md
@@ -0,0 +1,43 @@
+<!---
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements.  See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership.  The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License.  You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied.  See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# ArrowTypes.jl
+
+The type-mapping interface for serializing custom Julia types in the Arrow
+format, kept as its own package (registered separately from this
+subdirectory of the arrow-julia repository) so that packages can declare
+how their types map to Arrow without depending on Arrow.jl itself.
+
+* `ArrowTypes.ArrowKind(T)` — the general category of Arrow type a Julia
+  type is treated as (`PrimitiveKind`, `ListKind`, `StructKind`, …). A
+  consumer decides which categories and layouts it supports.
+* `ArrowTypes.ArrowType(T)` / `ArrowTypes.toarrow(x)` — the natively
+  supported type a value is converted to for serialization.
+* `ArrowTypes.arrowname(T)`, `ArrowTypes.arrowmetadata(T)`,
+  `ArrowTypes.JuliaType(Val(name), S, meta)` and `ArrowTypes.fromarrow` —
+  the round trip back to the custom type through Arrow extension-type
+  metadata.
+
+Arrow.jl 2.x and 3.x consume this stable 2.x interface. Arrow.jl 3.x applies
+`ArrowType` and `toarrow` recursively for custom values; defining `ArrowKind`
+alone does not select an arbitrary Arrow.jl 3.x physical layout. Packages that
+own custom types should depend on and import ArrowTypes.jl directly. Arrow.jl
+keeps `ArrowTypes` exported as a compatibility exception, and
+`Arrow.ArrowTypes` remains available as the qualified binding. See the
+docstrings of the functions above for the contract.
diff --git a/src/ArrowTypes/src/ArrowTypes.jl b/src/ArrowTypes/src/ArrowTypes.jl
index fe2223f4..29aa166c 100644
--- a/src/ArrowTypes/src/ArrowTypes.jl
+++ b/src/ArrowTypes/src/ArrowTypes.jl
@@ -15,8 +15,10 @@
 # limitations under the License.
 
 """
-The ArrowTypes module provides the [`ArrowTypes.Arrowtype`](@ref) interface trait that objects can define
-in order to signal how they should be serialized in the arrow format.
+The ArrowTypes module defines traits and hooks that packages can implement to
+describe how their Julia types map to the Arrow format. Arrow consumers,
+including Arrow.jl 2.x and 3.x, use this interface without requiring the
+package that owns a custom type to depend on Arrow.jl.
 """
 module ArrowTypes
 
@@ -41,24 +43,25 @@ export ArrowKind,
 """
     ArrowTypes.ArrowKind(T)
 
-For a give type `T`, define it's "arrow type kind", or the general category of arrow types it should be treated as. Must be one of:
+For a given type `T`, define its "arrow type kind", or the general category of arrow types it should be treated as. Must be one of:
   * [`ArrowTypes.NullKind`](@ref): `Missing` is the only type defined as `NullKind`
-  * [`ArrowTypes.PrimitiveKind`](@ref): `<:Integer`, `<:AbstractFloat`, along with `Arrow.Decimal`, and the various `Arrow.ArrowTimeType` subtypes
+  * [`ArrowTypes.PrimitiveKind`](@ref): `<:Integer`, `<:AbstractFloat`, along with decimal and temporal types
   * [`ArrowTypes.BoolKind`](@ref): only `Bool`
   * [`ArrowTypes.ListKind`](@ref): any `AbstractString` or `AbstractArray`
-  * [`ArrowTypes.FixedSizeList`](@ref): `NTuple{N, T}`
+  * [`ArrowTypes.FixedSizeListKind`](@ref): `NTuple{N, T}`
   * [`ArrowTypes.MapKind`](@ref): any `AbstractDict`
   * [`ArrowTypes.StructKind`](@ref): any `NamedTuple` or plain struct (mutable or otherwise)
   * [`ArrowTypes.UnionKind`](@ref): any `Union`
-  * [`ArrowTypes.DictEncodedKind`](@ref): array types that implement the `DataAPI.refpool` interface
-
-The list of `ArrowKind`s listed above translate to different ways to physically store data as supported by the arrow data format.
-See the docs for each for an idea of whether they might be an appropriate fit for a custom type.
-Note that custom types need to satisfy any additional "interface methods" as required by the various `ArrowKind`
-types. By default, if a type in julia is declared like `primitive type ...` it is considered a `PrimitiveKind`
-and if `struct` or `mutable struct` it's considered a `StructKind`. Also note that types will rarely need to define `ArrowKind`;
-much more common is to define `ArrowType(T)` and `toarrow(x::T)` to transform `T` to a natively supported arrow type, which will
-already have its `ArrowKind` defined.
+  * [`ArrowTypes.DictEncodedKind`](@ref): a kind a consumer may map its own dictionary-encoded array types to; ArrowTypes defines no such mapping itself
+
+The `ArrowKind`s describe general Arrow storage categories. Each consumer
+decides which categories, layouts, and extra interface methods it supports.
+By default, a Julia `primitive type` is a `PrimitiveKind`, and a `struct` or
+`mutable struct` is a `StructKind`. Types rarely need to define `ArrowKind`.
+It is more common to define `ArrowType(T)` and `toarrow(x::T)` to lower `T` to
+a natively supported Arrow type, which already has an `ArrowKind`. In
+particular, an `ArrowKind` override alone does not select an arbitrary
+physical layout in a consumer.
 """
 abstract type ArrowKind end
 
@@ -72,9 +75,9 @@ Interface method to define the natively supported arrow type `S` that a given ty
 Useful when a custom type wants a "serialization hook" or otherwise needs to be transformed/converted into a natively
 supported arrow type for serialization. If a type defines `ArrowType`, it must also define a corresponding
 [`ArrowTypes.toarrow(x::T)`](@ref) method which does the actual conversion from `T` to `S`.
-Note that custom structs defined like `struct T` or `mutable struct T` are natively supported in serialization, so unless
-_additional_ transformation/customization is desired, a custom type `T` can serialize with no `ArrowType` definition (by default,
-each field of a struct is serialized, using the results of `fieldnames(T)` and `getfield(x, i)`).
+Some consumers can serialize plain structs by discovering their fields; check
+the consumer's supported write types. Define `ArrowType` and `toarrow` when a
+custom type needs a different storage representation.
 Note that defining these methods only deal with custom _serialization_ to the arrow format; to be able to _deserialize_ custom
 types at all, see the docs for [`ArrowTypes.arrowname`](@ref), [`ArrowTypes.arrowmetadata`](@ref), [`ArrowTypes.JuliaType`](@ref),
 and [`ArrowTypes.fromarrow`](@ref).
@@ -142,15 +145,18 @@ arrowmetadata(::Type{Any}) = EMPTY_STRING
     ArrowTypes.JuliaType(::Val{Symbol(name)}, ::Type{S}, arrowmetadata::String) = T
 
 Interface method to define the custom Julia logical type `T` that a serialized metadata label should be converted to when
-deserializing. When reading arrow data, and a logical type label is encountered for a column, it will call
-`ArrowTypes.JuliaType(Val(Symbol(name)), S, arrowmetadata)` to see if a Julia type has been "registered" for deserialization. The `name`
+deserializing. To resolve a logical type label, a reader calls
+`ArrowTypes.JuliaType(Val(name_symbol), S, arrowmetadata)` with the corresponding existing Julia `Symbol`. The `name`
 used when defining the method *must* correspond to the same `name` when defining `ArrowTypes.arrowname(::Type{T}) = Symbol(name)`.
 The use of `Val(Symbol(...))` is to allow overloading a method on a specific logical type label. The `S` 2nd argument passed to
 `JuliaType` is the native arrow serialized type. This can be useful for parametric Julia types that wish to correctly parameterize
 their custom type based on what was serialized. The 3rd argument `arrowmetadata` is any metadata that was stored when the logical
 type was serialized as the result of calling `ArrowTypes.arrowmetadata(T)`. Note the 2nd and 3rd arguments are optional when
 overloading if unneeded.
-When defining [`ArrowTypes.arrowname`](@ref) and `ArrowTypes.JuliaType`, you may also want to implement [`ArrowTypes.fromarrow`]
+Readers must not intern an unknown, input-controlled name only to probe this interface: resolve the label with a non-interning
+lookup and call `JuliaType(Val(...))` only when the corresponding `Symbol` already exists, preserving ordinary Arrow storage
+values otherwise.
+When defining [`ArrowTypes.arrowname`](@ref) and `ArrowTypes.JuliaType`, you may also want to implement [`ArrowTypes.fromarrow`](@ref)
 in order to customize how a custom type `T` should be constructed from the native arrow data type. See its docs for more details.
 """
 function JuliaType end
@@ -188,7 +194,7 @@ fromarrow(::Type{Union{Missing,T}}, x::T) where {T} = x
 fromarrow(::Type{Union{Missing,T}}, x::T) where {T<:NamedTuple} = x # ambiguity fix
 fromarrow(::Type{Union{Missing,T}}, x) where {T} = fromarrow(T, x)
 
-"NullKind data is actually not physically stored since the data is constant; just the length is needed"
+"NullKind data is not stored physically — the value is constant, so only the length is needed."
 struct NullKind <: ArrowKind end
 
 ArrowKind(::Type{Missing}) = NullKind()
@@ -213,11 +219,11 @@ arrowname(::Type{Char}) = CHAR
 JuliaType(::Val{CHAR}) = Char
 fromarrow(::Type{Char}, x::UInt32) = Char(x)
 
-"BoolKind data is stored with values packed down to individual bits; so instead of a traditional Bool being 1 byte/8 bits, 8 Bool values would be packed into a single byte"
+"BoolKind data is bit-packed: 8 values per byte, not 1 byte per value."
 struct BoolKind <: ArrowKind end
 ArrowKind(::Type{Bool}) = BoolKind()
 
-"ListKind data are stored in two separate buffers; one buffer contains all the original data elements flattened into one long buffer; the 2nd buffer contains an offset into the 1st buffer for how many elements make up the original array element"
+"ListKind data is stored in two buffers: one holds every element flattened; the other holds the start offset of each list, so element i spans offsets[i]:offsets[i+1]-1."
 struct ListKind{stringtype} <: ArrowKind end
 
 ListKind() = ListKind{false}()
@@ -225,7 +231,7 @@ isstringtype(::ListKind{stringtype}) where {stringtype} = stringtype
 isstringtype(::Type{ListKind{stringtype}}) where {stringtype} = stringtype
 
 ArrowKind(::Type{<:AbstractString}) = ListKind{true}()
-# Treate Base.CodeUnits as Binary arrow type
+# Treat Base.CodeUnits as a Binary arrow type
 ArrowKind(::Type{<:Base.CodeUnits}) = ListKind{true}()
 
 fromarrow(::Type{T}, ptr::Ptr{UInt8}, len::Int) where {T} =
@@ -239,6 +245,8 @@ toarrow(x::Symbol) = String(x)
 const SYMBOL = Symbol("JuliaLang.Symbol")
 arrowname(::Type{Symbol}) = SYMBOL
 JuliaType(::Val{SYMBOL}) = Symbol
+# Arrow.jl's IPC reader checks that a Symbol payload is already interned before
+# it calls this compatibility hook. Direct ArrowTypes callers remain trusted.
 _symbol(ptr, len) = ccall(:jl_symbol_n, Ref{Symbol}, (Ptr{UInt8}, Int), ptr, len)
 fromarrow(::Type{Symbol}, ptr::Ptr{UInt8}, len::Int) = _symbol(ptr, len)
 
@@ -285,6 +293,8 @@ arrowname(::Type{IPv6}) = IPV6_SYMBOL
 JuliaType(::Val{IPV6_SYMBOL}) = IPv6
 fromarrow(::Type{IPv6}, x::NTuple{16,UInt8}) = IPv6(_cast(UInt128, x))
 
+# Not a plain reinterpret: the Ref round trip keeps the UInt128 ↔
+# NTuple{16,UInt8} conversion allocation- and trim-safe without a bitcast.
 function _cast(::Type{Y}, x)::Y where {Y}
     y = Ref{Y}()
     _unsafe_cast!(y, Ref(x), 1)
@@ -306,6 +316,16 @@ struct StructKind <: ArrowKind end
 
 ArrowKind(::Type{<:NamedTuple}) = StructKind()
 
+"""
+    ArrowTypes.fromarrowstruct(::Type{T}, ::Val{fnames}, x...) => T
+
+Optional `StructKind` deserialization hook. The field values `x` are passed
+together with their serialized field names `fnames` (a tuple of Symbols), so
+`T` can be reconstructed agnostic to the field order the serializer used.
+When a method is defined for `T`, it takes precedence over
+[`ArrowTypes.fromarrow`](@ref) in `StructKind` deserialization; the default
+forwards to `fromarrow(T, x...)`.
+"""
 @inline fromarrowstruct(T::Type, ::Val, x...) = fromarrow(T, x...)
 
 fromarrow(
@@ -335,7 +355,7 @@ function fromarrow(::Type{VersionNumber}, v::NamedTuple)
     VersionNumber(v.major, v.minor, v.patch, v.prerelease, v.build)
 end
 
-"MapKind data are stored similarly to ListKind, where elements are flattened, and a 2nd offsets buffer contains the individual list element length data"
+"MapKind data is stored like ListKind: flattened key-value entries plus an offsets buffer delimiting each map."
 struct MapKind <: ArrowKind end
 
 ArrowKind(::Type{<:AbstractDict}) = MapKind()
@@ -345,7 +365,7 @@ struct UnionKind <: ArrowKind end
 
 ArrowKind(::Union) = UnionKind()
 
-"DictEncodedKind store a small pool of unique values in one buffer, with a full-length buffer of integer offsets into the small value pool"
+"`DictEncodedKind` stores a category pool in one buffer and a full-length buffer of integer indices into it. A category pool may contain unused or duplicate physical entries."
 struct DictEncodedKind <: ArrowKind end
 
 """
@@ -392,7 +412,13 @@ function promoteunion(T, S)
     return isabstracttype(new) ? Union{T,S} : new
 end
 
-# lazily call toarrow(x) on getindex for each x in data
+"""
+    ArrowTypes.ToArrow(x) -> AbstractVector
+
+A lazy view over `x` that applies [`ArrowTypes.toarrow`](@ref) on `getindex`,
+with a concrete element type. Returns `x` itself when its element type is
+already a concrete natively supported arrow type indexed from 1.
+"""
 struct ToArrow{T,A} <: AbstractVector{T}
     data::A
 end
@@ -423,6 +449,9 @@ end
 Base.IndexStyle(::Type{<:ToArrow}) = Base.IndexLinear()
 Base.size(x::ToArrow) = (length(x.data),)
 Base.eltype(::Type{TA}) where {T,A,TA<:ToArrow{T,A}} = T
+# A conversion failure means "try the other Union branch"; anything else
+# (including InterruptException) must propagate.
+const _CONVERSION_ERRORS = Union{MethodError,InexactError,OverflowError,TypeError}
 function _convert(::Type{T}, x) where {T}
     if x isa T
         return x
@@ -430,10 +459,10 @@ function _convert(::Type{T}, x) where {T}
         # T was a promoted Union and x is not already one of
         # the concrete Union types, so we need to just try
         # to convert, recursively, to one of the Union types
-        # unfortunately not much we can do more efficiently here
         try
             return _convert(T.a, x)
-        catch
+        catch err
+            err isa _CONVERSION_ERRORS || rethrow()
             return _convert(T.b, x)
         end
     else
diff --git a/src/ArrowTypes/test/tests.jl b/src/ArrowTypes/test/tests.jl
index 22d8dd0e..083c2456 100644
--- a/src/ArrowTypes/test/tests.jl
+++ b/src/ArrowTypes/test/tests.jl
@@ -22,6 +22,21 @@ struct Person
     name::String
 end
 
+# Keep these fixtures at top level. Julia 1.0 does not permit type definitions
+# inside the local scope introduced by `@testset`.
+struct DateTimeTZ
+    instant::Int64
+    tz::String
+end
+
+struct Timestamp{TZ}
+    x::Int64
+end
+
+ArrowTypes.ArrowType(::Type{DateTimeTZ}) = Timestamp
+ArrowTypes.toarrow(x::DateTimeTZ) = Timestamp{Symbol(x.tz)}(x.instant)
+ArrowTypes.default(::Type{DateTimeTZ}) = DateTimeTZ(0, "UTC")
+
 @testset "ArrowTypes" begin
     @test ArrowTypes.ArrowKind(MyInt) == ArrowTypes.PrimitiveKind()
     @test ArrowTypes.ArrowKind(Person) == ArrowTypes.StructKind()
@@ -203,19 +218,6 @@ end
         @test x == [1, 3.14]
 
         @testset "respect non-missing concrete type" begin
-            struct DateTimeTZ
-                instant::Int64
-                tz::String
-            end
-
-            struct Timestamp{TZ}
-                x::Int64
-            end
-
-            ArrowTypes.ArrowType(::Type{DateTimeTZ}) = Timestamp
-            ArrowTypes.toarrow(x::DateTimeTZ) = Timestamp{Symbol(x.tz)}(x.instant)
-            ArrowTypes.default(::Type{DateTimeTZ}) = DateTimeTZ(0, "UTC")
-
             T = Union{DateTimeTZ,Missing}
             @test !ArrowTypes.concrete_or_concreteunion(ArrowTypes.ArrowType(T))
             @test eltype(ArrowTypes.ToArrow(T[missing])) == Union{Timestamp{:UTC},Missing}
diff --git a/src/FlatBuffers/builder.jl b/src/FlatBuffers/builder.jl
index 1ca11986..c3649994 100644
--- a/src/FlatBuffers/builder.jl
+++ b/src/FlatBuffers/builder.jl
@@ -14,11 +14,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-const fileIdentifierLength = 4
-
 """
 Scalar
-A Union of the Julia types `T <: Number` that are allowed in FlatBuffers schema
+The Julia scalar types allowed in a FlatBuffers schema: the fixed-width
+integers and floats, `Bool`, and `Enum`.
 """
 const Scalar =
     Union{Bool,Int8,Int16,Int32,Int64,UInt8,UInt16,UInt32,UInt64,Float32,Float64,Enum}
@@ -39,7 +38,6 @@ mutable struct Builder
     head::UOffsetT
     nested::Bool
     finished::Bool
-    sharedstrings::Dict{String,UOffsetT}
 end
 
 bytes(b::Builder) = getfield(b, :bytes)
@@ -53,21 +51,8 @@ Builder(size=0) = Builder(
     UOffsetT(size),
     false,
     false,
-    Dict{String,UOffsetT}(),
 )
 
-function reset!(b::Builder)
-    empty!(b.bytes)
-    empty!(b.vtable)
-    emtpy!(b.vtables)
-    empty!(b.sharedstrings)
-    b.minalign = 1
-    b.nested = false
-    b.finished = false
-    b.head = 0
-    return
-end
-
 Base.write(sink::Builder, o, x::Union{Bool,UInt8}) = sink.bytes[o + 1] = UInt8(x)
 function Base.write(sink::Builder, off, x::T) where {T}
     off += 1
@@ -80,9 +65,8 @@ Base.write(b::Builder, o, x::Float64) = write(b, o, reinterpret(UInt64, x))
 Base.write(b::Builder, o, x::Enum) = write(b, o, basetype(x)(x))
 
 """
-`finishedbytes` returns a pointer to the written data in the byte buffer.
-Panics if the builder is not in a finished state (which is caused by calling
-`finish!()`).
+`finishedbytes` returns a view of the written data in the byte buffer. It
+throws unless `finish!` has put the builder in a finished state.
 """
 function finishedbytes(b::Builder)
     assertfinished(b)
@@ -99,7 +83,7 @@ function startobject!(b::Builder, numfields)
 end
 
 """
-WriteVtable serializes the vtable for the current object, if applicable.
+`writevtable!` serializes the vtable for the current object, if applicable.
 
 Before writing out the vtable, this checks pre-existing vtables for equality
 to this one. If an equal vtable is found, point the object to the existing
@@ -134,10 +118,7 @@ function writevtable!(b::Builder)
     end
 
     # Search backwards through existing vtables, because similar vtables
-    # are likely to have been recently appended. See
-    # BenchmarkVtableDeduplication for a case in which this heuristic
-    # saves about 30% of the time used in writing objects with duplicate
-    # tables.
+    # are likely to have been recently appended.
     for i = length(b.vtables):-1:1
         # Find the other vtable, which is associated with `i`:
         vt2Offset = b.vtables[i]
@@ -146,7 +127,8 @@ function writevtable!(b::Builder)
 
         metadata = VtableMetadataFields * sizeof(VOffsetT)
         vt2End = vt2Start + vt2Len
-        vt2 = view(b.bytes, (vt2Start + metadata + 1):vt2End) #TODO: might need a +1 on the start of range here
+        # The field entries only (past the two metadata VOffsetTs).
+        vt2 = view(b.bytes, (vt2Start + metadata + 1):vt2End)
 
         # Compare the other vtable to the one under consideration.
         # If they are equal, store the offset and break:
@@ -205,7 +187,7 @@ function writevtable!(b::Builder)
 end
 
 """
-`endobject` writes data necessary to finish object construction.
+`endobject!` writes data necessary to finish object construction.
 """
 function endobject!(b::Builder)
     assertnested(b)
@@ -270,7 +252,7 @@ function prependoffsetslot!(b::Builder, o::Int, x::T, d) where {T}
 end
 
 """
-`startvector` initializes bookkeeping for writing a new vector.
+`startvector!` initializes bookkeeping for writing a new vector.
 
 A vector has the following format:
 <UOffsetT: number of elements in this vector>
@@ -285,7 +267,7 @@ function startvector!(b::Builder, elemSize, numElems, alignment)
 end
 
 """
-`endvector` writes data necessary to finish vector construction.
+`endvector!` writes data necessary to finish vector construction.
 """
 function endvector!(b::Builder, vectorNumElems)
     assertnested(b)
@@ -294,12 +276,6 @@ function endvector!(b::Builder, vectorNumElems)
     return offset(b)
 end
 
-function createsharedstring!(b::Builder, s::AbstractString)
-    get!(b.sharedstrings, s) do
-        createstring!(b, s)
-    end
-end
-
 """
 `createstring!` writes a null-terminated string as a vector.
 """
@@ -317,8 +293,6 @@ function createstring!(b::Builder, s::Union{AbstractString,AbstractVector{UInt8}
     return endvector!(b, sizeof(s))
 end
 
-createbytevector(b::Builder, v) = createstring!(b, v)
-
 function assertnested(b::Builder)
     # If you get this assert, you're in an object while trying to write
     # data that belongs outside of an object.
@@ -361,7 +335,7 @@ end
 If value `x` equals default `d`, then the slot will be set to zero and no
 other data will be written.
 """
-function prependslot!(b::Builder, o::Int, x::T, d, sh=false) where {T<:Scalar}
+function prependslot!(b::Builder, o::Int, x::T, d) where {T<:Scalar}
     if x != T(d)
         prepend!(b, x)
         slot!(b, o)
@@ -369,22 +343,6 @@ function prependslot!(b::Builder, o::Int, x::T, d, sh=false) where {T<:Scalar}
     return
 end
 
-"""
-`prependstructslot!` prepends a struct onto the object at vtable slot `o`.
-Structs are stored inline, so nothing additional is being added.
-In generated code, `d` is always 0.
-"""
-function prependstructslot!(b::Builder, voffset, x, d)
-    if x != d
-        assertnested(b)
-        if x != offset(b)
-            throw(ArgumentError("inline data write outside of object"))
-        end
-        slot!(b, voffset)
-    end
-    return
-end
-
 """
 `slot!` sets the vtable key `voffset` to the current location in the buffer.
 """
@@ -392,23 +350,6 @@ function slot!(b::Builder, slotnum)
     b.vtable[slotnum + 1] = offset(b)
 end
 
-# FinishWithFileIdentifier finalizes a buffer, pointing to the given `rootTable`.
-# as well as applys a file identifier
-function finishwithfileidentifier(b::Builder, rootTable, fid)
-    if length(fid) != fileIdentifierLength
-        error("incorrect file identifier length")
-    end
-    # In order to add a file identifier to the flatbuffer message, we need
-    # to prepare an alignment and file identifier length
-    prep!(b, b.minalign, sizeof(Int32) + fileIdentifierLength)
-    for i = fileIdentifierLength:-1:1
-        # place the file identifier
-        place!(b, fid[i])
-    end
-    # finish
-    finish!(b, rootTable)
-end
-
 """
 `finish!` finalizes a buffer, pointing to the given `rootTable`.
 """
@@ -427,7 +368,8 @@ function vtableEqual(a::Vector{UOffsetT}, objectStart, b::AbstractVector{UInt8})
     end
 
     for i = 0:(length(a) - 1)
-        x = read(IOBuffer(view(b, (i * sizeof(VOffsetT) + 1):length(b))), VOffsetT)
+        base = i * sizeof(VOffsetT)
+        x = VOffsetT(b[base + 1]) | (VOffsetT(b[base + 2]) << 8)
 
         # Skip vtable entries that indicate a default value.
         x == 0 && a[i + 1] == 0 && continue
diff --git a/src/FlatBuffers/table.jl b/src/FlatBuffers/table.jl
index a17d1cd0..0a42b6b9 100644
--- a/src/FlatBuffers/table.jl
+++ b/src/FlatBuffers/table.jl
@@ -21,8 +21,10 @@ The object containing the flatbuffer and positional information specific to the
 The `vtable` containing the offsets for specific members precedes `pos`.
 The actual values in the table follow `pos` offset and size of the vtable.
 
+Concrete subtypes declare:
+
 - `bytes::Vector{UInt8}`: the flatbuffer itself
-- `pos::Integer`:  the base position in `bytes` of the table
+- `pos::Base.Int`: the base position in `bytes` of the table
 """
 abstract type Table end
 abstract type Struct end
@@ -35,9 +37,6 @@ pos(x::TableOrStruct) = getfield(x, :pos)
 ==(a::T, b::T) where {T<:TableOrStruct} =
     all(getproperty(a, p) == getproperty(b, p) for p in propertynames(a))
 
-(::Type{T})(b::Builder) where {T<:TableOrStruct} =
-    T(b.bytes[(b.head + 1):end], get(b, b.head, Int32))
-
 getrootas(::Type{T}, bytes::Vector{UInt8}, offset) where {T<:Table} =
     init(T, bytes, offset + readbuffer(bytes, offset, UOffsetT))
 init(::Type{T}, bytes::Vector{UInt8}, pos::Integer) where {T<:TableOrStruct} = T(bytes, pos)
@@ -61,10 +60,6 @@ end
 "`indirect` retrieves the relative offset stored at `offset`."
 indirect(t::Table, off) = off + get(t, off, UOffsetT)
 
-getvalue(t, o, ::Type{Nothing}) = nothing
-getvalue(t, o, ::Type{T}) where {T<:Scalar} = get(t, pos(t) + o, T)
-getvalue(t, o, ::Type{T}) where {T<:Enum} = T(get(t, pos(t) + o, enumtype(T)))
-
 function Base.String(t::Table, off)
     off += get(t, off, UOffsetT)
     start = off + sizeof(UOffsetT)
@@ -72,13 +67,6 @@ function Base.String(t::Table, off)
     return unsafe_string(pointer(bytes(t), start + 1), len)
 end
 
-function bytevector(t::Table, off)
-    off += get(t, off, UOffsetT)
-    start = off + sizeof(UOffsetT)
-    len = get(t, off, UOffsetT)
-    return view(bytes(t), (start + 1):(start + len + 1))
-end
-
 """
 `vectorlen` retrieves the length of the vector whose offset is stored at
 `off` in this object.
@@ -128,49 +116,7 @@ Base.@propagate_inbounds function Base.getindex(A::Array{T,S}, i::Integer) where
     end
 end
 
-Base.@propagate_inbounds function Base.setindex!(A::Array{T,S}, v, i::Integer) where {T,S}
-    if T === S
-        return setindex!(A.data, v, i)
-    else
-        error("setindex! not supported for reference/table types")
-    end
-end
-
 function union(t::Table, off)
     off += pos(t)
     return off + get(t, off, UOffsetT)
 end
-
-function union!(t::Table, t2::Table, off)
-    off += pos(t)
-    t2.pos = off + get(t, off, UOffsetT)
-    t2.bytes = bytes(t)
-    return
-end
-
-"""
-GetVOffsetTSlot retrieves the VOffsetT that the given vtable location
-points to. If the vtable value is zero, the default value `d`
-will be returned.
-"""
-function getoffsetslot(t::Table, slot, d)
-    off = offset(t, slot)
-    if off == 0
-        return d
-    end
-    return off
-end
-
-"""
-`getslot` retrieves the `T` that the given vtable location
-points to. If the vtable value is zero, the default value `d`
-will be returned.
-"""
-function getslot(t::Table, slot, d::T) where {T}
-    off = offset(t, slot)
-    if off == 0
-        return d
-    end
-
-    return get(t, pos(t) + off, T)
-end
diff --git a/src/append.jl b/src/append.jl
deleted file mode 100644
index 1a5119e6..00000000
--- a/src/append.jl
+++ /dev/null
@@ -1,315 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-"""
-    Arrow.append(io::IO, tbl)
-    Arrow.append(file::String, tbl)
-    tbl |> Arrow.append(file)
-
-Append any [Tables.jl](https://github.com/JuliaData/Tables.jl)-compatible `tbl`
-to an existing arrow formatted file or IO. The existing arrow data must be in
-IPC stream format. Note that appending to the "feather formatted file" is _not_
-allowed, as this file format doesn't support appending. That means files written
-like `Arrow.write(filename::String, tbl)` _cannot_ be appended to; instead, you
-should write like `Arrow.write(filename::String, tbl; file=false)`.
-
-When an IO object is provided to be written on to, it must support seeking. For
-example, a file opened in `r+` mode or an `IOBuffer` that is readable, writable
-and seekable can be appended to, but not a network stream.
-
-Multiple record batches will be written based on the number of
-`Tables.partitions(tbl)` that are provided; by default, this is just
-one for a given table, but some table sources support automatic
-partitioning. Note you can turn multiple table objects into partitions
-by doing `Tables.partitioner([tbl1, tbl2, ...])`, but note that
-each table must have the exact same `Tables.Schema`.
-
-By default, `Arrow.append` will use multiple threads to write multiple
-record batches simultaneously (e.g. if julia is started with `julia -t 8`
-or the `JULIA_NUM_THREADS` environment variable is set).
-
-Supported keyword arguments to `Arrow.append` include:
-  * `alignment::Int=8`: specify the number of bytes to align buffers to when written in messages; strongly recommended to only use alignment values of 8 or 64 for modern memory cache line optimization
-  * `colmetadata=nothing`: the metadata that should be written as the table's columns' `custom_metadata` fields; must either be `nothing` or an `AbstractDict` of `column_name::Symbol => column_metadata` where `column_metadata` is an iterable of `<:AbstractString` pairs.
-  * `dictencode::Bool=false`: whether all columns should use dictionary encoding when being written; to dict encode specific columns, wrap the column/array in `Arrow.DictEncode(col)`
-  * `dictencodenested::Bool=false`: whether nested data type columns should also dict encode nested arrays/buffers; other language implementations [may not support this](https://arrow.apache.org/docs/status.html)
-  * `denseunions::Bool=true`: whether Julia `Vector{<:Union}` arrays should be written using the dense union layout; passing `false` will result in the sparse union layout
-  * `largelists::Bool=false`: causes list column types to be written with Int64 offset arrays; mainly for testing purposes; by default, Int64 offsets will be used only if needed
-  * `maxdepth::Int=$DEFAULT_MAX_DEPTH`: deepest allowed nested serialization level; this is provided by default to prevent accidental infinite recursion with mutually recursive data structures
-  * `metadata=Arrow.getmetadata(tbl)`: the metadata that should be written as the table's schema's `custom_metadata` field; must either be `nothing` or an iterable of `<:AbstractString` pairs.
-  * `ntasks::Int`: number of concurrent threaded tasks to allow while writing input partitions out as arrow record batches; default is no limit; to disable multithreaded writing, pass `ntasks=1`
-  * `convert::Bool`: whether certain arrow primitive types in the schema of `file` should be converted to Julia defaults for matching them to the schema of `tbl`; by default, `convert=true`.
-  * `file::Bool`: applicable when an `IO` is provided, whether it is a file; by default `file=false`.
-"""
-function append end
-
-append(io_or_file; kw...) = x -> append(io_or_file, x; kw...)
-
-function append(file::String, tbl; kwargs...)
-    open(file, isfile(file) ? "r+" : "w+") do io
-        append(io, tbl; file=true, kwargs...)
-    end
-
-    return file
-end
-
-function append(
-    io::IO,
-    tbl;
-    metadata=getmetadata(tbl),
-    colmetadata=nothing,
-    largelists::Bool=false,
-    denseunions::Bool=true,
-    dictencode::Bool=false,
-    dictencodenested::Bool=false,
-    alignment::Int=8,
-    maxdepth::Int=DEFAULT_MAX_DEPTH,
-    ntasks=Inf,
-    convert::Bool=true,
-    file::Bool=false,
-)
-    if ntasks < 1
-        throw(
-            ArgumentError(
-                "ntasks keyword argument must be > 0; pass `ntasks=1` to disable multithreaded writing",
-            ),
-        )
-    end
-
-    startpos = position(io)
-    seekend(io)
-    len = position(io) - startpos
-    seek(io, startpos) # leave the stream position unchanged
-
-    if len == 0 # empty file, not initialized, we can just write to it
-        kwargs = Dict{Symbol,Any}(
-            :largelists => largelists,
-            :denseunions => denseunions,
-            :dictencode => dictencode,
-            :dictencodenested => dictencodenested,
-            :alignment => alignment,
-            :maxdepth => maxdepth,
-            :metadata => metadata,
-            :colmetadata => colmetadata,
-        )
-        if isa(ntasks, Integer)
-            kwargs[:ntasks] = ntasks
-        end
-        write(io, tbl; kwargs...)
-    else
-        isstream, arrow_schema, compress = stream_properties(io; convert=convert)
-        if !isstream
-            throw(ArgumentError("append is supported only to files in arrow stream format"))
-        end
-        if compress isa Symbol && compress !== :lz4 && compress !== :zstd
-            throw(
-                ArgumentError(
-                    "unsupported compress keyword argument value: $compress. Valid values include `:lz4` or `:zstd`",
-                ),
-            )
-        end
-        append(
-            io,
-            tbl,
-            arrow_schema,
-            compress,
-            largelists,
-            denseunions,
-            dictencode,
-            dictencodenested,
-            alignment,
-            maxdepth,
-            ntasks,
-            metadata,
-            colmetadata,
-        )
-    end
-
-    return io
-end
-
-function append(
-    io::IO,
-    source,
-    arrow_schema,
-    compress,
-    largelists,
-    denseunions,
-    dictencode,
-    dictencodenested,
-    alignment,
-    maxdepth,
-    ntasks,
-    meta,
-    colmeta,
-)
-    seekend(io)
-    skip(io, -8) # overwrite last 8 bytes of last empty message footer
-
-    sch = Ref{Tables.Schema}(arrow_schema)
-    sync = OrderedSynchronizer()
-    msgs = Channel{Message}(ntasks)
-    dictencodings = Dict{Int64,Any}() # Lockable{DictEncoding}
-    # build messages
-    blocks = (Block[], Block[])
-    # start message writing from channel
-    threaded = ntasks > 1
-    tsk =
-        threaded ? (@wkspawn for msg in msgs
-            Base.write(io, msg, blocks, sch, alignment)
-        end) : (@async for msg in msgs
-            Base.write(io, msg, blocks, sch, alignment)
-        end)
-    anyerror = Threads.Atomic{Bool}(false)
-    errorref = Ref{Any}()
-    @sync for (i, tbl) in enumerate(Tables.partitions(source))
-        if anyerror[]
-            @error "error writing arrow data on partition = $(errorref[][3])" exception =
-                (errorref[][1], errorref[][2])
-            error("fatal error writing arrow data")
-        end
-        @debug "processing table partition i = $i"
-        tbl_cols = Tables.columns(tbl)
-        tbl_schema = Tables.schema(tbl_cols)
-
-        if !is_equivalent_schema(arrow_schema, tbl_schema)
-            throw(ArgumentError("Table schema does not match existing arrow file schema"))
-        end
-
-        if threaded
-            @wkspawn process_partition(
-                tbl_cols,
-                dictencodings,
-                largelists,
-                compress,
-                denseunions,
-                dictencode,
-                dictencodenested,
-                maxdepth,
-                sync,
-                msgs,
-                alignment,
-                i,
-                sch,
-                errorref,
-                anyerror,
-                meta,
-                colmeta,
-            )
-        else
-            @async process_partition(
-                tbl_cols,
-                dictencodings,
-                largelists,
-                compress,
-                denseunions,
-                dictencode,
-                dictencodenested,
-                maxdepth,
-                sync,
-                msgs,
-                alignment,
-                i,
-                sch,
-                errorref,
-                anyerror,
-                meta,
-                colmeta,
-            )
-        end
-    end
-    if anyerror[]
-        @error "error writing arrow data on partition = $(errorref[][3])" exception =
-            (errorref[][1], errorref[][2])
-        error("fatal error writing arrow data")
-    end
-    # close our message-writing channel, no further put!-ing is allowed
-    close(msgs)
-    # now wait for our message-writing task to finish writing
-    wait(tsk)
-
-    Base.write(
-        io,
-        Message(UInt8[], nothing, 0, true, false, Meta.Schema),
-        blocks,
-        sch,
-        alignment,
-    )
-
-    return io
-end
-
-function stream_properties(io::IO; convert::Bool=true)
-    startpos = position(io)
-    buff = similar(FILE_FORMAT_MAGIC_BYTES)
-    start_magic = read!(io, buff) == FILE_FORMAT_MAGIC_BYTES
-    seekend(io)
-    len = position(io) - startpos
-    skip(io, -length(FILE_FORMAT_MAGIC_BYTES))
-    end_magic = read!(io, buff) == FILE_FORMAT_MAGIC_BYTES
-    seek(io, startpos) # leave the stream position unchanged
-
-    isstream = !(len > 24 && start_magic && end_magic)
-    if isstream
-        stream = Stream(io, convert=convert)
-        for table in stream
-            # no need to scan further once we get compression information
-            (stream.compression[] !== nothing) && break
-        end
-        seek(io, startpos) # leave the stream position unchanged
-        return isstream, Tables.Schema(stream.names, stream.types), stream.compression[]
-    else
-        return isstream, nothing, nothing
-    end
-end
-
-function is_equivalent_schema(sch1::Tables.Schema, sch2::Tables.Schema)
-    (sch1.names == sch2.names) || (return false)
-    for (t1, t2) in zip(sch1.types, sch2.types)
-        tt1 = Base.nonmissingtype(t1)
-        tt2 = Base.nonmissingtype(t2)
-        if t1 == t2
-            continue
-        elseif tt1 <: AbstractVector && tt2 <: AbstractVector && eltype(tt1) == eltype(tt2)
-            continue
-        elseif isstructtype(tt1) && isstructtype(tt2)
-            is_equivalent_type_by_field(tt1, tt2)
-        else
-            return false
-        end
-    end
-    true
-end
-
-function is_equivalent_type_by_field(T1, T2)
-    n1 = fieldcount(T1)
-    n2 = fieldcount(T2)
-    n1 != n2 && return false
-
-    for i = 1:n1
-        fieldname(T1, i) == fieldname(T2, i) || return false
-
-        if fieldtype(T1, i) == fieldtype(T2, i)
-            continue
-        elseif isstructtype(T1) && isstructtype(T2)
-            is_equivalent_type_by_field(T1, T2) || continue
-        else
-            return false
-        end
-    end
-    true
-end
diff --git a/src/arraytypes/arraytypes.jl b/src/arraytypes/arraytypes.jl
deleted file mode 100644
index 58bab082..00000000
--- a/src/arraytypes/arraytypes.jl
+++ /dev/null
@@ -1,274 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-    Arrow.ArrowVector
-
-An abstract type that subtypes `AbstractVector`. Each specific arrow array type
-subtypes `ArrowVector`. See [`BoolVector`](@ref), [`Primitive`](@ref), [`List`](@ref),
-[`Map`](@ref), [`FixedSizeList`](@ref), [`Struct`](@ref), [`DenseUnion`](@ref),
-[`SparseUnion`](@ref), and [`DictEncoded`](@ref) for more details.
-"""
-abstract type ArrowVector{T} <: AbstractVector{T} end
-
-Base.IndexStyle(::Type{A}) where {A<:ArrowVector} = Base.IndexLinear()
-Base.similar(::Type{A}, dims::Dims) where {T,A<:ArrowVector{T}} = Vector{T}(undef, dims)
-validitybitmap(x::ArrowVector) = x.validity
-nullcount(x::ArrowVector) = validitybitmap(x).nc
-getmetadata(x::ArrowVector) = x.metadata
-Base.deleteat!(x::T, inds) where {T<:ArrowVector} = throw(
-    ArgumentError("`$T` does not support `deleteat!`; arrow data is by nature immutable"),
-)
-
-function toarrowvector(
-    x,
-    i=1,
-    de=Dict{Int64,Any}(),
-    ded=DictEncoding[],
-    meta=getmetadata(x);
-    compression::Union{Nothing,Symbol,LZ4FrameCompressor,ZstdCompressor}=nothing,
-    kw...,
-)
-    @debug "converting top-level column to arrow format: col = $(typeof(x)), compression = $compression, kw = $(values(kw))"
-    @debug x
-    A = arrowvector(x, i, 0, 0, de, ded, meta; compression=compression, kw...)
-    if compression isa LZ4FrameCompressor
-        A = compress(Meta.CompressionType.LZ4_FRAME, compression, A)
-    elseif compression isa ZstdCompressor
-        A = compress(Meta.CompressionType.ZSTD, compression, A)
-    elseif compression isa Symbol && compression == :lz4
-        comp = lz4_frame_compressor()
-        A = Base.@lock comp begin
-            compress(Meta.CompressionType.LZ4_FRAME, comp[], A)
-        end
-    elseif compression isa Symbol && compression == :zstd
-        comp = zstd_compressor()
-        A = Base.@lock comp begin
-            compress(Meta.CompressionType.ZSTD, comp[], A)
-        end
-    end
-    @debug "converted top-level column to arrow format: $(typeof(A))"
-    @debug A
-    return A
-end
-
-function arrowvector(
-    x,
-    i,
-    nl,
-    fi,
-    de,
-    ded,
-    meta;
-    dictencoding::Bool=false,
-    dictencode::Bool=false,
-    maxdepth::Int=DEFAULT_MAX_DEPTH,
-    kw...,
-)
-    if nl > maxdepth
-        error(
-            "reached nested serialization level ($nl) deeper than provided max depth argument ($(maxdepth)); to increase allowed nesting level, pass `maxdepth=X`",
-        )
-    end
-    T = maybemissing(eltype(x))
-    if !(x isa DictEncode) && !dictencoding && (dictencode || DataAPI.refarray(x) !== x)
-        x = DictEncode(x, dictencodeid(i, nl, fi))
-    elseif x isa DictEncoded
-        return arrowvector(
-            DictEncodeType,
-            x,
-            i,
-            nl,
-            fi,
-            de,
-            ded,
-            meta;
-            dictencode=dictencode,
-            kw...,
-        )
-    elseif !(x isa DictEncode)
-        x = ToArrow(x)
-    end
-    S = maybemissing(eltype(x))
-    if ArrowTypes.hasarrowname(T)
-        meta = _arrowtypemeta(
-            _normalizemeta(meta),
-            String(ArrowTypes.arrowname(T)),
-            String(ArrowTypes.arrowmetadata(T)),
-        )
-    end
-    return arrowvector(
-        S,
-        x,
-        i,
-        nl,
-        fi,
-        de,
-        ded,
-        meta;
-        dictencode=dictencode,
-        maxdepth=maxdepth,
-        kw...,
-    )
-end
-
-_normalizemeta(::Nothing) = nothing
-_normalizemeta(meta) = toidict(String(k) => String(v) for (k, v) in meta)
-
-_normalizecolmeta(::Nothing) = nothing
-_normalizecolmeta(colmeta) = toidict(
-    Symbol(k) => toidict(String(v1) => String(v2) for (v1, v2) in v) for (k, v) in colmeta
-)
-
-function _arrowtypemeta(::Nothing, n, m)
-    return toidict(("ARROW:extension:name" => n, "ARROW:extension:metadata" => m))
-end
-
-function _arrowtypemeta(meta, n, m)
-    dict = Dict(meta)
-    dict["ARROW:extension:name"] = n
-    dict["ARROW:extension:metadata"] = m
-    return toidict(dict)
-end
-
-# now we check for ArrowType converions and dispatch on ArrowKind
-function arrowvector(::Type{S}, x, i, nl, fi, de, ded, meta; kw...) where {S}
-    meta = _normalizemeta(meta)
-    return arrowvector(ArrowKind(S), x, i, nl, fi, de, ded, meta; kw...)
-end
-
-struct NullVector{T} <: ArrowVector{T}
-    data::MissingVector
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-Base.size(v::NullVector) = (length(v.data),)
-Base.getindex(v::NullVector{T}, i::Int) where {T} =
-    ArrowTypes.fromarrow(T, getindex(v.data, i))
-
-arrowvector(::NullKind, x, i, nl, fi, de, ded, meta; kw...) = NullVector{eltype(x)}(
-    MissingVector(length(x)),
-    isnothing(meta) ? nothing : toidict(meta),
-)
-compress(Z::Meta.CompressionType.T, comp, v::NullVector) =
-    Compressed{Z,NullVector}(v, CompressedBuffer[], length(v), length(v), Compressed[])
-
-function makenodesbuffers!(
-    col::NullVector,
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-)
-    push!(fieldnodes, FieldNode(length(col), length(col)))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    return bufferoffset
-end
-
-function writebuffer(io, col::NullVector, alignment)
-    return
-end
-
-"""
-    Arrow.ValidityBitmap
-
-A bit-packed array type where each bit corresponds to an element in an
-[`ArrowVector`](@ref), indicating whether that element is "valid" (bit == 1),
-or not (bit == 0). Used to indicate element missingness (whether it's null).
-
-If the null count of an array is zero, the `ValidityBitmap` will be "empty"
-and all elements are treated as "valid"/non-null.
-"""
-struct ValidityBitmap <: ArrowVector{Bool}
-    bytes::Vector{UInt8} # arrow memory blob
-    pos::Int # starting byte of validity bitmap
-    ℓ::Int # # of _elements_ (not bytes!) in bitmap (because bitpacking)
-    nc::Int # null count
-end
-
-Base.size(p::ValidityBitmap) = (p.ℓ,)
-nullcount(x::ValidityBitmap) = x.nc
-
-function ValidityBitmap(x)
-    T = eltype(x)
-    if !(T >: Missing)
-        return ValidityBitmap(UInt8[], 1, length(x), 0)
-    end
-    len = length(x)
-    blen = cld(len, 8)
-    bytes = Vector{UInt8}(undef, blen)
-    st = iterate(x)
-    nc = 0
-    b = 0xff
-    j = k = 1
-    for y in x
-        if y === missing
-            nc += 1
-            b = setbit(b, false, j)
-        end
-        j += 1
-        if j == 9
-            @inbounds bytes[k] = b
-            b = 0xff
-            j = 1
-            k += 1
-        end
-    end
-    if j > 1
-        bytes[k] = b
-    end
-    return ValidityBitmap(nc == 0 ? UInt8[] : bytes, 1, nc == 0 ? 0 : len, nc)
-end
-
-@propagate_inbounds function Base.getindex(p::ValidityBitmap, i::Integer)
-    # no boundscheck because parent array should do it
-    # if a validity bitmap is empty, it either means:
-    #   1) the parent array null_count is 0, so all elements are valid
-    #   2) parent array is also empty, so "all" elements are valid
-    p.nc == 0 && return true
-    # translate element index to bitpacked byte index
-    a, b = divrem(i - 1, 8) .+ (1, 1)
-    @inbounds byte = p.bytes[p.pos + a - 1]
-    # check individual bit of byte
-    return getbit(byte, b)
-end
-
-@propagate_inbounds function Base.setindex!(p::ValidityBitmap, v, i::Integer)
-    x = convert(Bool, v)
-    p.ℓ == 0 && !x && throw(BoundsError(p, i))
-    a, b = fldmod1(i, 8)
-    @inbounds byte = p.bytes[p.pos + a - 1]
-    @inbounds p.bytes[p.pos + a - 1] = setbit(byte, x, b)
-    return v
-end
-
-function writebitmap(io, col::ArrowVector, alignment)
-    v = col.validity
-    @debug "writing validity bitmap: nc = $(v.nc), n = $(cld(v.ℓ, 8))"
-    v.nc == 0 && return 0
-    n = Base.write(io, view(v.bytes, (v.pos):(v.pos + cld(v.ℓ, 8) - 1)))
-    return n + writezeros(io, paddinglength(n, alignment))
-end
-
-include("compressed.jl")
-include("primitive.jl")
-include("bool.jl")
-include("list.jl")
-include("fixedsizelist.jl")
-include("map.jl")
-include("struct.jl")
-include("unions.jl")
-include("dictencoding.jl")
-include("views.jl")
diff --git a/src/arraytypes/bool.jl b/src/arraytypes/bool.jl
deleted file mode 100644
index 29c1505a..00000000
--- a/src/arraytypes/bool.jl
+++ /dev/null
@@ -1,117 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-    Arrow.BoolVector
-
-A bit-packed array type, similar to [`ValidityBitmap`](@ref), but which
-holds boolean values, `true` or `false`.
-"""
-struct BoolVector{T} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    pos::Int
-    validity::ValidityBitmap
-    ℓ::Int64
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(p::BoolVector) = (p.ℓ,)
-
-@propagate_inbounds function Base.getindex(p::BoolVector{T}, i::Integer) where {T}
-    @boundscheck checkbounds(p, i)
-    if T >: Missing
-        @inbounds !p.validity[i] && return missing
-    end
-    a, b = fldmod1(i, 8)
-    @inbounds byte = p.arrow[p.pos + a - 1]
-    # check individual bit of byte
-    return ArrowTypes.fromarrow(T, getbit(byte, b))
-end
-
-@propagate_inbounds function Base.setindex!(p::BoolVector, v, i::Integer)
-    @boundscheck checkbounds(p, i)
-    x = convert(Bool, v)
-    a, b = fldmod1(i, 8)
-    @inbounds byte = p.arrow[p.pos + a - 1]
-    @inbounds p.arrow[p.pos + a - 1] = setbit(byte, x, b)
-    return v
-end
-
-arrowvector(::BoolKind, x::BoolVector, i, nl, fi, de, ded, meta; kw...) = x
-
-function arrowvector(::BoolKind, x, i, nl, fi, de, ded, meta; kw...)
-    validity = ValidityBitmap(x)
-    len = length(x)
-    blen = cld(len, 8)
-    bytes = Vector{UInt8}(undef, blen)
-    b = 0xff
-    j = k = 1
-    for y in x
-        if y === false
-            b = setbit(b, false, j)
-        end
-        j += 1
-        if j == 9
-            @inbounds bytes[k] = b
-            b = 0xff
-            j = 1
-            k += 1
-        end
-    end
-    if j > 1
-        bytes[k] = b
-    end
-    return BoolVector{eltype(x)}(bytes, 1, validity, len, meta)
-end
-
-function compress(Z::Meta.CompressionType.T, comp, p::P) where {P<:BoolVector}
-    len = length(p)
-    nc = nullcount(p)
-    validity = compress(Z, comp, p.validity)
-    data = compress(Z, comp, view(p.arrow, (p.pos):(p.pos + cld(p.ℓ, 8) - 1)))
-    return Compressed{Z,P}(p, [validity, data], len, nc, Compressed[])
-end
-
-function makenodesbuffers!(
-    col::BoolVector,
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-)
-    len = length(col)
-    nc = nullcount(col)
-    push!(fieldnodes, FieldNode(len, nc))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    # validity bitmap
-    blen = nc == 0 ? 0 : bitpackedbytes(len, alignment)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    # adjust buffer offset, make primitive array buffer
-    bufferoffset += blen
-    blen = bitpackedbytes(len, alignment)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    return bufferoffset + blen
-end
-
-function writebuffer(io, col::BoolVector, alignment)
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    writebitmap(io, col, alignment)
-    n = Base.write(io, view(col.arrow, (col.pos):(col.pos + cld(col.ℓ, 8) - 1)))
-    return n + writezeros(io, paddinglength(n, alignment))
-end
diff --git a/src/arraytypes/compressed.jl b/src/arraytypes/compressed.jl
deleted file mode 100644
index 070ca33b..00000000
--- a/src/arraytypes/compressed.jl
+++ /dev/null
@@ -1,98 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-struct CompressedBuffer
-    data::Vector{UInt8}
-    uncompressedlength::Int64
-end
-
-"""
-    Arrow.Compressed
-
-Represents the compressed version of an [`ArrowVector`](@ref).
-Holds a reference to the original column. May have `Compressed`
-children for nested array types.
-"""
-struct Compressed{Z,A}
-    data::A
-    buffers::Vector{CompressedBuffer}
-    len::Int64
-    nullcount::Int64
-    children::Vector{Compressed}
-end
-
-Base.length(c::Compressed) = c.len
-Base.eltype(::Type{C}) where {Z,A,C<:Compressed{Z,A}} = eltype(A)
-getmetadata(x::Compressed) = getmetadata(x.data)
-compressiontype(c::Compressed{Z}) where {Z} = Z
-
-function compress(Z::Meta.CompressionType.T, comp, x::Array)
-    GC.@preserve x begin
-        y = unsafe_wrap(Array, convert(Ptr{UInt8}, pointer(x)), sizeof(x))
-        return CompressedBuffer(transcode(comp, y), length(y))
-    end
-end
-
-compress(Z::Meta.CompressionType.T, comp, x) = compress(Z, comp, convert(Array, x))
-
-compress(Z::Meta.CompressionType.T, comp, v::ValidityBitmap) =
-    v.nc == 0 ? CompressedBuffer(UInt8[], 0) :
-    compress(Z, comp, view(v.bytes, (v.pos):(v.pos + cld(v.ℓ, 8) - 1)))
-
-function makenodesbuffers!(
-    col::Compressed,
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-)
-    push!(fieldnodes, FieldNode(col.len, col.nullcount))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    for buffer in col.buffers
-        blen = length(buffer.data) == 0 ? 0 : 8 + length(buffer.data)
-        push!(fieldbuffers, Buffer(bufferoffset, blen))
-        @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-        bufferoffset += padding(blen, alignment)
-    end
-    for child in col.children
-        bufferoffset =
-            makenodesbuffers!(child, fieldnodes, fieldbuffers, bufferoffset, alignment)
-    end
-    return bufferoffset
-end
-
-function writearray(io, b::CompressedBuffer)
-    if length(b.data) > 0
-        n = Base.write(io, b.uncompressedlength)
-        @debug "writing compressed buffer: uncompressedlength = $(b.uncompressedlength), n = $(length(b.data))"
-        @debug b.data
-        return n + Base.write(io, b.data)
-    end
-    return 0
-end
-
-function writebuffer(io, col::Compressed, alignment)
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    for buffer in col.buffers
-        n = writearray(io, buffer)
-        writezeros(io, paddinglength(n, alignment))
-    end
-    for child in col.children
-        writebuffer(io, child, alignment)
-    end
-    return
-end
diff --git a/src/arraytypes/dictencoding.jl b/src/arraytypes/dictencoding.jl
deleted file mode 100644
index 3e3576c5..00000000
--- a/src/arraytypes/dictencoding.jl
+++ /dev/null
@@ -1,418 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-    Arrow.DictEncoding
-
-Represents the "pool" of possible values for a [`DictEncoded`](@ref)
-array type. Whether the order of values is significant can be checked
-by looking at the `isOrdered` boolean field.
-
-The `S` type parameter, while not tied directly to any field, is the
-signed integer "index type" of the parent DictEncoded. We keep track
-of this in the DictEncoding in order to validate the length of the pool
-doesn't exceed the index type limit. The general workflow of writing arrow
-data means the initial schema will typically be based off the data in the
-first record batch, and subsequent record batches need to match the same
-schema exactly. For example, if a non-first record batch dict encoded column
-were to cause a DictEncoding pool to overflow on unique values, a fatal error
-should be thrown.
-"""
-mutable struct DictEncoding{T,S,A} <: ArrowVector{T}
-    id::Int64
-    data::A
-    isOrdered::Bool
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-indextype(::Type{DictEncoding{T,S,A}}) where {T,S,A} = S
-indextype(::T) where {T<:DictEncoding} = indextype(T)
-
-Base.size(d::DictEncoding) = size(d.data)
-
-@propagate_inbounds function Base.getindex(d::DictEncoding{T}, i::Integer) where {T}
-    @boundscheck checkbounds(d, i)
-    return @inbounds ArrowTypes.fromarrow(T, d.data[i])
-end
-
-# convenience wrapper to signal that an input column should be
-# dict encoded when written to the arrow format
-struct DictEncodeType{T} end
-getT(::Type{DictEncodeType{T}}) where {T} = T
-
-"""
-    Arrow.DictEncode(::AbstractVector, id::Integer=nothing)
-
-Signals that a column/array should be dictionary encoded when serialized
-to the arrow streaming/file format. An optional `id` number may be provided
-to signal that multiple columns should use the same pool when being
-dictionary encoded.
-"""
-struct DictEncode{T,A} <: AbstractVector{DictEncodeType{T}}
-    id::Int64
-    data::A
-end
-
-DictEncode(x::A, id=-1) where {A} = DictEncode{eltype(A),A}(id, x)
-Base.IndexStyle(::Type{<:DictEncode}) = Base.IndexLinear()
-Base.size(x::DictEncode) = (length(x.data),)
-Base.iterate(x::DictEncode, st...) = iterate(x.data, st...)
-Base.getindex(x::DictEncode, i::Int) = getindex(x.data, i)
-ArrowTypes.ArrowKind(::Type{<:DictEncodeType}) = DictEncodedKind()
-Base.copy(x::DictEncode) = DictEncode(x.data, x.id)
-
-"""
-    Arrow.DictEncoded
-
-A dictionary encoded array type (similar to a `PooledArray`). Behaves just
-like a normal array in most respects; internally, possible values are stored
-in the `encoding::DictEncoding` field, while the `indices::Vector{<:Integer}`
-field holds the "codes" of each element for indexing into the encoding pool.
-Any column/array can be dict encoding when serializing to the arrow format
-either by passing the `dictencode=true` keyword argument to [`Arrow.write`](@ref)
-(which causes _all_ columns to be dict encoded), or wrapping individual columns/
-arrays in [`Arrow.DictEncode(x)`](@ref).
-"""
-struct DictEncoded{T,S,A} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    validity::ValidityBitmap
-    indices::Vector{S}
-    encoding::DictEncoding{T,S,A}
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-DictEncoded(
-    b::Vector{UInt8},
-    v::ValidityBitmap,
-    inds::Vector{S},
-    encoding::DictEncoding{T,S,A},
-    meta,
-) where {S,T,A} = DictEncoded{T,S,A}(b, v, inds, encoding, meta)
-
-Base.size(d::DictEncoded) = size(d.indices)
-
-isdictencoded(d::DictEncoded) = true
-isdictencoded(x) = false
-isdictencoded(c::Compressed{Z,A}) where {Z,A<:DictEncoded} = true
-
-function signedtype(n::Integer)
-    typs = (Int8, Int16, Int32, Int64)
-    typs[something(findfirst(n .≤ typemax.(typs)), 4)]
-end
-
-signedtype(::Type{UInt8}) = Int8
-signedtype(::Type{UInt16}) = Int16
-signedtype(::Type{UInt32}) = Int32
-signedtype(::Type{UInt64}) = Int64
-signedtype(::Type{T}) where {T<:Signed} = T
-
-indtype(d::DictEncoded{T,S,A}) where {T,S,A} = S
-indtype(c::Compressed{Z,A}) where {Z,A<:DictEncoded} = indtype(c.data)
-
-dictencodeid(colidx, nestedlevel, fieldid) =
-    (Int64(nestedlevel) << 48) | (Int64(fieldid) << 32) | Int64(colidx)
-
-getid(d::DictEncoded) = d.encoding.id
-getid(c::Compressed{Z,A}) where {Z,A<:DictEncoded} = c.data.encoding.id
-
-function arrowvector(
-    ::DictEncodedKind,
-    x::DictEncoded,
-    i,
-    nl,
-    fi,
-    de,
-    ded,
-    meta;
-    dictencode::Bool=false,
-    dictencodenested::Bool=false,
-    kw...,
-)
-    id = x.encoding.id
-    # XXX This is a race condition if two workers hit this block at the same time, then they'll create
-    # distinct locks
-    if !haskey(de, id)
-        de[id] = Lockable(x.encoding)
-    else
-        encodinglockable = de[id]
-        Base.@lock encodinglockable begin
-            encoding = encodinglockable.value
-            # in this case, we just need to check if any values in our local pool need to be delta dicationary serialized
-            deltas = setdiff(x.encoding, encoding)
-            if !isempty(deltas)
-                ET = indextype(encoding)
-                if length(deltas) + length(encoding) > typemax(ET)
-                    error(
-                        "fatal error serializing dict encoded column with ref index type of $ET; subsequent record batch unique values resulted in $(length(deltas) + length(encoding)) unique values, which exceeds possible index values in $ET",
-                    )
-                end
-                data = arrowvector(
-                    deltas,
-                    i,
-                    nl,
-                    fi,
-                    de,
-                    ded,
-                    nothing;
-                    dictencode=dictencodenested,
-                    dictencodenested=dictencodenested,
-                    dictencoding=true,
-                    kw...,
-                )
-                push!(
-                    ded,
-                    DictEncoding{eltype(data),ET,typeof(data)}(
-                        id,
-                        data,
-                        false,
-                        getmetadata(data),
-                    ),
-                )
-                if typeof(encoding.data) <: ChainedVector
-                    append!(encoding.data, data)
-                else
-                    data2 = ChainedVector([encoding.data, data])
-                    encoding = DictEncoding{eltype(data2),ET,typeof(data2)}(
-                        id,
-                        data2,
-                        false,
-                        getmetadata(encoding),
-                    )
-                    de[id] = Lockable(encoding)
-                end
-            end
-        end
-    end
-    return x
-end
-
-function arrowvector(
-    ::DictEncodedKind,
-    x,
-    i,
-    nl,
-    fi,
-    de,
-    ded,
-    meta;
-    dictencode::Bool=false,
-    dictencodenested::Bool=false,
-    kw...,
-)
-    @assert x isa DictEncode
-    id = x.id == -1 ? dictencodeid(i, nl, fi) : x.id
-    x = x.data
-    len = length(x)
-    validity = ValidityBitmap(x)
-    # XXX This is a race condition if two workers hit this block at the same time, then they'll create
-    # distinct locks
-    if !haskey(de, id)
-        # dict encoding doesn't exist yet, so create for 1st time
-        if DataAPI.refarray(x) === x || DataAPI.refpool(x) === nothing
-            # need to encode ourselves
-            x = PooledArray(x; signed=true, compress=true)
-            inds = refa = DataAPI.refarray(x)
-            pool = DataAPI.refpool(x)
-        else
-            pool = DataAPI.refpool(x)
-            refa = DataAPI.refarray(x)
-            inds = copyto!(similar(Vector{signedtype(length(pool))}, length(refa)), refa)
-        end
-        # adjust to "offset" instead of index
-        inds .-= firstindex(refa)
-        data = arrowvector(
-            pool,
-            i,
-            nl,
-            fi,
-            de,
-            ded,
-            nothing;
-            dictencode=dictencodenested,
-            dictencodenested=dictencodenested,
-            dictencoding=true,
-            kw...,
-        )
-        encoding = DictEncoding{eltype(data),eltype(inds),typeof(data)}(
-            id,
-            data,
-            false,
-            getmetadata(data),
-        )
-        de[id] = Lockable(encoding)
-    else
-        # encoding already exists
-        # compute inds based on it
-        # if value doesn't exist in encoding, push! it
-        # also add to deltas updates
-        encodinglockable = de[id]
-        Base.@lock encodinglockable begin
-            encoding = encodinglockable.value
-            len = length(x)
-            ET = indextype(encoding)
-            pool = Dict{Union{eltype(encoding),eltype(x)},ET}(
-                a => (b - 1) for (b, a) in enumerate(encoding)
-            )
-            deltas = eltype(x)[]
-            inds = Vector{ET}(undef, len)
-            for (j, val) in enumerate(x)
-                @inbounds inds[j] = get!(pool, val) do
-                    push!(deltas, val)
-                    return length(pool)
-                end
-            end
-            if !isempty(deltas)
-                if length(deltas) + length(encoding) > typemax(ET)
-                    error(
-                        "fatal error serializing dict encoded column with ref index type of $ET; subsequent record batch unique values resulted in $(length(deltas) + length(encoding)) unique values, which exceeds possible index values in $ET",
-                    )
-                end
-                data = arrowvector(
-                    deltas,
-                    i,
-                    nl,
-                    fi,
-                    de,
-                    ded,
-                    nothing;
-                    dictencode=dictencodenested,
-                    dictencodenested=dictencodenested,
-                    dictencoding=true,
-                    kw...,
-                )
-                push!(
-                    ded,
-                    DictEncoding{eltype(data),ET,typeof(data)}(
-                        id,
-                        data,
-                        false,
-                        getmetadata(data),
-                    ),
-                )
-                if typeof(encoding.data) <: ChainedVector
-                    append!(encoding.data, data)
-                else
-                    data2 = ChainedVector([encoding.data, data])
-                    encoding = DictEncoding{eltype(data2),ET,typeof(data2)}(
-                        id,
-                        data2,
-                        false,
-                        getmetadata(encoding),
-                    )
-                    de[id] = Lockable(encoding)
-                end
-            end
-        end
-    end
-    if meta !== nothing && getmetadata(encoding) !== nothing
-        meta = toidict(merge!(Dict(meta), Dict(getmetadata(encoding))))
-    elseif getmetadata(encoding) !== nothing
-        meta = getmetadata(encoding)
-    end
-    return DictEncoded(UInt8[], validity, inds, encoding, meta)
-end
-
-@propagate_inbounds function Base.getindex(d::DictEncoded, i::Integer)
-    @boundscheck checkbounds(d, i)
-    @inbounds valid = d.validity[i]
-    !valid && return missing
-    @inbounds idx = d.indices[i]
-    return @inbounds d.encoding[idx + 1]
-end
-
-@propagate_inbounds function Base.setindex!(d::DictEncoded{T}, v, i::Integer) where {T}
-    @boundscheck checkbounds(d, i)
-    if v === missing
-        @inbounds d.validity[i] = false
-    else
-        ix = findfirst(d.encoding.data, v)
-        if ix === nothing
-            push!(d.encoding.data, v)
-            @inbounds d.indices[i] = length(d.encoding.data) - 1
-        else
-            @inbounds d.indices[i] = ix - 1
-        end
-    end
-    return v
-end
-
-function Base.copy(x::DictEncoded{T,S}) where {T,S}
-    pool = copy(x.encoding.data)
-    valid = x.validity
-    inds = x.indices
-    refs = copy(inds)
-    @inbounds for i = 1:length(inds)
-        refs[i] = refs[i] + one(S)
-    end
-    return PooledArray(
-        PooledArrays.RefArray(refs),
-        Dict{T,S}(val => i for (i, val) in enumerate(pool)),
-        pool,
-    )
-end
-
-function compress(Z::Meta.CompressionType.T, comp, x::A) where {A<:DictEncoded}
-    len = length(x)
-    nc = nullcount(x)
-    validity = compress(Z, comp, x.validity)
-    inds = compress(Z, comp, x.indices)
-    return Compressed{Z,A}(x, [validity, inds], len, nc, Compressed[])
-end
-
-function DataAPI.levels(x::DictEncoded)
-    rp = DataAPI.refpool(x)   # may contain missing values
-    Missing <: eltype(rp) || return rp
-    convert(AbstractArray{nonmissingtype(eltype(rp))}, deleteat!(rp, ismissing.(rp)))
-end
-
-function makenodesbuffers!(
-    col::DictEncoded{T,S},
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-) where {T,S}
-    len = length(col)
-    nc = nullcount(col)
-    push!(fieldnodes, FieldNode(len, nc))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    # validity bitmap
-    blen = nc == 0 ? 0 : bitpackedbytes(len, alignment)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    bufferoffset += blen
-    # indices
-    blen = sizeof(S) * len
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    bufferoffset += padding(blen, alignment)
-    return bufferoffset
-end
-
-DataAPI.refarray(x::DictEncoded{T,S}) where {T,S} = x.indices .+ one(S)
-
-DataAPI.refpool(x::DictEncoded) = copy(x.encoding.data)
-
-function writebuffer(io, col::DictEncoded, alignment)
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    writebitmap(io, col, alignment)
-    # write indices
-    n = writearray(io, col.indices)
-    @debug "writing array: col = $(typeof(col.indices)), n = $n, padded = $(padding(n, alignment))"
-    writezeros(io, paddinglength(n, alignment))
-    return
-end
diff --git a/src/arraytypes/fixedsizelist.jl b/src/arraytypes/fixedsizelist.jl
deleted file mode 100644
index 2558dd54..00000000
--- a/src/arraytypes/fixedsizelist.jl
+++ /dev/null
@@ -1,203 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-    Arrow.FixedSizeList
-
-An `ArrowVector` where each element is a "fixed size" list of some kind, like a `NTuple{N, T}`.
-"""
-struct FixedSizeList{T,A<:AbstractVector} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    validity::ValidityBitmap
-    data::A
-    ℓ::Int
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(l::FixedSizeList) = (l.ℓ,)
-
-@propagate_inbounds function Base.getindex(l::FixedSizeList{T}, i::Integer) where {T}
-    @boundscheck checkbounds(l, i)
-    S = Base.nonmissingtype(T)
-    X = ArrowTypes.ArrowKind(ArrowTypes.ArrowType(S))
-    N = ArrowTypes.getsize(X)
-    Y = ArrowTypes.gettype(X)
-    if X !== T && !(l.validity[i])
-        return missing
-    else
-        off = (i - 1) * N
-        if X === T && isbitstype(Y)
-            tup = _unsafe_load_tuple(NTuple{N,Y}, l.data, off + 1)
-        else
-            tup = ntuple(j -> l.data[off + j], N)
-        end
-        return ArrowTypes.fromarrow(T, tup)
-    end
-end
-
-function _unsafe_load_tuple(
-    ::Type{NTuple{N,T}},
-    bytes::Vector{UInt8},
-    i::Integer,
-) where {N,T}
-    x = Ref(bytes, i)
-    y = Ref{NTuple{N,T}}()
-    ArrowTypes._unsafe_cast!(y, x, N)
-    return y[]
-end
-
-@propagate_inbounds function Base.setindex!(l::FixedSizeList{T}, v::T, i::Integer) where {T}
-    @boundscheck checkbounds(l, i)
-    if v === missing
-        @inbounds l.validity[i] = false
-    else
-        N = ArrowTypes.getsize(
-            ArrowTypes.ArrowKind(ArrowTypes.ArrowType(Base.nonmissingtype(T))),
-        )
-        off = (i - 1) * N
-        foreach(1:N) do j
-            @inbounds l.data[off + j] = v[j]
-        end
-    end
-    return v
-end
-
-# lazy equal-spaced flattener
-struct ToFixedSizeList{T,N,A} <: AbstractVector{T}
-    data::A # A is AbstractVector of (AbstractVector or AbstractString)
-end
-
-origtype(::ToFixedSizeList{T,N,A}) where {T,N,A} = eltype(A)
-
-function ToFixedSizeList(input)
-    NT = ArrowTypes.ArrowKind(Base.nonmissingtype(eltype(input))) # typically NTuple{N, T}
-    return ToFixedSizeList{ArrowTypes.gettype(NT),ArrowTypes.getsize(NT),typeof(input)}(
-        input,
-    )
-end
-
-Base.IndexStyle(::Type{<:ToFixedSizeList}) = Base.IndexLinear()
-Base.size(x::ToFixedSizeList{T,N}) where {T,N} = (N * length(x.data),)
-
-Base.@propagate_inbounds function Base.getindex(
-    A::ToFixedSizeList{T,N},
-    i::Integer,
-) where {T,N}
-    @boundscheck checkbounds(A, i)
-    a, b = fldmod1(i, N)
-    @inbounds x = A.data[a]
-    return @inbounds x === missing ? ArrowTypes.default(T) : x[b]
-end
-
-# efficient iteration
-@inline function Base.iterate(
-    A::ToFixedSizeList{T,N},
-    (i, chunk, chunk_i, len)=(1, 1, 1, length(A)),
-) where {T,N}
-    i > len && return nothing
-    @inbounds y = A.data[chunk]
-    @inbounds x = y === missing ? ArrowTypes.default(T) : y[chunk_i]
-    if chunk_i == N
-        chunk += 1
-        chunk_i = 1
-    else
-        chunk_i += 1
-    end
-    return x, (i + 1, chunk, chunk_i, len)
-end
-
-arrowvector(::FixedSizeListKind, x::FixedSizeList, i, nl, fi, de, ded, meta; kw...) = x
-
-function arrowvector(
-    ::FixedSizeListKind{N,T},
-    x,
-    i,
-    nl,
-    fi,
-    de,
-    ded,
-    meta;
-    kw...,
-) where {N,T}
-    len = length(x)
-    validity = ValidityBitmap(x)
-    flat = ToFixedSizeList(x)
-    if eltype(flat) == UInt8
-        data = flat
-        S = origtype(flat)
-    else
-        data = arrowvector(flat, i, nl + 1, fi, de, ded, nothing; kw...)
-        S = withmissing(eltype(x), NTuple{N,eltype(data)})
-    end
-    return FixedSizeList{S,typeof(data)}(UInt8[], validity, data, len, meta)
-end
-
-function compress(Z::Meta.CompressionType.T, comp, x::FixedSizeList{T,A}) where {T,A}
-    len = length(x)
-    nc = nullcount(x)
-    validity = compress(Z, comp, x.validity)
-    buffers = [validity]
-    children = Compressed[]
-    if eltype(A) == UInt8
-        push!(buffers, compress(Z, comp, x.data))
-    else
-        push!(children, compress(Z, comp, x.data))
-    end
-    return Compressed{Z,typeof(x)}(x, buffers, len, nc, children)
-end
-
-function makenodesbuffers!(
-    col::FixedSizeList{T,A},
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-) where {T,A}
-    len = length(col)
-    nc = nullcount(col)
-    push!(fieldnodes, FieldNode(len, nc))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    # validity bitmap
-    blen = nc == 0 ? 0 : bitpackedbytes(len, alignment)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    bufferoffset += blen
-    if eltype(A) === UInt8
-        blen = ArrowTypes.getsize(ArrowTypes.ArrowKind(Base.nonmissingtype(T))) * len
-        push!(fieldbuffers, Buffer(bufferoffset, blen))
-        @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-        bufferoffset += padding(blen, alignment)
-    else
-        bufferoffset =
-            makenodesbuffers!(col.data, fieldnodes, fieldbuffers, bufferoffset, alignment)
-    end
-    return bufferoffset
-end
-
-function writebuffer(io, col::FixedSizeList{T,A}, alignment) where {T,A}
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    writebitmap(io, col, alignment)
-    # write values array
-    if eltype(A) === UInt8
-        n = writearray(io, UInt8, col.data)
-        @debug "writing array: col = $(typeof(col.data)), n = $n, padded = $(padding(n, alignment))"
-        writezeros(io, paddinglength(n, alignment))
-    else
-        writebuffer(io, col.data, alignment)
-    end
-    return
-end
diff --git a/src/arraytypes/list.jl b/src/arraytypes/list.jl
deleted file mode 100644
index 41ac66f9..00000000
--- a/src/arraytypes/list.jl
+++ /dev/null
@@ -1,260 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-struct Offsets{T<:Union{Int32,Int64}} <: ArrowVector{Tuple{T,T}}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    offsets::Vector{T}
-end
-
-Base.size(o::Offsets) = (length(o.offsets) - 1,)
-
-@propagate_inbounds function Base.getindex(o::Offsets, i::Integer)
-    @boundscheck checkbounds(o, i)
-    @inbounds lo = o.offsets[i] + 1
-    @inbounds hi = o.offsets[i + 1]
-    return lo, hi
-end
-
-"""
-    Arrow.List
-
-An `ArrowVector` where each element is a variable sized list of some kind, like an `AbstractVector` or `AbstractString`.
-"""
-struct List{T,O,A} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    validity::ValidityBitmap
-    offsets::Offsets{O}
-    data::A
-    ℓ::Int
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(l::List) = (l.ℓ,)
-
-@propagate_inbounds function Base.getindex(l::List{T}, i::Integer) where {T}
-    @boundscheck checkbounds(l, i)
-    @inbounds lo, hi = l.offsets[i]
-    S = Base.nonmissingtype(T)
-    K = ArrowTypes.ArrowKind(ArrowTypes.ArrowType(S))
-    # special-case Base.CodeUnits for ArrowTypes compat
-    if ArrowTypes.isstringtype(K) || S <: Base.CodeUnits
-        if S !== T
-            if S <: Base.CodeUnits
-                return l.validity[i] ?
-                       Base.CodeUnits(unsafe_string(pointer(l.data, lo), hi - lo + 1)) :
-                       missing
-            else
-                return l.validity[i] ?
-                       ArrowTypes.fromarrow(T, pointer(l.data, lo), hi - lo + 1) : missing
-            end
-        else
-            if S <: Base.CodeUnits
-                return Base.CodeUnits(unsafe_string(pointer(l.data, lo), hi - lo + 1))
-            else
-                return ArrowTypes.fromarrow(T, pointer(l.data, lo), hi - lo + 1)
-            end
-        end
-    elseif S !== T
-        return l.validity[i] ? ArrowTypes.fromarrow(T, view(l.data, lo:hi)) : missing
-    else
-        return ArrowTypes.fromarrow(T, view(l.data, lo:hi))
-    end
-end
-
-# @propagate_inbounds function Base.setindex!(l::List{T}, v, i::Integer) where {T}
-
-# end
-
-# internal interface definitions to be able to treat AbstractString/CodeUnits similarly
-_ncodeunits(x::AbstractString) = ncodeunits(x)
-_codeunits(x::AbstractString) = codeunits(x)
-_ncodeunits(x::Base.CodeUnits) = length(x)
-_codeunits(x::Base.CodeUnits) = x
-
-# an AbstractVector version of Iterators.flatten
-# code based on SentinelArrays.ChainedVector
-struct ToList{T,stringtype,A,I} <: AbstractVector{T}
-    data::Vector{A} # A is AbstractVector or AbstractString
-    inds::Vector{I}
-end
-
-origtype(::ToList{T,S,A,I}) where {T,S,A,I} = A
-liststringtype(::Type{ToList{T,S,A,I}}) where {T,S,A,I} = S
-function liststringtype(::List{T,O,A}) where {T,O,A}
-    ST = Base.nonmissingtype(T)
-    K = ArrowTypes.ArrowKind(ST)
-    return liststringtype(A) || ArrowTypes.isstringtype(K) || ST <: Base.CodeUnits # add the CodeUnits check for ArrowTypes compat for now
-end
-liststringtype(T) = false
-
-function ToList(input; largelists::Bool=false)
-    AT = eltype(input)
-    ST = Base.nonmissingtype(AT)
-    K = ArrowTypes.ArrowKind(ST)
-    stringtype = ArrowTypes.isstringtype(K) || ST <: Base.CodeUnits # add the CodeUnits check for ArrowTypes compat for now
-    T = stringtype ? UInt8 : eltype(ST)
-    len = stringtype ? _ncodeunits : length
-    data = AT[]
-    I = largelists ? Int64 : Int32
-    inds = I[0]
-    sizehint!(data, length(input))
-    sizehint!(inds, length(input))
-    totalsize = I(0)
-    for x in input
-        if x === missing
-            push!(data, missing)
-        else
-            push!(data, x)
-            totalsize += len(x)
-            if I === Int32 && totalsize > 2147483647
-                I = Int64
-                inds = convert(Vector{Int64}, inds)
-            end
-        end
-        push!(inds, totalsize)
-    end
-    return ToList{T,stringtype,AT,I}(data, inds)
-end
-
-Base.IndexStyle(::Type{<:ToList}) = Base.IndexLinear()
-Base.size(x::ToList{T,S,A,I}) where {T,S,A,I} = (isempty(x.inds) ? zero(I) : x.inds[end],)
-
-function Base.pointer(A::ToList{UInt8}, i::Integer)
-    chunk = searchsortedfirst(A.inds, i)
-    chunk = chunk > length(A.inds) ? 1 : (chunk - 1)
-    return pointer(A.data[chunk])
-end
-
-@inline function index(A::ToList, i::Integer)
-    chunk = searchsortedfirst(A.inds, i)
-    return chunk - 1, i - (@inbounds A.inds[chunk - 1])
-end
-
-Base.@propagate_inbounds function Base.getindex(
-    A::ToList{T,stringtype},
-    i::Integer,
-) where {T,stringtype}
-    @boundscheck checkbounds(A, i)
-    chunk, ix = index(A, i)
-    @inbounds x = A.data[chunk]
-    return @inbounds stringtype ? _codeunits(x)[ix] : x[ix]
-end
-
-Base.@propagate_inbounds function Base.setindex!(
-    A::ToList{T,stringtype},
-    v,
-    i::Integer,
-) where {T,stringtype}
-    @boundscheck checkbounds(A, i)
-    chunk, ix = index(A, i)
-    @inbounds x = A.data[chunk]
-    if stringtype
-        _codeunits(x)[ix] = v
-    else
-        x[ix] = v
-    end
-    return v
-end
-
-# efficient iteration
-@inline function Base.iterate(A::ToList{T,stringtype}) where {T,stringtype}
-    length(A) == 0 && return nothing
-    i = 1
-    chunk = 2
-    chunk_i = 1
-    chunk_len = A.inds[chunk]
-    while i > chunk_len
-        chunk += 1
-        chunk_len = A.inds[chunk]
-    end
-    val = A.data[chunk - 1]
-    x = stringtype ? _codeunits(val)[1] : val[1]
-    # find next valid index
-    i += 1
-    if i > chunk_len
-        while true
-            chunk += 1
-            chunk > length(A.inds) && break
-            chunk_len = A.inds[chunk]
-            i <= chunk_len && break
-        end
-    else
-        chunk_i += 1
-    end
-    return x, (i, chunk, chunk_i, chunk_len, length(A))
-end
-
-@inline function Base.iterate(
-    A::ToList{T,stringtype},
-    (i, chunk, chunk_i, chunk_len, len),
-) where {T,stringtype}
-    i > len && return nothing
-    @inbounds val = A.data[chunk - 1]
-    @inbounds x = stringtype ? _codeunits(val)[chunk_i] : val[chunk_i]
-    i += 1
-    if i > chunk_len
-        chunk_i = 1
-        while true
-            chunk += 1
-            chunk > length(A.inds) && break
-            @inbounds chunk_len = A.inds[chunk]
-            i <= chunk_len && break
-        end
-    else
-        chunk_i += 1
-    end
-    return x, (i, chunk, chunk_i, chunk_len, len)
-end
-
-arrowvector(::ListKind, x::List, i, nl, fi, de, ded, meta; kw...) = x
-
-function arrowvector(::ListKind, x, i, nl, fi, de, ded, meta; largelists::Bool=false, kw...)
-    len = length(x)
-    validity = ValidityBitmap(x)
-    flat = ToList(x; largelists=largelists)
-    offsets = Offsets(UInt8[], flat.inds)
-    if liststringtype(typeof(flat)) && eltype(flat) == UInt8 # binary or utf8string
-        data = flat
-        T = origtype(flat)
-    else
-        data =
-            arrowvector(flat, i, nl + 1, fi, de, ded, nothing; largelists=largelists, kw...)
-        T = withmissing(eltype(x), Vector{eltype(data)})
-    end
-    return List{T,eltype(flat.inds),typeof(data)}(
-        UInt8[],
-        validity,
-        offsets,
-        data,
-        len,
-        meta,
-    )
-end
-
-function compress(Z::Meta.CompressionType.T, comp, x::List{T,O,A}) where {T,O,A}
-    len = length(x)
-    nc = nullcount(x)
-    validity = compress(Z, comp, x.validity)
-    offsets = compress(Z, comp, x.offsets.offsets)
-    buffers = [validity, offsets]
-    children = Compressed[]
-    if liststringtype(x)
-        push!(buffers, compress(Z, comp, x.data))
-    else
-        push!(children, compress(Z, comp, x.data))
-    end
-    return Compressed{Z,typeof(x)}(x, buffers, len, nc, children)
-end
diff --git a/src/arraytypes/map.jl b/src/arraytypes/map.jl
deleted file mode 100644
index 42160732..00000000
--- a/src/arraytypes/map.jl
+++ /dev/null
@@ -1,146 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-    Arrow.Map
-
-An `ArrowVector` where each element is a "map" of some kind, like a `Dict`.
-"""
-struct Map{T,O,A} <: ArrowVector{T}
-    validity::ValidityBitmap
-    offsets::Offsets{O}
-    data::A
-    ℓ::Int
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(l::Map) = (l.ℓ,)
-
-@propagate_inbounds function Base.getindex(l::Map{T}, i::Integer) where {T}
-    @boundscheck checkbounds(l, i)
-    @inbounds lo, hi = l.offsets[i]
-    if Base.nonmissingtype(T) !== T
-        return l.validity[i] ?
-               ArrowTypes.fromarrow(
-            T,
-            Dict(x.key => x.value for x in view(l.data, lo:hi)),
-        ) : missing
-    else
-        return ArrowTypes.fromarrow(T, Dict(x.key => x.value for x in view(l.data, lo:hi)))
-    end
-end
-
-keyvalues(KT, ::Missing) = missing
-keyvalues(KT, x::AbstractDict) = [KT(k, v) for (k, v) in pairs(x)]
-
-keyvaluetypes(::Type{NamedTuple{(:key, :value),Tuple{K,V}}}) where {K,V} = (K, V)
-
-arrowvector(::MapKind, x::Map, i, nl, fi, de, ded, meta; kw...) = x
-
-function arrowvector(::MapKind, x, i, nl, fi, de, ded, meta; largelists::Bool=false, kw...)
-    len = length(x)
-    validity = ValidityBitmap(x)
-    ET = eltype(x)
-    DT = Base.nonmissingtype(ET)
-    KDT, VDT = keytype(DT), valtype(DT)
-    ArrowTypes.concrete_or_concreteunion(KDT) || throw(
-        ArgumentError(
-            "`keytype(d)` must be concrete to serialize map-like `d`, but `keytype(d) == $KDT`",
-        ),
-    )
-    ArrowTypes.concrete_or_concreteunion(VDT) || throw(
-        ArgumentError(
-            "`valtype(d)` must be concrete to serialize map-like `d`, but `valtype(d) == $VDT`",
-        ),
-    )
-    KT = KeyValue{KDT,VDT}
-    VT = Vector{KT}
-    T = DT !== ET ? Union{Missing,VT} : VT
-    flat = ToList(T[keyvalues(KT, y) for y in x]; largelists=largelists)
-    offsets = Offsets(UInt8[], flat.inds)
-    data = arrowvector(flat, i, nl + 1, fi, de, ded, nothing; largelists=largelists, kw...)
-    K, V = keyvaluetypes(eltype(data))
-    return Map{withmissing(ET, Dict{K,V}),eltype(flat.inds),typeof(data)}(
-        validity,
-        offsets,
-        data,
-        len,
-        meta,
-    )
-end
-
-function compress(Z::Meta.CompressionType.T, comp, x::A) where {A<:Map}
-    len = length(x)
-    nc = nullcount(x)
-    validity = compress(Z, comp, x.validity)
-    offsets = compress(Z, comp, x.offsets.offsets)
-    buffers = [validity, offsets]
-    children = Compressed[]
-    push!(children, compress(Z, comp, x.data))
-    return Compressed{Z,A}(x, buffers, len, nc, children)
-end
-
-function makenodesbuffers!(
-    col::Union{Map{T,O,A},List{T,O,A}},
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-) where {T,O,A}
-    len = length(col)
-    nc = nullcount(col)
-    push!(fieldnodes, FieldNode(len, nc))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    # validity bitmap
-    blen = nc == 0 ? 0 : bitpackedbytes(len, alignment)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    # adjust buffer offset, make array buffer
-    bufferoffset += blen
-    blen = sizeof(O) * (len + 1)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    bufferoffset += padding(blen, alignment)
-    if liststringtype(col)
-        blen = length(col.data)
-        push!(fieldbuffers, Buffer(bufferoffset, blen))
-        @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-        bufferoffset += padding(blen, alignment)
-    else
-        bufferoffset =
-            makenodesbuffers!(col.data, fieldnodes, fieldbuffers, bufferoffset, alignment)
-    end
-    return bufferoffset
-end
-
-function writebuffer(io, col::Union{Map{T,O,A},List{T,O,A}}, alignment) where {T,O,A}
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    writebitmap(io, col, alignment)
-    # write offsets
-    n = writearray(io, O, col.offsets.offsets)
-    @debug "writing array: col = $(typeof(col.offsets.offsets)), n = $n, padded = $(padding(n, alignment))"
-    writezeros(io, paddinglength(n, alignment))
-    # write values array
-    if liststringtype(col)
-        n = writearray(io, UInt8, col.data)
-        @debug "writing array: col = $(typeof(col.data)), n = $n, padded = $(padding(n, alignment))"
-        writezeros(io, paddinglength(n, alignment))
-    else
-        writebuffer(io, col.data, alignment)
-    end
-    return
-end
diff --git a/src/arraytypes/primitive.jl b/src/arraytypes/primitive.jl
deleted file mode 100644
index 7d86bfe0..00000000
--- a/src/arraytypes/primitive.jl
+++ /dev/null
@@ -1,112 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-    Arrow.Primitive
-
-An `ArrowVector` where each element is a "fixed size" scalar of some kind, like an integer, float, decimal, or time type.
-"""
-struct Primitive{T,A} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    validity::ValidityBitmap
-    data::A
-    ℓ::Int64
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Primitive(::Type{T}, b::Vector{UInt8}, v::ValidityBitmap, data::A, l, meta) where {T,A} =
-    Primitive{T,A}(b, v, data, l, meta)
-
-Base.size(p::Primitive) = (p.ℓ,)
-
-function Base.copy(p::Primitive{T,A}) where {T,A}
-    if nullcount(p) == 0 && T === eltype(A)
-        return copy(p.data)
-    else
-        return convert(Array, p)
-    end
-end
-
-@propagate_inbounds function Base.getindex(p::Primitive{T}, i::Integer) where {T}
-    @boundscheck checkbounds(p, i)
-    if T >: Missing
-        return @inbounds (p.validity[i] ? ArrowTypes.fromarrow(T, p.data[i]) : missing)
-    else
-        return @inbounds ArrowTypes.fromarrow(T, p.data[i])
-    end
-end
-
-@propagate_inbounds function Base.setindex!(p::Primitive{T}, v, i::Integer) where {T}
-    @boundscheck checkbounds(p, i)
-    if T >: Missing
-        if v === missing
-            @inbounds p.validity[i] = false
-        else
-            @inbounds p.data[i] = convert(Base.nonmissingtype(T), v)
-        end
-    else
-        @inbounds p.data[i] = convert(Base.nonmissingtype(T), v)
-    end
-    return v
-end
-
-arrowvector(::PrimitiveKind, x::Primitive, i, nl, fi, de, ded, meta; kw...) = x
-
-function arrowvector(::PrimitiveKind, x, i, nl, fi, de, ded, meta; kw...)
-    validity = ValidityBitmap(x)
-    return Primitive(eltype(x), UInt8[], validity, x, length(x), meta)
-end
-
-function compress(Z::Meta.CompressionType.T, comp, p::P) where {P<:Primitive}
-    len = length(p)
-    nc = nullcount(p)
-    validity = compress(Z, comp, p.validity)
-    data = compress(Z, comp, p.data)
-    return Compressed{Z,P}(p, [validity, data], len, nc, Compressed[])
-end
-
-function makenodesbuffers!(
-    col::Primitive{T},
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-) where {T}
-    len = length(col)
-    nc = nullcount(col)
-    push!(fieldnodes, FieldNode(len, nc))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    # validity bitmap
-    blen = nc == 0 ? 0 : bitpackedbytes(len, alignment)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    # adjust buffer offset, make primitive array buffer
-    bufferoffset += blen
-    blen = len * sizeof(Base.nonmissingtype(T))
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    return bufferoffset + padding(blen, alignment)
-end
-
-function writebuffer(io, col::Primitive{T}, alignment) where {T}
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    writebitmap(io, col, alignment)
-    n = writearray(io, Base.nonmissingtype(T), col.data)
-    @debug "writing array: col = $(typeof(col.data)), n = $n, padded = $(padding(n, alignment))"
-    writezeros(io, paddinglength(n, alignment))
-    return
-end
diff --git a/src/arraytypes/struct.jl b/src/arraytypes/struct.jl
deleted file mode 100644
index 23a8b641..00000000
--- a/src/arraytypes/struct.jl
+++ /dev/null
@@ -1,162 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-    Arrow.Struct
-
-An `ArrowVector` where each element is a "struct" of some kind with ordered, named fields, like a `NamedTuple{names, types}` or regular julia `struct`.
-"""
-struct Struct{T,S,fnames} <: ArrowVector{T}
-    validity::ValidityBitmap
-    data::S # Tuple of ArrowVector
-    ℓ::Int
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(s::Struct) = (s.ℓ,)
-
-isnamedtuple(::Type{<:NamedTuple}) = true
-isnamedtuple(T) = false
-istuple(::Type{<:Tuple}) = true
-istuple(T) = false
-
-if isdefined(ArrowTypes, :fromarrowstruct)
-    # https://github.com/apache/arrow-julia/pull/493
-    @inline function _fromarrowstruct(T::Type, v::Val, x...)
-        return ArrowTypes.fromarrowstruct(T, v, x...)
-    end
-else
-    @inline function _fromarrowstruct(T::Type, ::Val, x...)
-        return ArrowTypes.fromarrow(T, x...)
-    end
-end
-
-@propagate_inbounds function Base.getindex(
-    s::Struct{T,S,fnames},
-    i::Integer,
-) where {T,S,fnames}
-    @boundscheck checkbounds(s, i)
-    NT = Base.nonmissingtype(T)
-    NT !== T && (s.validity[i] || return missing)
-    vals = ntuple(j -> s.data[j][i], fieldcount(S))
-    if isnamedtuple(NT) || istuple(NT)
-        return NT(vals)
-    else
-        return _fromarrowstruct(NT, Val{fnames}(), vals...)
-    end
-end
-
-# @propagate_inbounds function Base.setindex!(s::Struct{T}, v::T, i::Integer) where {T}
-#     @boundscheck checkbounds(s, i)
-#     if v === missing
-#         @inbounds s.validity[i] = false
-#     else
-#         NT = Base.nonmissingtype(T)
-#         N = fieldcount(NT)
-#         foreach(1:N) do j
-#             @inbounds s.data[j][i] = getfield(v, j)
-#         end
-#     end
-#     return v
-# end
-
-struct ToStruct{T,i,A} <: AbstractVector{T}
-    data::A # eltype is NamedTuple or some struct
-end
-
-ToStruct(x::A, j::Integer) where {A} =
-    ToStruct{fieldtype(Base.nonmissingtype(eltype(A)), j),j,A}(x)
-
-Base.IndexStyle(::Type{<:ToStruct}) = Base.IndexLinear()
-Base.size(x::ToStruct) = (length(x.data),)
-
-Base.@propagate_inbounds function Base.getindex(A::ToStruct{T,j}, i::Integer) where {T,j}
-    @boundscheck checkbounds(A, i)
-    @inbounds x = A.data[i]
-    return x === missing ? ArrowTypes.default(T) : getfield(x, j)
-end
-
-arrowvector(::StructKind, x::Struct, i, nl, fi, de, ded, meta; kw...) = x
-
-namedtupletype(::Type{NamedTuple{names,types}}, data) where {names,types} =
-    NamedTuple{names,Tuple{(eltype(x) for x in data)...}}
-namedtupletype(::Type{T}, data) where {T} =
-    NamedTuple{fieldnames(T),Tuple{(eltype(x) for x in data)...}}
-namedtupletype(::Type{T}, data) where {T<:Tuple} =
-    NamedTuple{map(Symbol, fieldnames(T)),Tuple{(eltype(x) for x in data)...}}
-
-function arrowvector(::StructKind, x, i, nl, fi, de, ded, meta; kw...)
-    len = length(x)
-    validity = ValidityBitmap(x)
-    T = Base.nonmissingtype(eltype(x))
-    data = Tuple(
-        arrowvector(ToStruct(x, j), i, nl + 1, j, de, ded, nothing; kw...) for
-        j = 1:fieldcount(T)
-    )
-    NT = namedtupletype(T, data)
-    return Struct{withmissing(eltype(x), NT),typeof(data),fieldnames(NT)}(
-        validity,
-        data,
-        len,
-        meta,
-    )
-end
-
-function compress(Z::Meta.CompressionType.T, comp, x::A) where {A<:Struct}
-    len = length(x)
-    nc = nullcount(x)
-    validity = compress(Z, comp, x.validity)
-    buffers = [validity]
-    children = Compressed[]
-    for y in x.data
-        push!(children, compress(Z, comp, y))
-    end
-    return Compressed{Z,A}(x, buffers, len, nc, children)
-end
-
-function makenodesbuffers!(
-    col::Struct{T},
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-) where {T}
-    len = length(col)
-    nc = nullcount(col)
-    push!(fieldnodes, FieldNode(len, nc))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    # validity bitmap
-    blen = nc == 0 ? 0 : bitpackedbytes(len, alignment)
-    push!(fieldbuffers, Buffer(bufferoffset, blen))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    bufferoffset += blen
-    for child in col.data
-        bufferoffset =
-            makenodesbuffers!(child, fieldnodes, fieldbuffers, bufferoffset, alignment)
-    end
-    return bufferoffset
-end
-
-function writebuffer(io, col::Struct, alignment)
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    writebitmap(io, col, alignment)
-    # write values arrays
-    for child in col.data
-        writebuffer(io, child, alignment)
-    end
-    return
-end
diff --git a/src/arraytypes/unions.jl b/src/arraytypes/unions.jl
deleted file mode 100644
index ab4673d9..00000000
--- a/src/arraytypes/unions.jl
+++ /dev/null
@@ -1,345 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Union arrays
-# need a custom representation of Union types since arrow unions
-# are ordered, and possibly indirected via separate typeIds array
-# here, T is Meta.UnionMode.Dense or Meta.UnionMode.Sparse,
-# typeIds is a NTuple{N, Int32}, and U is a Tuple{...} of the
-# unioned types
-struct UnionT{T,typeIds,U} end
-
-unionmode(::Type{UnionT{T,typeIds,U}}) where {T,typeIds,U} = T
-typeids(::Type{UnionT{T,typeIds,U}}) where {T,typeIds,U} = typeIds
-Base.eltype(::Type{UnionT{T,typeIds,U}}) where {T,typeIds,U} = U
-uniontypewith(::Type{UnionT{T,typeIds,U}}, ::Type{U2}) where {T,typeIds,U,U2<:Tuple} =
-    UnionT{T,typeIds,U2}
-
-ArrowTypes.ArrowKind(::Type{<:UnionT}) = ArrowTypes.UnionKind()
-
-# iterate a Julia Union{...} type, producing an array of unioned types
-function eachunion(U::Union, elems=nothing)
-    if elems === nothing
-        return eachunion(U.b, Type[U.a])
-    else
-        push!(elems, U.a)
-        return eachunion(U.b, elems)
-    end
-end
-
-function eachunion(T, elems)
-    push!(elems, T)
-    return elems
-end
-
-# produce typeIds, offsets, data tuple for DenseUnion
-isatypeid(x::T, ::Type{types}) where {T,types} = isatypeid(x, fieldtype(types, 1), types, 1)
-isatypeid(x::T, ::Type{S}, ::Type{types}, i) where {T,S,types} =
-    x isa S ? i : isatypeid(x, fieldtype(types, i + 1), types, i + 1)
-
-"""
-    Arrow.DenseUnion
-
-An `ArrowVector` where the type of each element is one of a fixed set of types, meaning its eltype is like a julia `Union{type1, type2, ...}`.
-An `Arrow.DenseUnion`, in comparison to `Arrow.SparseUnion`, stores elements in a set of arrays, one array per possible type, and an "offsets"
-array, where each offset element is the index into one of the typed arrays. This allows a sort of "compression", where no extra space is
-used/allocated to store all the elements.
-"""
-struct DenseUnion{T,U,S} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    arrow2::Vector{UInt8} # if arrow blob is compressed, need a 2nd reference for uncompressed offsets bytes
-    typeIds::Vector{UInt8}
-    offsets::Vector{Int32}
-    data::S # Tuple of ArrowVector
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(s::DenseUnion) = size(s.typeIds)
-nullcount(x::DenseUnion) = 0 # DenseUnion has no validity bitmap; only children do
-
-@propagate_inbounds function Base.getindex(
-    s::DenseUnion{T,UnionT{M,typeIds,U}},
-    i::Integer,
-) where {T,M,typeIds,U}
-    @boundscheck checkbounds(s, i)
-    @inbounds typeId = s.typeIds[i]
-    @inbounds off = s.offsets[i]
-    @inbounds x = s.data[typeId + 1][off + 1]
-    return ArrowTypes.fromarrow(fieldtype(U, typeId + 1), x)
-end
-
-# @propagate_inbounds function Base.setindex!(s::DenseUnion{UnionT{T, typeIds, U}}, v, i::Integer) where {T, typeIds, U}
-#     @boundscheck checkbounds(s, i)
-#     @inbounds typeId = s.typeIds[i]
-#     typeids = typeIds === nothing ? (0:(fieldcount(U) - 1)) : typeIds
-#     vtypeId = Int8(typeids[isatypeid(v, U)])
-#     if typeId == vtypeId
-#         @inbounds off = s.offsets[i]
-#         @inbounds s.data[typeId +1][off + 1] = v
-#     else
-#         throw(ArgumentError("type of item to set $(typeof(v)) must match existing item $(fieldtype(U, typeid))"))
-#     end
-#     return v
-# end
-
-# convenience wrappers for signaling that an array shoudld be written
-# as with dense/sparse union arrow buffers
-struct DenseUnionVector{T,U} <: AbstractVector{UnionT{Meta.UnionMode.Dense,nothing,U}}
-    itr::T
-end
-
-DenseUnionVector(x::T) where {T} = DenseUnionVector{T,Tuple{eachunion(eltype(x))...}}(x)
-Base.IndexStyle(::Type{<:DenseUnionVector}) = Base.IndexLinear()
-Base.size(x::DenseUnionVector) = (length(x.itr),)
-Base.iterate(x::DenseUnionVector, st...) = iterate(x.itr, st...)
-Base.getindex(x::DenseUnionVector, i::Int) = getindex(x.itr, i)
-
-function todense(::Type{UnionT{T,typeIds,U}}, x) where {T,typeIds,U}
-    typeids = typeIds === nothing ? (0:(fieldcount(U) - 1)) : typeIds
-    len = length(x)
-    types = Vector{UInt8}(undef, len)
-    offsets = Vector{Int32}(undef, len)
-    data = Tuple(
-        Vector{i == 1 ? Union{Missing,fieldtype(U, i)} : fieldtype(U, i)}(undef, 0) for
-        i = 1:fieldcount(U)
-    )
-    for (i, y) in enumerate(x)
-        typeid = y === missing ? 0x00 : UInt8(typeids[isatypeid(y, U)])
-        @inbounds types[i] = typeid
-        @inbounds offsets[i] = length(data[typeid + 1])
-        push!(data[typeid + 1], y)
-    end
-    return types, offsets, data
-end
-
-struct SparseUnionVector{T,U} <: AbstractVector{UnionT{Meta.UnionMode.Sparse,nothing,U}}
-    itr::T
-end
-
-SparseUnionVector(x::T) where {T} = SparseUnionVector{T,Tuple{eachunion(eltype(x))...}}(x)
-Base.IndexStyle(::Type{<:SparseUnionVector}) = Base.IndexLinear()
-Base.size(x::SparseUnionVector) = (length(x.itr),)
-Base.iterate(x::SparseUnionVector, st...) = iterate(x.itr, st...)
-Base.getindex(x::SparseUnionVector, i::Int) = getindex(x.itr, i)
-
-# sparse union child array producer
-# for sparse unions, we split the parent array into
-# N children arrays, each having the same length as the parent
-# but with one child array per unioned type; each child
-# should include the elements from parent of its type
-# and other elements can be missing/default
-function sparsetypeids(::Type{UnionT{T,typeIds,U}}, x) where {T,typeIds,U}
-    typeids = typeIds === nothing ? (0:(fieldcount(U) - 1)) : typeIds
-    len = length(x)
-    types = Vector{UInt8}(undef, len)
-    for (i, y) in enumerate(x)
-        typeid = y === missing ? 0x00 : UInt8(typeids[isatypeid(y, U)])
-        @inbounds types[i] = typeid
-    end
-    return types
-end
-
-struct ToSparseUnion{T,A} <: AbstractVector{T}
-    data::A
-end
-
-ToSparseUnion(::Type{T}, data::A) where {T,A} = ToSparseUnion{T,A}(data)
-
-Base.IndexStyle(::Type{<:ToSparseUnion}) = Base.IndexLinear()
-Base.size(x::ToSparseUnion) = (length(x.data),)
-
-Base.@propagate_inbounds function Base.getindex(A::ToSparseUnion{T}, i::Integer) where {T}
-    @boundscheck checkbounds(A, i)
-    @inbounds x = A.data[i]
-    return @inbounds x isa T ? x : ArrowTypes.default(T)
-end
-
-function compress(Z::Meta.CompressionType.T, comp, x::A) where {A<:DenseUnion}
-    len = length(x)
-    nc = nullcount(x)
-    typeIds = compress(Z, comp, x.typeIds)
-    offsets = compress(Z, comp, x.offsets)
-    buffers = [typeIds, offsets]
-    children = Compressed[]
-    for y in x.data
-        push!(children, compress(Z, comp, y))
-    end
-    return Compressed{Z,A}(x, buffers, len, nc, children)
-end
-
-"""
-    Arrow.SparseUnion
-
-An `ArrowVector` where the type of each element is one of a fixed set of types, meaning its eltype is like a julia `Union{type1, type2, ...}`.
-An `Arrow.SparseUnion`, in comparison to `Arrow.DenseUnion`, stores elements in a set of arrays, one array per possible type, and each typed
-array has the same length as the full array. This ends up with "wasted" space, since only one slot among the typed arrays is valid per full
-array element, but can allow for certain optimizations when each typed array has the same length.
-"""
-struct SparseUnion{T,U,S} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    typeIds::Vector{UInt8}
-    data::S # Tuple of ArrowVector
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(s::SparseUnion) = size(s.typeIds)
-nullcount(x::SparseUnion) = 0
-
-@propagate_inbounds function Base.getindex(
-    s::SparseUnion{T,UnionT{M,typeIds,U}},
-    i::Integer,
-) where {T,M,typeIds,U}
-    @boundscheck checkbounds(s, i)
-    @inbounds typeId = s.typeIds[i]
-    @inbounds x = s.data[typeId + 1][i]
-    return ArrowTypes.fromarrow(fieldtype(U, typeId + 1), x)
-end
-
-# @propagate_inbounds function Base.setindex!(s::SparseUnion{UnionT{T, typeIds, U}}, v, i::Integer) where {T, typeIds, U}
-#     @boundscheck checkbounds(s, i)
-#     typeids = typeIds === nothing ? (0:(fieldcount(U) - 1)) : typeIds
-#     vtypeId = Int8(typeids[isatypeid(v, U)])
-#     @inbounds s.typeIds[i] = vtypeId
-#     @inbounds s.data[vtypeId + 1][i] = v
-#     return v
-# end
-
-arrowvector(U::Union, x, i, nl, fi, de, ded, meta; denseunions::Bool=true, kw...) =
-    arrowvector(
-        denseunions ? DenseUnionVector(x) : SparseUnionVector(x),
-        i,
-        nl,
-        fi,
-        de,
-        ded,
-        meta;
-        denseunions=denseunions,
-        kw...,
-    )
-
-arrowvector(
-    ::UnionKind,
-    x::Union{DenseUnion,SparseUnion},
-    i,
-    nl,
-    fi,
-    de,
-    ded,
-    meta;
-    kw...,
-) = x
-
-function arrowvector(::UnionKind, x, i, nl, fi, de, ded, meta; kw...)
-    UT = eltype(x)
-    if unionmode(UT) == Meta.UnionMode.Dense
-        x = x isa DenseUnionVector ? x.itr : x
-        typeids, offsets, data = todense(UT, x)
-        data2 = map(
-            y -> arrowvector(y[2], i, nl + 1, y[1], de, ded, nothing; kw...),
-            enumerate(data),
-        )
-        UT2 = uniontypewith(UT, Tuple{(eltype(x) for x in data2)...})
-        return DenseUnion{Union{(eltype(x) for x in data2)...},UT2,typeof(data2)}(
-            UInt8[],
-            UInt8[],
-            typeids,
-            offsets,
-            data2,
-            meta,
-        )
-    else
-        x = x isa SparseUnionVector ? x.itr : x
-        typeids = sparsetypeids(UT, x)
-        data3 = Tuple(
-            arrowvector(
-                ToSparseUnion(fieldtype(eltype(UT), j), x),
-                i,
-                nl + 1,
-                j,
-                de,
-                ded,
-                nothing;
-                kw...,
-            ) for j = 1:fieldcount(eltype(UT))
-        )
-        UT2 = uniontypewith(UT, Tuple{(eltype(x) for x in data3)...})
-        return SparseUnion{Union{(eltype(x) for x in data3)...},UT2,typeof(data3)}(
-            UInt8[],
-            typeids,
-            data3,
-            meta,
-        )
-    end
-end
-
-function compress(Z::Meta.CompressionType.T, comp, x::A) where {A<:SparseUnion}
-    len = length(x)
-    nc = nullcount(x)
-    typeIds = compress(Z, comp, x.typeIds)
-    buffers = [typeIds]
-    children = Compressed[]
-    for y in x.data
-        push!(children, compress(Z, comp, y))
-    end
-    return Compressed{Z,A}(x, buffers, len, nc, children)
-end
-
-function makenodesbuffers!(
-    col::Union{DenseUnion,SparseUnion},
-    fieldnodes,
-    fieldbuffers,
-    bufferoffset,
-    alignment,
-)
-    len = length(col)
-    nc = nullcount(col)
-    push!(fieldnodes, FieldNode(len, nc))
-    @debug "made field node: nodeidx = $(length(fieldnodes)), col = $(typeof(col)), len = $(fieldnodes[end].length), nc = $(fieldnodes[end].null_count)"
-    # typeIds buffer
-    push!(fieldbuffers, Buffer(bufferoffset, len))
-    @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-    bufferoffset += padding(len, alignment)
-    if col isa DenseUnion
-        # offsets buffer
-        blen = sizeof(Int32) * len
-        push!(fieldbuffers, Buffer(bufferoffset, blen))
-        @debug "made field buffer: bufferidx = $(length(fieldbuffers)), offset = $(fieldbuffers[end].offset), len = $(fieldbuffers[end].length), padded = $(padding(fieldbuffers[end].length, alignment))"
-        bufferoffset += padding(blen, alignment)
-    end
-    for child in col.data
-        bufferoffset =
-            makenodesbuffers!(child, fieldnodes, fieldbuffers, bufferoffset, alignment)
-    end
-    return bufferoffset
-end
-
-function writebuffer(io, col::Union{DenseUnion,SparseUnion}, alignment)
-    @debug "writebuffer: col = $(typeof(col))"
-    @debug col
-    # typeIds buffer
-    n = writearray(io, UInt8, col.typeIds)
-    @debug "writing array: col = $(typeof(col.typeIds)), n = $n, padded = $(padding(n, alignment))"
-    writezeros(io, paddinglength(n, alignment))
-    if col isa DenseUnion
-        n = writearray(io, Int32, col.offsets)
-        @debug "writing array: col = $(typeof(col.offsets)), n = $n, padded = $(padding(n, alignment))"
-        writezeros(io, paddinglength(n, alignment))
-    end
-    for child in col.data
-        writebuffer(io, child, alignment)
-    end
-    return
-end
diff --git a/src/arraytypes/views.jl b/src/arraytypes/views.jl
deleted file mode 100644
index 0a43f6fc..00000000
--- a/src/arraytypes/views.jl
+++ /dev/null
@@ -1,80 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-struct ViewElement
-    length::Int32
-    prefix::Int32
-    bufindex::Int32
-    offset::Int32
-end
-
-"""
-    Arrow.View
-
-An `ArrowVector` where each element is a variable sized list of some kind, like an `AbstractVector` or `AbstractString`.
-"""
-struct View{T} <: ArrowVector{T}
-    arrow::Vector{UInt8} # need to hold a reference to arrow memory blob
-    validity::ValidityBitmap
-    data::Vector{ViewElement}
-    inline::Vector{UInt8} # `data` field reinterpreted as a byte array
-    buffers::Vector{Vector{UInt8}} # holds non-inlined data
-    ℓ::Int
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-end
-
-Base.size(l::View) = (l.ℓ,)
-
-@propagate_inbounds function Base.getindex(l::View{T}, i::Integer) where {T}
-    @boundscheck checkbounds(l, i)
-    @inbounds v = l.data[i]
-    S = Base.nonmissingtype(T)
-    if S <: Base.CodeUnits
-        # BinaryView
-        return !l.validity[i] ? missing :
-               v.length < 13 ?
-               Base.CodeUnits(
-            StringView(
-                @view l.inline[(((i - 1) * 16) + 5):(((i - 1) * 16) + 5 + v.length - 1)]
-            ),
-        ) :
-               Base.CodeUnits(
-            StringView(
-                @view l.buffers[v.bufindex + 1][(v.offset + 1):(v.offset + v.length)]
-            ),
-        )
-    else
-        # Utf8View
-        return !l.validity[i] ? missing :
-               v.length < 13 ?
-               ArrowTypes.fromarrow(
-            T,
-            StringView(
-                @view l.inline[(((i - 1) * 16) + 5):(((i - 1) * 16) + 5 + v.length - 1)]
-            ),
-        ) :
-               ArrowTypes.fromarrow(
-            T,
-            StringView(
-                @view l.buffers[v.bufindex + 1][(v.offset + 1):(v.offset + v.length)]
-            ),
-        )
-    end
-end
-
-# @propagate_inbounds function Base.setindex!(l::List{T}, v, i::Integer) where {T}
-
-# end
diff --git a/src/arrowtypes.jl b/src/arrowtypes.jl
new file mode 100644
index 00000000..ada72de8
--- /dev/null
+++ b/src/arrowtypes.jl
@@ -0,0 +1,1756 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# ArrowTypes is a facade concern. ArrowCore stays dependency- and
+# conversion-free; this layer interprets the standard extension metadata on
+# materialized values and supplies the shared metadata helpers used by the
+# writer. An unregistered extension type stays an ordinary Arrow storage
+# value; the format requires readers to accept that.
+
+const _EXTENSION_NAME_KEY = "ARROW:extension:name"
+const _EXTENSION_METADATA_KEY = "ARROW:extension:metadata"
+const _MAX_ARROWTYPE_EXACT_ARITY = 1024
+const _MAX_ARROWTYPE_UNION_BRANCHES = 32
+const _MAX_ARROWTYPE_SCHEMA_NAME_BYTES = 4096
+const _MAX_ARROWTYPE_STRUCT_NAME_BYTES = 64 * 1024
+const _MAX_EXTENSION_WARNING_BYTES = 128
+const _MAX_EXTENSION_WARNINGS = 16
+
+# Look a Symbol up without creating one: interning an input-controlled name
+# would permanently allocate process-global state.
+function _existingjlsymbol(name::AbstractString)
+    # Checked as a `String`: other packages add methods to the iteration of
+    # other string types.
+    name isa String || return _existingjlsymbol(String(name)::String)
+    occursin('\0', name) && return nothing
+    ncodeunits(name) <= _MAX_ARROWTYPE_SCHEMA_NAME_BYTES || return nothing
+    pointer = ccall(:jl_symbol_lookup, Ptr{Cvoid}, (Cstring,), name)
+    return pointer == C_NULL ? nothing : Symbol(name)
+end
+
+# ArrowTypes.jl hooks take FixedSizeBinary storage as `NTuple{N,UInt8}` (for
+# example `fromarrow(::Type{UUID}, ::NTuple{16,UInt8})`). Wider descriptors keep
+# their bytes as a vector so an untrusted width cannot force a huge tuple type.
+_arrowtypesfixedbinarytype(t::AC.FixedSizeBinaryType) =
+    t.nbytes <= _MAX_ARROWTYPE_EXACT_ARITY ? NTuple{t.nbytes,UInt8} : Vector{UInt8}
+
+function _boundedfixedliststoragetype(listsize::Int, element)
+    # Julia materializes an NTuple type's parameter list in O(N) space. Keep
+    # the exact storage signature for ordinary fixed lists, but use the compact
+    # tuple-family type for a hostile or unusually large descriptor.
+    return listsize <= _MAX_ARROWTYPE_EXACT_ARITY ? NTuple{listsize,element} :
+           Tuple{Vararg{element}}
+end
+
+function _fieldmetavalue(f::AC.Field, key::String, default=nothing)
+    value = default
+    f.metadata === nothing && return value
+    for kv in f.metadata
+        first(kv) == key && (value = last(kv))
+    end
+    return value
+end
+
+function _arrowtypesextension(f::AC.Field)
+    name = _fieldmetavalue(f, _EXTENSION_NAME_KEY)
+    name === nothing && return nothing
+    metadata = _fieldmetavalue(f, _EXTENSION_METADATA_KEY, "")
+    return String(name), String(metadata)
+end
+
+# ---------------------------------------------------------------------------
+# Mappings the facade owns, consulted before ArrowTypes.jl's hooks: canonical
+# Arrow extension types, and Julia types ArrowTypes.jl gives no Arrow
+# storage. `UUID` writes canonical `arrow.uuid` (big-endian bytes); the
+# little-endian `JuliaLang.UUID` layout older writers used still reads and
+# rewrites through ArrowTypes.jl's own UUID hooks.
+# ---------------------------------------------------------------------------
+
+const _UUID_EXTENSION = "arrow.uuid"
+const _FACADE_PERIOD_NAMES = (
+    (Dates.Week, "JuliaLang.Dates.Week"),
+    (Dates.Day, "JuliaLang.Dates.Day"),
+    (Dates.Hour, "JuliaLang.Dates.Hour"),
+    (Dates.Minute, "JuliaLang.Dates.Minute"),
+    (Dates.Month, "JuliaLang.Dates.Month"),
+    (Dates.Year, "JuliaLang.Dates.Year"),
+)
+# Canonical extensions whose storage is already their public value.
+_quietextension(name::String) = name == "arrow.json" || name == "arrow.opaque"
+
+function _facadearrowname(T::Type)
+    T === UUIDs.UUID && return _UUID_EXTENSION
+    T === Int128 && return "JuliaLang.Int128"
+    T === UInt128 && return "JuliaLang.UInt128"
+    for (P, name) in _FACADE_PERIOD_NAMES
+        T === P && return name
+    end
+    return nothing
+end
+
+_facadestoragetype(T::Type) = T === Int128 || T === UInt128 ? NTuple{16,UInt8} : nothing
+
+# The Julia type a facade-owned label reads as, given its ArrowTypes storage
+# type, or nothing.
+function _facadejuliatype(name::String, storage)
+    bytes16 = storage === NTuple{16,UInt8}
+    name == _UUID_EXTENSION && return bytes16 ? UUIDs.UUID : nothing
+    name == "JuliaLang.Int128" && return bytes16 ? Int128 : nothing
+    name == "JuliaLang.UInt128" && return bytes16 ? UInt128 : nothing
+    name == "arrow.bool8" && return storage === Int8 ? Bool : nothing
+    for (P, label) in _FACADE_PERIOD_NAMES
+        name == label || continue
+        P <: Union{Dates.Month,Dates.Year} && return storage === Int32 ? P : nothing
+        return storage isa Type && storage <: Dates.FixedPeriod ? P : nothing
+    end
+    return nothing
+end
+
+# Storage for a facade-owned value. `field` is the Field being rewritten, if
+# any: a retained `JuliaLang.UUID` field keeps its little-endian layout.
+function _facadetoarrow(x::UUIDs.UUID, field)
+    legacy =
+        field !== nothing && _fieldmetavalue(field, _EXTENSION_NAME_KEY) == "JuliaLang.UUID"
+    legacy && return ArrowTypes.toarrow(x)
+    return ArrowTypes._cast(NTuple{16,UInt8}, hton(x.value))
+end
+_facadetoarrow(x::Union{Int128,UInt128}, field) = ArrowTypes._cast(NTuple{16,UInt8}, x)
+
+# The public value of facade-owned storage under `f`'s label, or nothing when
+# the label is not one the facade owns (ArrowTypes.jl's hooks then apply).
+function _facadefromarrow(T::Type, f::AC.Field, storage)
+    name = _fieldmetavalue(f, _EXTENSION_NAME_KEY)
+    (name === nothing || _facadejuliatype(name, typeof(storage)) !== T) && return nothing
+    # `storage`'s type is known at run time; see `_uninferred`.
+    T === UUIDs.UUID &&
+        return UUIDs.UUID(ntoh(_uninferred(ArrowTypes._cast, UInt128, storage)::UInt128))
+    T === Bool && return storage != 0
+    T <: Union{Int128,UInt128} && return _uninferred(ArrowTypes._cast, T, storage)
+    T <: Union{Dates.Month,Dates.Year} && return convert(T, Dates.Month(storage))
+    return convert(T, storage)
+end
+
+function _withoutownextension(f::AC.Field, t::AC.ArrowType=f.type; nullable=f.nullable)
+    metadata =
+        f.metadata === nothing ? nothing :
+        Pair{String,String}[
+            String(first(kv)) => String(last(kv)) for kv in f.metadata if
+            first(kv) != _EXTENSION_NAME_KEY && first(kv) != _EXTENSION_METADATA_KEY
+        ]
+    return AC.Field(f.name, t; nullable=nullable, metadata=metadata, children=f.children)
+end
+
+_withmissingtype(T, nullable::Bool) = nullable && T !== Missing ? Union{Missing,T} : T
+_nonmissingstoragetype(T) = T === Missing ? Missing : Base.nonmissingtype(T)
+
+@inline function _ispositionalchildname(name::String, index::Int)
+    bytes = codeunits(name)
+    length(bytes) == ndigits(index) || return false
+    value = 0
+    for byte in bytes
+        0x30 <= byte <= 0x39 || return false
+        value = 10 * value + Int(byte - 0x30)
+    end
+    return value == index
+end
+
+function _arrowtypesstructnames(
+    f::AC.Field,
+    budget::Union{Nothing,AllocationBudget}=nothing,
+)
+    length(f.children) <= _MAX_ARROWTYPE_EXACT_ARITY || throw(
+        ArgumentError(
+            "extension struct $(f.name) has more than " *
+            "$_MAX_ARROWTYPE_EXACT_ARITY children and cannot form an exact Julia " *
+            "NamedTuple storage type",
+        ),
+    )
+    nchildren = length(f.children)
+    _chargevector!(budget, Symbol, nchildren, "ArrowTypes struct-name workspace")
+    _chargedict!(budget, String, Nothing, nchildren, "ArrowTypes struct-name duplicate set")
+    names = Symbol[]
+    seen = Set{String}()
+    sizehint!(names, nchildren)
+    sizehint!(seen, nchildren)
+    totalbytes = 0
+    # ArrowTypes represents positional Tuple storage as Struct children named
+    # "1", "2", ... . Preserve that established interface without opening an
+    # unbounded input-to-Symbol path: at most the fixed set 1:1024 can be added.
+    positional = all(
+        index -> _ispositionalchildname(f.children[index].name, index),
+        eachindex(f.children),
+    )
+    for child in f.children
+        name = child.name
+        occursin('\0', name) && throw(
+            ArgumentError(
+                "extension struct $(f.name) has a child name with an embedded NUL",
+            ),
+        )
+        namebytes = ncodeunits(name)
+        namebytes <= _MAX_ARROWTYPE_SCHEMA_NAME_BYTES || throw(
+            ArgumentError(
+                "extension struct $(f.name) has a child name longer than " *
+                "$_MAX_ARROWTYPE_SCHEMA_NAME_BYTES bytes",
+            ),
+        )
+        totalbytes <= _MAX_ARROWTYPE_STRUCT_NAME_BYTES - namebytes || throw(
+            ArgumentError(
+                "extension struct $(f.name) child names exceed the supported " *
+                "$_MAX_ARROWTYPE_STRUCT_NAME_BYTES-byte total",
+            ),
+        )
+        totalbytes += namebytes
+        name in seen && throw(
+            ArgumentError(
+                "extension struct $(f.name) has duplicate child names and cannot " *
+                "form a Julia NamedTuple storage type",
+            ),
+        )
+        push!(seen, name)
+        symbol = _existingjlsymbol(name)
+        if symbol === nothing
+            positional || throw(
+                ArgumentError(
+                    "extension struct $(f.name) has an unregistered child name " *
+                    "$(repr(name)); exact NamedTuple lifting would permanently intern it",
+                ),
+            )
+            _chargeobject!(budget, namebytes, "ArrowTypes positional child-name symbol")
+            symbol = Symbol(name)
+        end
+        push!(names, symbol)
+    end
+    _chargeobject!(
+        budget,
+        AC.checked_mul(Int64(Base.elsize(Vector{Symbol})), Int64(nchildren)),
+        "ArrowTypes struct-name tuple",
+    )
+    return Tuple(names)
+end
+
+"ArrowTypes' Julia storage type for one non-composite Field."
+function _arrowtypesprimitivebasetype(f::AC.Field)
+    t = f.type
+    t isa AC.NullType && return Missing
+    t isa AC.IntType && return AC.juliatype(t)
+    t isa AC.FloatType && return AC.juliatype(t)
+    t isa AC.BoolType && return Bool
+    t isa AC.Utf8Type && return String
+    t isa AC.BinaryType && return Vector{UInt8}
+    t isa AC.FixedSizeBinaryType && return _arrowtypesfixedbinarytype(t)
+    t isa AC.ViewType && return t.utf8 ? String : Vector{UInt8}
+    if t isa AC.DateType
+        return t.unit == AC.DAY ? Dates.Date : Dates.DateTime
+    end
+    if t isa AC.TimestampType
+        return t.unit == AC.SECOND || t.unit == AC.MILLISECOND ? Dates.DateTime : Int64
+    end
+    t isa AC.TimeType && return Dates.Time
+    if t isa AC.DurationType
+        return t.unit == AC.SECOND ? Dates.Second :
+               t.unit == AC.MILLISECOND ? Dates.Millisecond :
+               t.unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
+    end
+    if t isa AC.DecimalType
+        return t.bits == 32 ? Int32 : t.bits == 64 ? Int64 : Vector{UInt8}
+    end
+    if t isa AC.IntervalType
+        return t.unit == AC.YEAR_MONTH ? Int32 :
+               t.unit == AC.DAY_TIME ? NamedTuple{(:days, :millis),Tuple{Int32,Int32}} :
+               NamedTuple{(:months, :days, :nanos),Tuple{Int32,Int32,Int64}}
+    end
+    return Any
+end
+
+function _extensionwarningname(
+    name::AbstractString,
+    budget::Union{Nothing,AllocationBudget}=nothing,
+)
+    # Measured as a `String`: other packages add methods to the iteration of
+    # other string types.
+    name isa String || return _extensionwarningname(String(name)::String, budget)
+    ncodeunits(name) <= _MAX_EXTENSION_WARNING_BYTES && return name
+    bytes = 0
+    lastindex = 0
+    for index in eachindex(name)
+        width = nextind(name, index) - index
+        bytes + width > _MAX_EXTENSION_WARNING_BYTES && break
+        bytes += width
+        lastindex = index
+    end
+    lastindex == 0 && return "…"
+    _chargeobject!(budget, bytes + ncodeunits("…"), "ArrowTypes extension-warning display")
+    return string(SubString(name, firstindex(name), lastindex), '…')
+end
+
+# Labels that Arrow.jl 2.x (and Durations.jl's Arrow 2.x extension) wrote on
+# temporal columns whose storage Arrow 3.0 reads natively into the same
+# instants and values. They are expected in 2.x files, so they do not warn.
+# The pre-2.4.2 `JuliaLang.ZonedDateTime` label is not one of them: that
+# storage holds local wall time, not a UTC instant.
+function _arrow2temporallabel(name::String, t::AC.ArrowType)
+    t isa AC.DictionaryType && (t = t.valuetype)
+    naive = t isa AC.TimestampType && _timestampzone(t) === nothing
+    zoned = t isa AC.TimestampType && _timestampzone(t) !== nothing
+    name == "JuliaLang.Date" && return t isa AC.DateType
+    name == "JuliaLang.DateTime" &&
+        return naive || (t isa AC.DateType && t.unit == AC.MILLISECOND)
+    name == "JuliaLang.Time" && return t isa AC.TimeType
+    name == "JuliaLang.Dates.Period" && return t isa AC.DurationType
+    name == "JuliaLang.ZonedDateTime-UTC" && return zoned
+    name == "JuliaLang.Durations.Timestamp" && return naive
+    name == "JuliaLang.Durations.ZonedTimestamp" && return zoned
+    return false
+end
+
+# Unsupported extension names already reported, process-wide, so reading
+# many files that carry the same label warns once.
+const _WARNED_EXTENSIONS = Set{String}()
+const _WARNED_EXTENSIONS_LOCK = ReentrantLock()
+
+function _warnunsupportedextension(ctx, name::String, f::AC.Field)
+    ctx.warn || return nothing
+    _arrow2temporallabel(name, f.type) && return nothing
+    displayname = _extensionwarningname(name, ctx.budget)
+    report = lock(_WARNED_EXTENSIONS_LOCK) do
+        displayname in _WARNED_EXTENSIONS && return :seen
+        length(_WARNED_EXTENSIONS) > _MAX_EXTENSION_WARNINGS && return :seen
+        push!(_WARNED_EXTENSIONS, displayname)
+        return length(_WARNED_EXTENSIONS) > _MAX_EXTENSION_WARNINGS ? :suppress : :warn
+    end
+    report === :seen && return nothing
+    if report === :suppress
+        @warn "additional unsupported Arrow extension warnings were suppressed"
+        return nothing
+    end
+    descriptor = AC.descriptorname(f.type)
+    # Charge only the message this adapter builds. The logging framework's
+    # own records and rendering are outside this budget.
+    _chargeobject!(
+        ctx.budget,
+        AC.checked_add(
+            Int64(128),
+            AC.checked_mul(Int64(4), Int64(ncodeunits(displayname))),
+        ),
+        "ArrowTypes extension-warning message",
+    )
+    @warn "unsupported ARROW:extension:name type: $(repr(displayname)), storage descriptor = $descriptor"
+    return nothing
+end
+
+function _hasarrowtypesextension(f::AC.Field)
+    _arrowtypesextension(f) === nothing || return true
+    return any(_hasarrowtypesextension, f.children)
+end
+
+# Core's ordinary materializer deliberately returns only storage-domain
+# values. Two facade-only facts still have to survive until ArrowTypes lifting:
+# a Union's selected child, and whether a Dictionary<Null> row was a valid
+# index into its null pool rather than a null index. Keep those facts on this
+# private route; the facade consumes every marker before returning a column.
+struct _ArrowTypesRoutedUnion{T}
+    child::Int
+    value::T
+end
+
+struct _ArrowTypesRoutedNull end
+
+mutable struct _ArrowTypesRoutePlan
+    extensions::Dict{AC.Field,Bool}
+    routes::Dict{AC.Field,Bool}
+    dictionaryfields::Dict{AC.Field,AC.Field}
+    budget::Union{Nothing,AllocationBudget}
+end
+function _ArrowTypesRoutePlan(
+    budget::Union{Nothing,AllocationBudget}=nothing,
+    extensions::Union{Nothing,Dict{AC.Field,Bool}}=nothing,
+)
+    _chargeobject!(budget, sizeof(_ArrowTypesRoutePlan), "ArrowTypes route-plan owner")
+    if extensions === nothing
+        _chargeemptydict!(
+            budget,
+            AC.Field,
+            Bool,
+            "ArrowTypes extension-presence cache container",
+        )
+        extensions = Dict{AC.Field,Bool}()
+    end
+    _chargeemptydict!(budget, AC.Field, Bool, "ArrowTypes route cache container")
+    _chargeemptydict!(
+        budget,
+        AC.Field,
+        AC.Field,
+        "ArrowTypes routed dictionary-field cache container",
+    )
+    return _ArrowTypesRoutePlan(
+        extensions,
+        Dict{AC.Field,Bool}(),
+        Dict{AC.Field,AC.Field}(),
+        budget,
+    )
+end
+
+function _hasarrowtypesextension(f::AC.Field, plan::_ArrowTypesRoutePlan)
+    # The routed walker asks per value: a cache hit must not construct the
+    # memoization thunk, or one heap closure rides beside every row.
+    cached = get(plan.extensions, f, nothing)
+    cached === nothing || return cached
+    return _memoized!(
+        plan.extensions,
+        f,
+        plan.budget,
+        "ArrowTypes extension-presence cache",
+    ) do
+        _arrowtypesextension(f) === nothing || return true
+        return _uninferred(
+            any,
+            child -> _hasarrowtypesextension(child, plan),
+            f.children,
+        )::Bool
+    end
+end
+
+function _routedictionaryfield!(
+    plan::_ArrowTypesRoutePlan,
+    f::AC.Field,
+    t::AC.DictionaryType,
+)
+    # Per dictionary value in the routed walker: hits must not allocate.
+    cached = get(plan.dictionaryfields, f, nothing)
+    cached === nothing || return cached
+    return _memoized!(
+        plan.dictionaryfields,
+        f,
+        plan.budget,
+        "ArrowTypes routed dictionary-field cache",
+    ) do
+        _arrowtypesdictvaluefield(f, t; retainmetadata=true, budget=plan.budget)
+    end
+end
+
+function _needsarrowtypesroute(f::AC.Field, plan::_ArrowTypesRoutePlan)
+    return _memoized!(plan.routes, f, plan.budget, "ArrowTypes route cache") do
+        t = f.type
+        if t isa AC.DictionaryType
+            ownnull = t.valuetype isa AC.NullType && _arrowtypesextension(f) !== nothing
+            return ownnull ||
+                   _needsarrowtypesroute(_routedictionaryfield!(plan, f, t), plan)
+        elseif t isa AC.RunEndEncodedType
+            return length(f.children) == 2 && _needsarrowtypesroute(f.children[2], plan)
+        elseif t isa AC.UnionType && _hasarrowtypesextension(f, plan)
+            return true
+        end
+        return _uninferred(
+            any,
+            child -> _needsarrowtypesroute(child, plan),
+            f.children,
+        )::Bool
+    end
+end
+
+function _arrowtypesroutedvalue(
+    f::AC.Field,
+    d::AC.ArrayData,
+    i::Int64,
+    plan::_ArrowTypesRoutePlan,
+    routeallunions::Bool=false,
+    budget::Union{Nothing,AllocationBudget}=nothing,
+    underlabel::Bool=false,
+)
+    # A label-free subtree that is NOT below any label lands in PUBLIC rows,
+    # so build it with the facade's public row builder. Everything at or
+    # below a label — registered or not — stays in the ArrowTypes STORAGE
+    # domain and keeps walking, so leaves reach the raw tail and unions
+    # carry routed markers; restoration then either feeds a registered
+    # target's fromarrow or converts the raw values itself when the label
+    # resolves to no target.
+    (routeallunions || underlabel || _hasarrowtypesextension(f, plan)) ||
+        return _publicvalue(f, d, i, budget, true)
+    under = underlabel || _arrowtypesextension(f) !== nothing
+    t = f.type
+    if t isa AC.DictionaryType
+        AC.isvalid_at(d, i) || return missing
+        w = AC.primwidth(t.indextype)
+        index =
+            AC._load_int(AC.rolebuffer(d, AC.DATA), t.indextype, AC._slotbyteoff(d, i, w))
+        pool = d.dictionary
+        pool === nothing && throw(AC.ValidationError("dictionary array has no value pool"))
+        value = _arrowtypesroutedvalue(
+            _routedictionaryfield!(plan, f, t),
+            pool,
+            AC.checked_add(Int64(index), Int64(1)),
+            plan,
+            routeallunions,
+            budget,
+            under,
+        )
+        # A NullType pool's physical value is always `missing`. The valid index
+        # above makes it a logical extension value; an invalid outer index has
+        # already returned ordinary `missing` and must remain distinct.
+        return t.valuetype isa AC.NullType && _arrowtypesextension(f) !== nothing ?
+               _ArrowTypesRoutedNull() : value
+    elseif t isa AC.RunEndEncodedType
+        length(f.children) == 2 ||
+            return budget === nothing ? AC.getvalue(f, d, i) : AC.getvalue(f, d, i, budget)
+        return _arrowtypesroutedvalue(
+            f.children[2],
+            d.children[2],
+            AC._ree_runindex(d, i),
+            plan,
+            routeallunions,
+            budget,
+            under,
+        )
+    elseif t isa AC.UnionType
+        childfield, childdata, childindex = AC._union_child(f, d, i)
+        child = findfirst(x -> x === childfield, f.children)
+        child === nothing && throw(AC.ValidationError("union selected an undeclared child"))
+        value = _arrowtypesroutedvalue(
+            childfield,
+            childdata,
+            childindex,
+            plan,
+            routeallunions,
+            budget,
+            under,
+        )
+        routed = _ArrowTypesRoutedUnion(child, value)
+        _chargeobject!(budget, sizeof(typeof(routed)), "ArrowTypes routed union value")
+        return routed
+    elseif t isa AC.ListType
+        AC.isvalid_at(d, i) || return missing
+        lo, hi = AC._offsets_at(d, i, AC.layoutspec(t).offsetwidth == 8)
+        childfield, childdata = f.children[1], d.children[1]
+        _chargevector!(budget, Any, hi - lo, "ArrowTypes routed list value")
+        out = Vector{Any}(undef, Int(hi - lo))
+        for k = 1:length(out)
+            out[k] = _arrowtypesroutedvalue(
+                childfield,
+                childdata,
+                AC.checked_add(lo, Int64(k)),
+                plan,
+                routeallunions,
+                budget,
+                under,
+            )
+        end
+        return out
+    elseif t isa AC.ListViewType
+        AC.isvalid_at(d, i) || return missing
+        off, size = AC._listview_range(t, d, i)
+        childfield, childdata = f.children[1], d.children[1]
+        _chargevector!(budget, Any, size, "ArrowTypes routed list-view value")
+        out = Vector{Any}(undef, Int(size))
+        for k = 1:length(out)
+            out[k] = _arrowtypesroutedvalue(
+                childfield,
+                childdata,
+                AC.checked_add(off, Int64(k)),
+                plan,
+                routeallunions,
+                budget,
+                under,
+            )
+        end
+        return out
+    elseif t isa AC.FixedSizeListType
+        AC.isvalid_at(d, i) || return missing
+        childfield, childdata = f.children[1], d.children[1]
+        base = AC.checked_mul(AC._slotindex0(d, i), Int64(t.listsize))
+        _chargevector!(budget, Any, t.listsize, "ArrowTypes routed fixed-list value")
+        out = Vector{Any}(undef, t.listsize)
+        for k = 1:(t.listsize)
+            out[k] = _arrowtypesroutedvalue(
+                childfield,
+                childdata,
+                AC.checked_add(base, Int64(k)),
+                plan,
+                routeallunions,
+                budget,
+                under,
+            )
+        end
+        return out
+    elseif t isa AC.StructType
+        AC.isvalid_at(d, i) || return missing
+        childindex = AC.checked_add(d.offset, i)
+        _chargevector!(
+            budget,
+            Pair{String,Any},
+            length(f.children),
+            "ArrowTypes routed struct value",
+        )
+        out = Vector{Pair{String,Any}}(undef, length(f.children))
+        for k in eachindex(f.children)
+            out[k] =
+                f.children[k].name => _arrowtypesroutedvalue(
+                    f.children[k],
+                    d.children[k],
+                    childindex,
+                    plan,
+                    routeallunions,
+                    budget,
+                    under,
+                )
+        end
+        return out
+    elseif t isa AC.MapType
+        AC.isvalid_at(d, i) || return missing
+        lo, hi = AC._offsets_at(d, i, false)
+        entriesfield, entriesdata = f.children[1], d.children[1]
+        keyfield, valuefield = entriesfield.children
+        keydata, valuedata = entriesdata.children
+        _chargevector!(budget, Pair{Any,Any}, hi - lo, "ArrowTypes routed map value")
+        out = Vector{Pair{Any,Any}}(undef, Int(hi - lo))
+        for k = 1:length(out)
+            entryindex = AC.checked_add(entriesdata.offset, AC.checked_add(lo, Int64(k)))
+            out[k] = Pair{Any,Any}(
+                _arrowtypesroutedvalue(
+                    keyfield,
+                    keydata,
+                    entryindex,
+                    plan,
+                    routeallunions,
+                    budget,
+                    under,
+                ),
+                _arrowtypesroutedvalue(
+                    valuefield,
+                    valuedata,
+                    entryindex,
+                    plan,
+                    routeallunions,
+                    budget,
+                    under,
+                ),
+            )
+        end
+        return out
+    end
+    # A null slot must not run the budgeted extraction: its transient
+    # charging machinery would allocate per missing value with nothing to
+    # reserve it against. The Null layout has no validity buffer (asking
+    # for it throws) and every slot is missing.
+    t isa AC.NullType && return missing
+    AC.isvalid_at(d, i) || return missing
+    budget === nothing && return AC.getvalue(f, d, i)
+    # Core's budgeted getvalue reserves the materialized value but its own
+    # transient estimate object rides beside every leaf; flat wrapper
+    # columns have no container reserve to absorb it, so charge it here.
+    _chargeobject!(budget, 24, "ArrowTypes routed leaf estimate")
+    return AC.getvalue(f, d, i, budget)
+end
+
+"Materialize only when facade lifting needs storage provenance from the layout."
+function _arrowtypesroutedcolumn(
+    f::AC.Field,
+    d::AC.ArrayData,
+    plan::_ArrowTypesRoutePlan;
+    force::Bool=false,
+)
+    # Consult the route cache even when forced: the plan memoizes and
+    # budget-charges one route entry per schema Field either way.
+    needed = _needsarrowtypesroute(f, plan)
+    (force || needed) || return nothing
+    budget = plan.budget
+    _chargevector!(budget, Any, d.len, "ArrowTypes routed column")
+    return Any[
+        _arrowtypesroutedvalue(f, d, Int64(i), plan, false, budget) for i = 1:(d.len)
+    ]
+end
+
+_arrowtypesroutedcolumn(
+    f::AC.Field,
+    d::AC.ArrayData,
+    budget::Union{Nothing,AllocationBudget}=nothing,
+) = _arrowtypesroutedcolumn(f, d, _ArrowTypesRoutePlan(budget))
+
+"Per read/write operation ArrowTypes resolution; each Field calls JuliaType at most once."
+mutable struct _ArrowTypesContext
+    targets::Dict{AC.Field,Any}
+    logicaltypes::Dict{AC.Field,Any}
+    publictypes::Dict{AC.Field,Any}
+    extensions::Dict{AC.Field,Bool}
+    structnames::Dict{AC.Field,Tuple}
+    storage::IdDict{Type,Any}
+    dictionaryfields::Dict{AC.Field,AC.Field}
+    metadata_dictionaryfields::Dict{AC.Field,AC.Field}
+    public_dictionaryfields::Dict{AC.Field,AC.Field}
+    boxedchildren::Dict{AC.Field,Vector{Any}}
+    routeplan::Union{Nothing,_ArrowTypesRoutePlan}
+    warn::Bool
+    newsymbols::Int   # Symbols this read created (see `_liftsymbol!`)
+    budget::Union{Nothing,AllocationBudget}
+end
+function _ArrowTypesContext(;
+    warn::Bool=true,
+    budget::Union{Nothing,AllocationBudget}=nothing,
+)
+    _chargeobject!(budget, sizeof(_ArrowTypesContext), "ArrowTypes context owner")
+    _chargeemptydict!(budget, AC.Field, Any, "ArrowTypes target cache container")
+    _chargeemptydict!(budget, AC.Field, Any, "ArrowTypes logical-type cache container")
+    _chargeemptydict!(budget, AC.Field, Any, "ArrowTypes public-type cache container")
+    _chargeemptydict!(
+        budget,
+        AC.Field,
+        Bool,
+        "ArrowTypes extension-presence cache container",
+    )
+    _chargeemptydict!(budget, AC.Field, Tuple, "ArrowTypes struct-name cache container")
+    _chargeemptydict!(budget, Type, Any, "ArrowTypes storage-type cache container")
+    _chargeemptydict!(
+        budget,
+        AC.Field,
+        AC.Field,
+        "ArrowTypes dictionary-field cache container",
+    )
+    _chargeemptydict!(
+        budget,
+        AC.Field,
+        AC.Field,
+        "ArrowTypes metadata dictionary-field cache container",
+    )
+    _chargeemptydict!(
+        budget,
+        AC.Field,
+        AC.Field,
+        "ArrowTypes public dictionary-field cache container",
+    )
+    _chargeemptydict!(
+        budget,
+        AC.Field,
+        Vector{Any},
+        "ArrowTypes boxed-children cache container",
+    )
+    return _ArrowTypesContext(
+        Dict{AC.Field,Any}(),
+        Dict{AC.Field,Any}(),
+        Dict{AC.Field,Any}(),
+        Dict{AC.Field,Bool}(),
+        Dict{AC.Field,Tuple}(),
+        IdDict{Type,Any}(),
+        Dict{AC.Field,AC.Field}(),
+        Dict{AC.Field,AC.Field}(),
+        Dict{AC.Field,AC.Field}(),
+        Dict{AC.Field,Vector{Any}}(),
+        nothing,
+        warn,
+        0,
+        budget,
+    )
+end
+
+function _hasarrowtypesextension(f::AC.Field, ctx::_ArrowTypesContext)
+    return _memoized!(
+        ctx.extensions,
+        f,
+        ctx.budget,
+        "ArrowTypes extension-presence cache",
+    ) do
+        _arrowtypesextension(f) === nothing || return true
+        return _uninferred(
+            any,
+            child -> _hasarrowtypesextension(child, ctx),
+            f.children,
+        )::Bool
+    end
+end
+
+function _arrowtypesstructnames(ctx::_ArrowTypesContext, f::AC.Field)
+    return _memoized!(ctx.structnames, f, ctx.budget, "ArrowTypes struct-name cache") do
+        _arrowtypesstructnames(f, ctx.budget)
+    end
+end
+
+function _arrowtypesrouteplan!(ctx::_ArrowTypesContext)
+    plan = ctx.routeplan
+    plan === nothing || return plan
+    plan = _ArrowTypesRoutePlan(ctx.budget, ctx.extensions)
+    ctx.routeplan = plan
+    return plan
+end
+
+Base.@noinline function _arrowtypesrawstoragetype(T::Type)
+    Base.@nospecialize T
+    storage = _facadestoragetype(T)
+    storage === nothing || return storage
+    return _uninferred(ArrowTypes.ArrowType, T)
+end
+
+function _checkarrowtypesstorageshape!(
+    owner::Type,
+    storage,
+    seen::Base.IdSet{Any},
+    depth::Int,
+)
+    Base.@nospecialize owner storage
+    storage isa Type || return nothing
+    storage in seen && return nothing
+    depth <= 64 || throw(
+        ArgumentError(
+            "ArrowTypes.ArrowType($owner) returned a storage type nested beyond " *
+            "the supported depth 64",
+        ),
+    )
+    push!(seen, storage)
+    if storage isa Union
+        variants = Base.uniontypes(storage)
+        length(variants) <= _MAX_ARROWTYPE_UNION_BRANCHES || throw(
+            ArgumentError(
+                "ArrowTypes.ArrowType($owner) returned a Union with more than " *
+                "$_MAX_ARROWTYPE_UNION_BRANCHES branches",
+            ),
+        )
+        for variant in variants
+            _checkarrowtypesstorageshape!(owner, variant, seen, depth + 1)
+        end
+    elseif storage isa DataType
+        if storage <: Tuple && isconcretetype(storage)
+            nfields = fieldcount(storage)
+            nfields <= _MAX_ARROWTYPE_EXACT_ARITY || throw(
+                ArgumentError(
+                    "ArrowTypes.ArrowType($owner) returned a concrete Tuple with " *
+                    "$nfields fields; the supported limit is " *
+                    "$_MAX_ARROWTYPE_EXACT_ARITY",
+                ),
+            )
+        end
+        for parameter in storage.parameters
+            parameter isa Type || continue
+            _checkarrowtypesstorageshape!(owner, parameter, seen, depth + 1)
+        end
+    end
+    return nothing
+end
+
+function _validatedarrowtypesstoragetype(T::Type, storage)
+    Base.@nospecialize T storage
+    storage isa Type || throw(
+        ArgumentError(
+            "ArrowTypes.ArrowType($T) must return a Julia type, not $(repr(storage))",
+        ),
+    )
+    _checkarrowtypesstorageshape!(T, storage, Base.IdSet{Any}(), 0)
+    return storage
+end
+
+Base.@noinline function _arrowtypesstoragetype!(ctx::_ArrowTypesContext, T::Type)
+    Base.@nospecialize T
+    # Row lifting asks per union value: a cache hit must not construct the
+    # memoization thunk.
+    cached = get(ctx.storage, T, nothing)
+    cached === nothing || return cached
+    return _memoized!(ctx.storage, T, ctx.budget, "ArrowTypes storage-type cache") do
+        _validatedarrowtypesstoragetype(T, _arrowtypesrawstoragetype(T))
+    end
+end
+
+function _arrowtypesstoragebasetype(ctx::_ArrowTypesContext, f::AC.Field)
+    t = f.type
+    if t isa AC.DictionaryType
+        valuefield = _arrowtypesdictvaluefield(ctx, f, t)
+        return _arrowtypesstoragebasetype(ctx, valuefield)
+    end
+    if t isa AC.RunEndEncodedType
+        length(f.children) == 2 || return Any
+        return Base.nonmissingtype(_arrowtypeslogicaleltype(ctx, f.children[2]))
+    end
+    if t isa Union{AC.ListType,AC.ListViewType}
+        length(f.children) == 1 || return Vector{Any}
+        return Vector{_arrowtypeslogicaleltype(ctx, f.children[1])}
+    end
+    if t isa AC.FixedSizeListType
+        length(f.children) == 1 || return NTuple{0,Any}
+        element = _arrowtypeslogicaleltype(ctx, f.children[1])
+        # Generic JuliaType registrations still resolve from the bounded
+        # signature. A hook that requires an exact oversized arity safely
+        # remains unregistered.
+        return _boundedfixedliststoragetype(t.listsize, element)
+    end
+    if t isa AC.StructType
+        length(f.children) > _MAX_ARROWTYPE_EXACT_ARITY && return Vector{Pair{String,Any}}
+        names = _arrowtypesstructnames(ctx, f)
+        _chargevector!(
+            ctx.budget,
+            Type,
+            length(f.children),
+            "ArrowTypes struct type workspace",
+        )
+        types = Type[_arrowtypeslogicaleltype(ctx, child) for child in f.children]
+        return Core.apply_type(NamedTuple, names, Core.apply_type(Tuple, types...))
+    end
+    if t isa AC.MapType
+        length(f.children) == 1 || return Dict{Any,Any}
+        entries = f.children[1]
+        length(entries.children) == 2 || return Dict{Any,Any}
+        K = _arrowtypeslogicaleltype(ctx, entries.children[1])
+        V = _arrowtypeslogicaleltype(ctx, entries.children[2])
+        return Dict{K,V}
+    end
+    if t isa AC.UnionType
+        isempty(f.children) && return Union{}
+        T = _arrowtypeslogicaleltype(ctx, f.children[1])
+        for child in Iterators.drop(f.children, 1)
+            T = Union{T,_arrowtypeslogicaleltype(ctx, child)}
+        end
+        return T
+    end
+    return _arrowtypesprimitivebasetype(f)
+end
+
+function _arrowtypesfallbackstoragebasetype(ctx::_ArrowTypesContext, f::AC.Field)
+    t = f.type
+    if t isa AC.DictionaryType
+        valuefield = _arrowtypesdictvaluefield(ctx, f, t)
+        return _arrowtypesfallbackstoragebasetype(ctx, valuefield)
+    end
+    if t isa AC.RunEndEncodedType
+        return length(f.children) == 2 ?
+               _arrowtypesfallbackstoragebasetype(ctx, f.children[2]) : Any
+    end
+    t isa Union{AC.ListType,AC.ListViewType} && return Vector{Any}
+    t isa AC.FixedSizeListType && return Tuple{Vararg{Any}}
+    t isa AC.StructType && return Vector{Pair{String,Any}}
+    t isa AC.MapType && return Dict{Any,Any}
+    t isa AC.UnionType && return Any
+    return _arrowtypesprimitivebasetype(f)
+end
+
+function _preflightarrowtypesstructnames(ctx::_ArrowTypesContext, f::AC.Field)
+    f.type isa AC.StructType && _arrowtypesstructnames(ctx, f)
+    foreach(child -> _preflightarrowtypesstructnames(ctx, child), f.children)
+    return nothing
+end
+
+function _arrowtypestarget(ctx::_ArrowTypesContext, f::AC.Field)
+    # Row lifting asks per value: a cache hit must not construct the
+    # memoization thunk.
+    cached = get(ctx.targets, f, nothing)
+    cached === nothing || return cached
+    return _memoized!(ctx.targets, f, ctx.budget, "ArrowTypes target cache") do
+        ext = _arrowtypesextension(f)
+        # Most Fields have no extension label. Do not synthesize their full
+        # ArrowTypes storage shape merely to discover that no JuliaType hook
+        # can apply. In particular, forming NTuple{N,T} for an unlabelled
+        # FixedSizeList must not allocate in proportion to an untrusted N.
+        ext === nothing && return (false, nothing, nothing)
+        name, metadata = ext
+        if isempty(f.children)
+            storage = _arrowtypesstoragebasetype(ctx, f)
+            facade = _facadejuliatype(name, storage)
+            facade === nothing || return (true, facade, storage)
+            _quietextension(name) && return (true, nothing, storage)
+        end
+        sym = _existingjlsymbol(name)
+        if sym === nothing
+            storage = _arrowtypesfallbackstoragebasetype(ctx, f)
+            _warnunsupportedextension(ctx, name, f)
+            return (true, nothing, storage)
+        end
+        try
+            _preflightarrowtypesstructnames(ctx, f)
+        catch err
+            err isa ArgumentError || rethrow()
+            storage = _arrowtypesfallbackstoragebasetype(ctx, f)
+            _warnunsupportedextension(ctx, name, f)
+            return (true, nothing, storage)
+        end
+        storage = _arrowtypesstoragebasetype(ctx, f)
+        target = ArrowTypes.JuliaType(Val(sym), _nonmissingstoragetype(storage), metadata)
+        target === nothing ||
+            target isa Type ||
+            throw(
+                ArgumentError(
+                    "ArrowTypes.JuliaType for extension $(repr(name)) on field " *
+                    "$(f.name) must return a Julia type or nothing, not " *
+                    "$(repr(target))",
+                ),
+            )
+        target === nothing && _warnunsupportedextension(ctx, name, f)
+        return (true, target, storage)
+    end
+end
+
+function _arrowtypeslogicalnullable(f::AC.Field, target, storage=nothing)
+    if f.type isa AC.UnionType
+        storage === nothing && (storage = ArrowTypes.ArrowType(target))
+    end
+    # A nullable logical column adds exactly one Null child around the
+    # target's storage Union, so one extra field child means "outer nullable";
+    # equal counts mean not nullable, and anything else is a mismatch.
+    if storage isa Union
+        fieldbranches = length(f.children)
+        storagebranches = length(Base.uniontypes(storage))
+        fieldbranches == storagebranches && return false
+        if fieldbranches == storagebranches + 1
+            Missing <: storage && throw(
+                ArgumentError(
+                    "registered ArrowTypes target $target uses Missing as a storage " *
+                    "Union branch, so retained field $(f.name) cannot add an " *
+                    "indistinguishable outer missing branch",
+                ),
+            )
+            return true
+        end
+        throw(
+            ArgumentError(
+                "registered ArrowTypes target $target has $storagebranches storage " *
+                "Union branches, but retained field $(f.name) has $fieldbranches children",
+            ),
+        )
+    end
+    return f.nullable
+end
+
+_arrowtypeslogicalnullable(ctx::_ArrowTypesContext, f::AC.Field, target) =
+    _arrowtypeslogicalnullable(
+        f,
+        target,
+        f.type isa AC.UnionType ? _arrowtypesstoragetype!(ctx, target) : nothing,
+    )
+
+function _arrowtypeslogicaleltype(ctx::_ArrowTypesContext, f::AC.Field)
+    # Row restoration asks per value: a cache hit must not construct the
+    # memoization thunk.
+    cached = get(ctx.logicaltypes, f, nothing)
+    cached === nothing || return cached
+    return _memoized!(ctx.logicaltypes, f, ctx.budget, "ArrowTypes logical-type cache") do
+        _, target, storage = _arrowtypestarget(ctx, f)
+        storage === nothing && (storage = _arrowtypesstoragebasetype(ctx, f))
+        nullable =
+            target === nothing ? f.nullable : _arrowtypeslogicalnullable(ctx, f, target)
+        _withmissingtype(target === nothing ? storage : target, nullable)
+    end
+end
+
+function _arrowtypespubliceltype(ctx::_ArrowTypesContext, f::AC.Field)
+    # Row restoration asks per value: a cache hit must not construct the
+    # memoization thunk.
+    cached = get(ctx.publictypes, f, nothing)
+    cached === nothing || return cached
+    return _memoized!(ctx.publictypes, f, ctx.budget, "ArrowTypes public-type cache") do
+        _, target, storage = _arrowtypestarget(ctx, f)
+        if target !== nothing
+            nullable =
+                !(f.type isa AC.NullType) && _arrowtypeslogicalnullable(ctx, f, target)
+            return _withmissingtype(target, nullable)
+        end
+        t = f.type
+        if t isa AC.DictionaryType
+            valuefield = _arrowtypespublicdictvaluefield(ctx, f, t)
+            return _withmissingtype(
+                Base.nonmissingtype(_arrowtypespubliceltype(ctx, valuefield)),
+                f.nullable,
+            )
+        elseif t isa AC.RunEndEncodedType
+            length(f.children) == 2 || return Any
+            return _arrowtypespubliceltype(ctx, f.children[2])
+        elseif t isa Union{AC.ListType,AC.ListViewType,AC.FixedSizeListType}
+            length(f.children) == 1 || return _withmissingtype(Vector{Any}, f.nullable)
+            return _withmissingtype(
+                Vector{_arrowtypespubliceltype(ctx, f.children[1])},
+                f.nullable,
+            )
+        elseif t isa AC.StructType
+            foreach(child -> _arrowtypespubliceltype(ctx, child), f.children)
+            return _withmissingtype(Vector{Pair{String,Any}}, f.nullable)
+        elseif t isa AC.MapType
+            foreach(child -> _arrowtypespubliceltype(ctx, child), f.children)
+            return _withmissingtype(Vector{Pair{Any,Any}}, f.nullable)
+        elseif t isa AC.UnionType
+            isempty(f.children) && return Union{}
+            T = _arrowtypespubliceltype(ctx, f.children[1])
+            for child in Iterators.drop(f.children, 1)
+                T = Base.promote_typejoin(T, _arrowtypespubliceltype(ctx, child))
+            end
+            return T
+        end
+        # An unmarked or unknown-label leaf materializes in the native
+        # public domain regardless of any storage fallback the label lookup
+        # produced: no registered mapping consumes these values. The native
+        # declared rule already carries nullability, and a Null leaf keeps
+        # its intrinsic Missing domain.
+        return _declaredeltype(f, true)
+    end
+end
+
+function _typedvalues(::Type{Any}, values, budget=nothing)
+    _chargevector!(budget, Any, length(values), "ArrowTypes public column")
+    # map(identity, …) keeps the input's own narrowed eltype for an Any
+    # target instead of widening every column to Vector{Any}.
+    return _uninferred(map, identity, values)
+end
+function _typedvalues(::Type{T}, values, budget=nothing) where {T}
+    _chargevector!(budget, T, length(values), "ArrowTypes typed column")
+    return _collectas(T, values)
+end
+
+function _arrowtypesscalar(t::AC.ArrowType, x)
+    x === missing && return missing
+    if t isa AC.DateType
+        return t.unit == AC.DAY ? Dates.Date(Dates.UTD(Int64(x) + _EPOCH_DAYS)) :
+               Dates.DateTime(Dates.UTM(Int64(x) + Dates.UNIXEPOCH))
+    end
+    if t isa AC.TimestampType
+        # DateTime cannot hold micro/nanosecond precision, so those units
+        # stay raw Int64 rather than lose information.
+        t.unit == AC.SECOND &&
+            return Dates.DateTime(Dates.UTM(Int64(x) * 1000 + Dates.UNIXEPOCH))
+        t.unit == AC.MILLISECOND &&
+            return Dates.DateTime(Dates.UTM(Int64(x) + Dates.UNIXEPOCH))
+        return x
+    end
+    t isa AC.TimeType && return _publictime(t.unit, x)
+    if t isa AC.DurationType
+        P =
+            t.unit == AC.SECOND ? Dates.Second :
+            t.unit == AC.MILLISECOND ? Dates.Millisecond :
+            t.unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
+        return P(Int64(x))
+    end
+    return x
+end
+
+function _arrowtypesdictvaluefield(
+    f::AC.Field,
+    t::AC.DictionaryType;
+    retainmetadata::Bool=false,
+    nullable::Bool=true,
+    budget::Union{Nothing,AllocationBudget}=nothing,
+)
+    metadata = retainmetadata ? f.metadata : nothing
+    # Field and FrozenVector are immutable. Use Core's exact positional
+    # constructor so every reader view shares the already-frozen child tree.
+    _chargeobject!(budget, sizeof(AC.Field), "ArrowTypes derived dictionary Field")
+    return AC.Field(f.name, t.valuetype, nullable, metadata, f.children)
+end
+
+function _arrowtypesdictvaluefield(
+    ctx::_ArrowTypesContext,
+    f::AC.Field,
+    t::AC.DictionaryType;
+    retainmetadata::Bool=false,
+)
+    cache = retainmetadata ? ctx.metadata_dictionaryfields : ctx.dictionaryfields
+    # Per dictionary value during row lifting: hits must not allocate.
+    cached = get(cache, f, nothing)
+    cached === nothing || return cached
+    what =
+        retainmetadata ? "ArrowTypes metadata dictionary-field cache" :
+        "ArrowTypes dictionary-field cache"
+    return _memoized!(cache, f, ctx.budget, what) do
+        _arrowtypesdictvaluefield(f, t; retainmetadata, budget=ctx.budget)
+    end
+end
+
+function _arrowtypespublicdictvaluefield(
+    ctx::_ArrowTypesContext,
+    f::AC.Field,
+    t::AC.DictionaryType,
+)
+    return _memoized!(
+        ctx.public_dictionaryfields,
+        f,
+        ctx.budget,
+        "ArrowTypes public dictionary-field cache",
+    ) do
+        _arrowtypesdictvaluefield(f, t; nullable=false, budget=ctx.budget)
+    end
+end
+
+"Convert a child while preserving the container shape required by its parent."
+function _arrowtypesnestedvalue(
+    ctx::_ArrowTypesContext,
+    f::AC.Field,
+    x;
+    extension_shape::Bool,
+    rawdomain::Bool=false,
+)
+    # Indexing instead of destructuring: per-value callers must not box
+    # iteration-state tuples beside every row.
+    target = _arrowtypestarget(ctx, f)[2]
+    # Dictionary<Null> needs a private marker to distinguish a valid index
+    # into its null pool from a null dictionary index. Consume that marker at
+    # every recursive Field seam, including when the extension label is not
+    # registered in this process. No private routing value may reach a public
+    # row container.
+    (target !== nothing || x isa _ArrowTypesRoutedNull) &&
+        return _arrowtypesvalue(ctx, f, x)
+    # A label with no target left its whole subtree in the raw storage
+    # domain (see the routed walker); its values convert here on the way
+    # into public rows.
+    return _arrowtypesstoragevalue(
+        ctx,
+        f,
+        x;
+        extension_shape=extension_shape,
+        rawdomain=rawdomain || _arrowtypesextension(f) !== nothing,
+    )
+end
+
+function _arrowtypesnestedeltype(
+    ctx::_ArrowTypesContext,
+    f::AC.Field;
+    extension_shape::Bool,
+)
+    target = _arrowtypestarget(ctx, f)[2]
+    if target !== nothing || extension_shape
+        return _arrowtypeslogicaleltype(ctx, f)
+    end
+    return _arrowtypespubliceltype(ctx, f)
+end
+
+"""
+Reserve the dynamic per-element restoration overhead for `n` nested calls:
+each one is a dynamic keyword invocation that leaves a small argument tuple
+and scalar boxes behind (32 bytes covers the measured worst case).
+"""
+function _chargerestoredelements!(
+    budget::Union{Nothing,AllocationBudget},
+    n::Integer,
+    what::AbstractString,
+)
+    budget === nothing && return nothing
+    _charge!(budget, AC.checked_mul(Int64(n), Int64(32)), what)
+    return nothing
+end
+
+"""
+One heap-boxed reference per child Field. `Field` is an inline immutable, so
+handing `f.children[i]` to a dynamic per-row call re-boxes it beside every
+value; restoration loops index this cached vector instead.
+"""
+function _arrowtypesboxedchildren(ctx::_ArrowTypesContext, f::AC.Field)
+    cached = get(ctx.boxedchildren, f, nothing)
+    cached === nothing || return cached
+    return _memoized!(
+        ctx.boxedchildren,
+        f,
+        ctx.budget,
+        "ArrowTypes boxed-children cache",
+    ) do
+        _chargevector!(
+            ctx.budget,
+            AC.Field,
+            length(f.children),
+            "ArrowTypes boxed children",
+        )
+        Any[child for child in f.children]
+    end
+end
+
+"Convert children, preserving the reader's unmarked row containers unless requested."
+function _arrowtypesstoragevalue(
+    ctx::_ArrowTypesContext,
+    f::AC.Field,
+    x;
+    extension_shape::Bool,
+    rawdomain::Bool=false,
+)
+    t = f.type
+    x === missing && return missing
+    t isa AC.DictionaryType && return _arrowtypesstoragevalue(
+        ctx,
+        _arrowtypesdictvaluefield(ctx, f, t),
+        x;
+        extension_shape=extension_shape,
+        rawdomain=rawdomain,
+    )
+    if t isa AC.RunEndEncodedType
+        length(f.children) == 2 || return x
+        return _arrowtypesnestedvalue(
+            ctx,
+            _arrowtypesboxedchildren(ctx, f)[2],
+            x;
+            extension_shape=extension_shape,
+            rawdomain=rawdomain,
+        )
+    end
+    if t isa Union{AC.ListType,AC.ListViewType,AC.FixedSizeListType}
+        length(f.children) == 1 || return x
+        child = f.children[1]
+        childbox = _arrowtypesboxedchildren(ctx, f)[1]
+        _chargevector!(ctx.budget, Any, length(x), "ArrowTypes converted list value")
+        _chargerestoredelements!(ctx.budget, length(x), "ArrowTypes restored list elements")
+        vals = Any[
+            _arrowtypesnestedvalue(
+                ctx,
+                childbox,
+                y;
+                extension_shape=extension_shape,
+                rawdomain=rawdomain,
+            ) for y in x
+        ]
+        if t isa AC.FixedSizeListType && extension_shape
+            _chargevector!(ctx.budget, Any, length(vals), "ArrowTypes tuple storage")
+            out = Tuple(vals)
+            # The tuple construction and the dynamic hook call each copy
+            # inline (isbits) child payloads wholesale; heap children
+            # contribute pointer slots only, which sizeof reflects.
+            _chargeobject!(
+                ctx.budget,
+                AC.checked_mul(Int64(2), Int64(sizeof(typeof(out)))),
+                "ArrowTypes tuple payload",
+            )
+            return out
+        end
+        return _typedvalues(
+            _arrowtypesnestedeltype(ctx, child; extension_shape=extension_shape),
+            vals,
+            ctx.budget,
+        )
+    end
+    if t isa AC.StructType
+        length(x) == length(f.children) || throw(
+            AC.ValidationError("extension struct value width does not match its Field"),
+        )
+        _chargevector!(ctx.budget, Any, length(f.children), "ArrowTypes struct workspace")
+        _chargerestoredelements!(
+            ctx.budget,
+            length(f.children),
+            "ArrowTypes restored struct children",
+        )
+        boxedchildren = _arrowtypesboxedchildren(ctx, f)
+        vals = Vector{Any}(undef, length(f.children))
+        for (i, child) in enumerate(f.children)
+            kv = x[i]
+            kv isa Pair ||
+                throw(AC.ValidationError("extension struct rows must contain Pairs"))
+            first(kv) == child.name || throw(
+                AC.ValidationError("extension struct child order does not match its Field"),
+            )
+            vals[i] = _arrowtypesnestedvalue(
+                ctx,
+                boxedchildren[i],
+                last(kv);
+                extension_shape=extension_shape,
+                rawdomain=rawdomain,
+            )
+        end
+        if extension_shape
+            # Rebuilding the storage base type per row walks every child and
+            # re-applies the NamedTuple constructor. A registered Field's
+            # target cache carries the exact type; an unlabeled Field reads
+            # it through the logical-eltype memo. An unknown label keeps the
+            # direct computation: its cached slot holds the bounded fallback
+            # shape, not the exact one.
+            tgt = _arrowtypestarget(ctx, f)
+            NT =
+                tgt[2] !== nothing ? tgt[3] :
+                tgt[1] === false ? Base.nonmissingtype(_arrowtypeslogicaleltype(ctx, f)) :
+                _arrowtypesstoragebasetype(ctx, f)
+            if NT <: NamedTuple
+                _chargevector!(
+                    ctx.budget,
+                    Any,
+                    length(vals),
+                    "ArrowTypes NamedTuple storage",
+                )
+                # The transient tuple and the constructed row each copy the
+                # row's inline (isbits) payload; heap-backed children only
+                # contribute pointer slots, which sizeof reflects.
+                NT isa DataType &&
+                    isconcretetype(NT) &&
+                    _chargeobject!(
+                        ctx.budget,
+                        AC.checked_mul(Int64(2), Int64(sizeof(NT))),
+                        "ArrowTypes NamedTuple payload",
+                    )
+                return NT(Tuple(vals))
+            end
+            _chargevector!(
+                ctx.budget,
+                Pair{String,Any},
+                length(vals),
+                "ArrowTypes converted struct value",
+            )
+            return Pair{String,Any}[f.children[i].name => vals[i] for i in eachindex(vals)]
+        end
+        _chargevector!(
+            ctx.budget,
+            Pair{String,Any},
+            length(vals),
+            "ArrowTypes converted struct value",
+        )
+        # The raw-domain path (a label with no resolvable target) rebuilds
+        # every child pair with freshly boxed scalars; reserve that beside
+        # the pair vector.
+        _chargerestoredelements!(
+            ctx.budget,
+            AC.checked_mul(Int64(3), Int64(length(vals))),
+            "ArrowTypes raw struct rows",
+        )
+        return Pair{String,Any}[f.children[i].name => vals[i] for i in eachindex(vals)]
+    end
+    if t isa AC.MapType
+        length(f.children) == 1 || return x
+        entries = f.children[1]
+        length(entries.children) == 2 || return x
+        entryboxes = _arrowtypesboxedchildren(ctx, entries)
+        kfbox, vfbox = entryboxes[1], entryboxes[2]
+        _chargevector!(
+            ctx.budget,
+            Pair{Any,Any},
+            length(x),
+            "ArrowTypes converted map value",
+        )
+        _chargerestoredelements!(
+            ctx.budget,
+            AC.checked_mul(Int64(2), Int64(length(x))),
+            "ArrowTypes restored map entries",
+        )
+        vals = Pair{Any,Any}[
+            _arrowtypesnestedvalue(
+                ctx,
+                kfbox,
+                first(kv);
+                extension_shape=extension_shape,
+                rawdomain=rawdomain,
+            ) => _arrowtypesnestedvalue(
+                ctx,
+                vfbox,
+                last(kv);
+                extension_shape=extension_shape,
+                rawdomain=rawdomain,
+            ) for kv in x
+        ]
+        if extension_shape
+            # Same caching rule as the struct branch: registered Fields use
+            # the exact cached storage type, unlabeled Fields the memoized
+            # logical eltype, unknown labels the direct computation.
+            tgt = _arrowtypestarget(ctx, f)
+            D =
+                tgt[2] !== nothing ? tgt[3] :
+                tgt[1] === false ? Base.nonmissingtype(_arrowtypeslogicaleltype(ctx, f)) :
+                _arrowtypesstoragebasetype(ctx, f)
+            if D <: Dict
+                _chargedict!(
+                    ctx.budget,
+                    keytype(D),
+                    valtype(D),
+                    length(vals),
+                    "ArrowTypes Dict storage",
+                )
+            end
+            out = D()
+            D <: Dict && sizehint!(out, length(vals))
+            for kv in vals
+                out[first(kv)] = last(kv)
+            end
+            return out
+        end
+        return vals
+    end
+    if t isa AC.UnionType
+        if x isa _ArrowTypesRoutedUnion
+            1 <= x.child <= length(f.children) ||
+                throw(AC.ValidationError("routed union child is outside its Field"))
+            return _arrowtypesnestedvalue(
+                ctx,
+                _arrowtypesboxedchildren(ctx, f)[x.child],
+                x.value;
+                extension_shape=extension_shape,
+                rawdomain=rawdomain,
+            )
+        end
+        boxedchildren = _arrowtypesboxedchildren(ctx, f)
+        for (k, child) in enumerate(f.children)
+            T = _arrowtypesnestedeltype(ctx, child; extension_shape=extension_shape)
+            x isa T && return _arrowtypesnestedvalue(
+                ctx,
+                boxedchildren[k],
+                x;
+                extension_shape=extension_shape,
+                rawdomain=rawdomain,
+            )
+        end
+        return x
+    end
+    # Only a marked parent's ArrowTypes storage shape asks for ArrowTypes
+    # scalars here — that domain is the registered mappings' contract. A
+    # leaf outside any label already arrived public from the routed walker;
+    # a leaf inside a label-without-target subtree arrived as raw storage
+    # and converts here, landing in public rows like every unmarked value.
+    if extension_shape
+        if t isa AC.FixedSizeBinaryType && _arrowtypesfixedbinarytype(t) !== Vector{UInt8}
+            # The tuple is built here and copied again into the dynamic hook call.
+            _chargeobject!(ctx.budget, 2 * t.nbytes, "ArrowTypes fixed-size binary tuple")
+            return NTuple{t.nbytes,UInt8}(x)
+        end
+        return _arrowtypesscalar(t, x)
+    end
+    if rawdomain && _isconvertibleleaf(t)
+        # Same reserve as the facade's converted leaf: the public box plus
+        # its transient conversion temporaries.
+        _chargeobject!(ctx.budget, 96, "ArrowTypes converted leaf")
+        return _publicleafscalar(t, x)
+    end
+    return x
+end
+
+function _arrowtypesutf8storage(ctx::_ArrowTypesContext, f::AC.Field)
+    t = f.type
+    t isa AC.DictionaryType &&
+        return _arrowtypesutf8storage(ctx, _arrowtypesdictvaluefield(ctx, f, t))
+    if t isa AC.RunEndEncodedType
+        return length(f.children) == 2 && _arrowtypesutf8storage(ctx, f.children[2])
+    end
+    return t isa AC.Utf8Type || (t isa AC.ViewType && t.utf8)
+end
+
+function _arrowtypesfromarrow(ctx::_ArrowTypesContext, T, f::AC.Field, storage)
+    value = _facadefromarrow(T, f, storage)
+    value === nothing || return value
+    t = f.type
+    if _arrowtypesutf8storage(ctx, f) && storage isa AbstractString
+        T === Symbol && return _liftsymbol!(ctx, storage, f.name)
+        bytes = _utf8units(storage)
+        GC.@preserve storage bytes begin
+            return _uninferred(ArrowTypes.fromarrow, T, pointer(bytes), length(bytes))
+        end
+    elseif t isa AC.DictionaryType
+        # The extension label lives on the dictionary field, but the shape
+        # passed to ArrowTypes is the dictionary VALUE shape. In particular, a
+        # Struct value must use `fromarrowstruct` with its declared child names;
+        # the generic `fromarrow(T, storage)` path can bind reordered storage
+        # children to the logical constructor by position.
+        return _arrowtypesfromarrow(ctx, T, _arrowtypesdictvaluefield(ctx, f, t), storage)
+    elseif t isa AC.RunEndEncodedType
+        return ArrowTypes.fromarrow(T, storage)
+    elseif t isa AC.StructType
+        # Reconstruction copies the row's inline (isbits) payload at each
+        # seam — the transient tuple, the splatted arguments, and an isbits
+        # target's returned box; heap-backed children contribute pointer
+        # slots only, which sizeof reflects.
+        storage isa Union{NamedTuple,Tuple} && _chargeobject!(
+            ctx.budget,
+            AC.checked_mul(Int64(3), Int64(sizeof(typeof(storage)))),
+            "ArrowTypes struct hook payload",
+        )
+        if T <: NamedTuple || T <: Tuple
+            # The transient tuple and constructed row beside the payload.
+            _chargerestoredelements!(
+                ctx.budget,
+                AC.checked_mul(Int64(2), Int64(length(storage))),
+                "ArrowTypes struct hook tuple",
+            )
+            return T(Tuple(storage))
+        end
+        names = _arrowtypesstructnames(ctx, f)
+        # The `applicable` probe and the variadic hook call each re-splat
+        # every child value, re-boxing scalars whose types Julia does not
+        # cache; charge that width-dependent dispatch work per child.
+        ctx.budget === nothing || _charge!(
+            ctx.budget,
+            AC.checked_mul(Int64(length(storage)), Int64(160)),
+            "ArrowTypes struct hook dispatch",
+        )
+        values = Tuple(storage)
+        if isdefined(ArrowTypes, :fromarrowstruct)
+            fromstruct = getfield(ArrowTypes, :fromarrowstruct)
+            applicable(fromstruct, T, Val(names), values...) &&
+                return fromstruct(T, Val(names), values...)
+        end
+        return ArrowTypes.fromarrow(T, values...)
+    end
+    return ArrowTypes.fromarrow(T, storage)
+end
+
+function _arrowtypesvalue(ctx::_ArrowTypesContext, f::AC.Field, x)
+    routednull = x isa _ArrowTypesRoutedNull
+    routednull && (x = missing)
+    target = _arrowtypestarget(ctx, f)[2]
+    if target === nothing
+        return _arrowtypesstoragevalue(
+            ctx,
+            f,
+            x;
+            extension_shape=false,
+            rawdomain=_arrowtypesextension(f) !== nothing,
+        )
+    end
+    if f.type isa AC.UnionType && x isa _ArrowTypesRoutedUnion
+        child = f.children[x.child]
+        storage = _arrowtypesstoragetype!(ctx, target)
+        # A nullable logical column adds one unmarked Null child around a
+        # target whose own storage Union has no Missing branch. Preserve that
+        # outer missing instead of passing it to the target's fromarrow hook.
+        child.type isa AC.NullType &&
+            _arrowtypesextension(child) === nothing &&
+            !(storage isa Union && Missing <: storage) &&
+            return missing
+    end
+    # A validity null remains `missing`; NullType is different — it is the
+    # physical storage of public-domain values such as `nothing` and must lift.
+    x === missing && !routednull && !(f.type isa AC.NullType) && return missing
+    storage = _arrowtypesstoragevalue(ctx, f, x; extension_shape=true)
+    # Reserve the lifted value plus the dynamic-dispatch temporaries around
+    # the fromarrow hook. Childless (flat scalar) storage leaves about 140
+    # bytes of boxes per lifted value; container storage's per-element
+    # restoration and hook-dispatch reserves already carry its width, so
+    # only a small fixed remainder rides per row; union storage and the
+    # transparent wrappers (run-end, dictionary) lift one scalar with no
+    # per-element reserve and keep the larger fixed one.
+    _chargeobject!(
+        ctx.budget,
+        isempty(f.children) ? 152 :
+        f.type isa
+        Union{AC.StructType,AC.ListType,AC.ListViewType,AC.FixedSizeListType,AC.MapType} ?
+        96 : 216,
+        "ArrowTypes lifted value",
+    )
+    # The default ArrowTypes pointer adapter copies a string's bytes again
+    # (`unsafe_string`) before the hook sees them: that copy grows with the
+    # value, so reserve it by length (plus the copy's measured header and
+    # size-class slop) beside the fixed overhead.
+    storage isa AbstractString && _chargeobject!(
+        ctx.budget,
+        AC.checked_add(Int64(ncodeunits(storage)), Int64(256)),
+        "ArrowTypes lifted string copy",
+    )
+    return _arrowtypesfromarrow(ctx, target, f, storage)
+end
+
+# Interning a Symbol permanently allocates process-global state, so one read
+# (one stream batch) creates at most `Limits.max_new_symbols` of them, and
+# charges their bytes to its allocation budget; existing Symbols cost nothing.
+_maxnewsymbols(ctx::_ArrowTypesContext) =
+    ctx.budget === nothing ? _DEFAULT_MAX_NEW_SYMBOLS : ctx.budget.maxnewsymbols
+
+function _liftsymbol!(ctx::_ArrowTypesContext, s::AbstractString, name::AbstractString)
+    # As a `String`: see `_existingjlsymbol`.
+    s isa String || return _liftsymbol!(ctx, String(s)::String, name)
+    symbol = _existingjlsymbol(s)
+    symbol === nothing || return symbol
+    occursin('\0', s) && _symbolnulerror(ctx, s, name)
+    # Top-level columns were counted before conversion (`_checknewsymbols`).
+    ctx.newsymbols < _maxnewsymbols(ctx) || _symbollimiterror(ctx, name, false)
+    ctx.budget === nothing ||
+        _charge!(ctx.budget, Int64(ncodeunits(s)), "interned Symbol values")
+    ctx.newsymbols += 1
+    return Symbol(s)
+end
+
+@noinline function _symbolnulerror(ctx::_ArrowTypesContext, s, name)
+    displayname = _extensionwarningname(s, ctx.budget)
+    throw(
+        AC.ValidationError(
+            "field $name holds the JuliaLang.Symbol value $(repr(displayname)), " *
+            "which contains a NUL byte and cannot be a Symbol",
+        ),
+    )
+end
+
+# `column`: `name` is a top-level column, which `select` can read as strings.
+@noinline function _symbollimiterror(ctx::_ArrowTypesContext, name, column::Bool)
+    limit = _maxnewsymbols(ctx)
+    # `repr` of a Symbol runs Base code that other packages invalidate.
+    sym = _uninferred(repr, Symbol(name))::String
+    hint = column ? ", or read the column as strings with select=[$sym => String]" : ""
+    throw(
+        AC.ValidationError(
+            "$(column ? "column" : "field") $name holds more than $limit Symbol values " *
+            "this process has not created yet, the most one read may create (Julia " *
+            "never frees a Symbol). Raise the limit with " *
+            "limits=Arrow.Limits(max_new_symbols=...)$hint",
+        ),
+    )
+end
+
+# A JuliaLang.Symbol column's new names, counted (deduplicated) before any
+# is created, so a refused read leaves no Symbols behind.
+function _checknewsymbols(ctx::_ArrowTypesContext, f::AC.Field, col::AbstractVector)
+    limit = _maxnewsymbols(ctx) - ctx.newsymbols
+    new = Set{String}()
+    charged = Int64(0)
+    for x in col
+        x isa AbstractString || continue
+        _existingjlsymbol(x) === nothing || continue
+        occursin('\0', x) && _symbolnulerror(ctx, x, f.name)
+        x in new && continue
+        length(new) < limit || _symbollimiterror(ctx, f.name, true)
+        # The set's entry and its copy of the name, returned below.
+        bytes = Int64(ncodeunits(x) + 64)
+        ctx.budget === nothing || _charge!(ctx.budget, bytes, "new Symbol name count")
+        charged += bytes
+        push!(new, String(x))
+    end
+    ctx.budget === nothing || _refund!(ctx.budget, charged)
+    return nothing
+end
+
+"Heap-box an inline immutable once; @noinline keeps the box from folding away."
+@noinline _boxonce(@nospecialize(x)) = x
+
+"Interpret extension labels recursively over an already materialized column."
+function _arrowtypescolumn(
+    f::AC.Field,
+    col::AbstractVector,
+    ctx::_ArrowTypesContext=_ArrowTypesContext(),
+)
+    has_label, target, _ = _arrowtypestarget(ctx, f)
+    has_registered_child = any(
+        child ->
+            _arrowtypestarget(ctx, child)[2] !== nothing ||
+            _hasarrowtypesextension(child, ctx),
+        f.children,
+    )
+    has_routed_value =
+        any(x -> x isa _ArrowTypesRoutedNull || x isa _ArrowTypesRoutedUnion, col)
+    if target === nothing &&
+       has_label &&
+       !has_registered_child &&
+       !has_routed_value &&
+       isempty(f.children)
+        # No hook or routed provenance is available to consume, and the
+        # column is flat (its raw values sit under one leaf descriptor, via
+        # transparent wrappers at most): convert the whole column at once
+        # without building a per-row ArrowTypes workspace. A composite
+        # column with an unconsumed label falls through to the per-row
+        # lifting below, which converts its raw-domain leaves in place.
+        return _publiccolumn(f, _postconvertfield(f, col, ctx.budget), ctx.budget)
+    end
+    target === Symbol && _checknewsymbols(ctx, f, col)
+    _chargevector!(ctx.budget, Any, length(col), "ArrowTypes lifting workspace")
+    # `f` is an immutable struct held inline in this frame: box it once,
+    # behind a call boundary the optimizer cannot fold away, so the dynamic
+    # per-row call does not re-box it beside every value.
+    fbox = _boxonce(f)
+    values = Any[_arrowtypesvalue(ctx, fbox, x) for x in col]
+    if target !== nothing
+        # NullType uses the physical null slots as its storage values. A
+        # registered logical type such as `Nothing` lifts those slots to real
+        # values, so physical field nullability must not add `Missing` back.
+        nullable =
+            !(f.type isa AC.NullType) &&
+            (_arrowtypeslogicalnullable(ctx, f, target) || any(ismissing, values))
+        T = _withmissingtype(target, nullable)
+        return _typedvalues(T, values, ctx.budget)
+    end
+    # An unknown top-level extension remains the ordinary storage column.
+    # Recursive registered children have already been lifted in `values`.
+    if has_label && !has_registered_child
+        # The lifted rows: routed markers consumed, and raw-domain leaves
+        # under the unconsumed label already converted to their public
+        # values — no whole-column conversion may run again.
+        return _publiccolumn(f, values, ctx.budget)
+    end
+    T = _arrowtypespubliceltype(ctx, f)
+    any(ismissing, values) && !(Missing <: T) && (T = Union{Missing,T})
+    return _typedvalues(T, values, ctx.budget)
+end
diff --git a/src/cdata.jl b/src/cdata.jl
new file mode 100644
index 00000000..1e730b40
--- /dev/null
+++ b/src/cdata.jl
@@ -0,0 +1,1207 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# The C data interface and C stream interface adapter over ArrowCore.
+#
+# `ArrayData` has the shape of the C `ArrowArray` (buffers + children +
+# dictionary + length/null_count/offset), so export is struct filling and
+# import is struct reading.
+#
+#   * Export: every C node of one export (a schema tree, an array tree, or a
+#     stream) carries in `private_data` a pointer to one malloc'd count of the
+#     nodes the consumer has not released. A release callback releases the
+#     children and dictionary still in place, marks the node released, and
+#     counts it off. It takes no lock, allocates nothing, and touches no Julia
+#     object, because consumers call it from their own threads and from inside
+#     GC finalizers. The Julia side keeps each export's roots (the columns,
+#     whose regions keep the buffers alive) and mallocs in `EXPORTS` until the
+#     count reaches zero; later exports or garbage collections free them.
+#     `to_c_data`'s two top-level structs, the only memory Arrow.jl allocates
+#     that a consumer can read after releasing it, are freed by the first reap
+#     at least 10 ms after the rest.
+#
+#   * Import: the moved ArrowArray becomes ONE ForeignOwner shared by every
+#     child/dictionary BufferSlice (a single release for the whole tree).
+#     Buffer extents are DECLARED, not verified: the ABI cannot prove
+#     allocation sizes, so extents are computed from length/offset/layout, and
+#     offsets buffers are read (bounded by their computed size) to size the
+#     data buffers they govern. Failed imports release the moved structure
+#     exactly once before throwing. Per spec, moving marks the source released
+#     (release = NULL). Validity is reachability: every imported region's
+#     `root` is the ForeignOwner, so the producer's memory outlives every slice
+#     by construction, and every region shares one `ReleaseCell`, so
+#     `release!` on the owner or on any region revokes all siblings (later
+#     access is a clean `InvalidStateException`) and then runs the producer's
+#     release exactly once.
+#
+#   * Streams: `ArrowArrayStream` maps in both directions. An exported stream
+#     is one export whose `get_schema` and `get_next` results are exports of
+#     their own; an imported stream is a moved struct whose batches import as
+#     arrays do.
+# =============================================================================
+
+# ---------------------------------------------------------------------------
+# ABI structs (field-exact per https://arrow.apache.org/docs/format/CDataInterface.html)
+# ---------------------------------------------------------------------------
+
+"""
+    Arrow.CArrowSchema
+
+The C data interface's `ArrowSchema` struct, field for field.
+"""
+struct CArrowSchema
+    format::Ptr{UInt8}
+    name::Ptr{UInt8}
+    metadata::Ptr{UInt8}
+    flags::Int64
+    n_children::Int64
+    children::Ptr{Ptr{CArrowSchema}}
+    dictionary::Ptr{CArrowSchema}
+    release::Ptr{Cvoid}
+    private_data::Ptr{Cvoid}
+end
+
+"""
+    Arrow.CArrowArray
+
+The C data interface's `ArrowArray` struct, field for field.
+"""
+struct CArrowArray
+    length::Int64
+    null_count::Int64
+    offset::Int64
+    n_buffers::Int64
+    n_children::Int64
+    buffers::Ptr{Ptr{Cvoid}}
+    children::Ptr{Ptr{CArrowArray}}
+    dictionary::Ptr{CArrowArray}
+    release::Ptr{Cvoid}
+    private_data::Ptr{Cvoid}
+end
+
+const ARROW_FLAG_NULLABLE = Int64(2)
+const ARROW_FLAG_DICTIONARY_ORDERED = Int64(1)
+const ARROW_FLAG_MAP_KEYS_SORTED = Int64(4)
+const ARROW_FLAG_ALL_SUPPORTED =
+    ARROW_FLAG_NULLABLE | ARROW_FLAG_DICTIONARY_ORDERED | ARROW_FLAG_MAP_KEYS_SORTED
+
+# Store one field of a C struct in place (structs are immutable in Julia;
+# the C memory is not).
+@generated function _store_field!(p::Ptr{T}, ::Val{name}, v) where {T,name}
+    i = findfirst(==(name), fieldnames(T))
+    off = fieldoffset(T, i)
+    FT = fieldtype(T, i)
+    return :(unsafe_store!(Ptr{$FT}(Ptr{Cvoid}(p) + $off), convert($FT, v)); nothing)
+end
+_store_field!(p, name::Symbol, v) = _store_field!(p, Val(name), v)
+
+# Call the release callback of the C struct at `p`, if it still has one.
+function _release_c!(p::Ptr{T}) where {T}
+    r = unsafe_load(p).release
+    r == C_NULL || ccall(r, Cvoid, (Ptr{T},), p)
+    return nothing
+end
+
+# Release a producer's struct and check that its callback marked the struct
+# released, as the interface requires.
+function _release_producer!(p::Ptr{T}) where {T}
+    _release_c!(p)
+    unsafe_load(p).release == C_NULL ||
+        error("C Data producer release did not mark the structure released")
+    return nothing
+end
+
+# ---------------------------------------------------------------------------
+# Format strings <-> Core descriptors (parity with Core's accessor set)
+# ---------------------------------------------------------------------------
+
+_tuchar(u) =
+    u == AC.SECOND ? "s" : u == AC.MILLISECOND ? "m" : u == AC.MICROSECOND ? "u" : "n"
+
+function formatstring(t::IntType)
+    t.bits == 128 && throw(
+        ArgumentError(
+            "the C data interface has no 128-bit integer format; " *
+            "convert the column to a decimal or fixed-size binary first",
+        ),
+    )
+    return (
+        t.signed ? Dict(8 => "c", 16 => "s", 32 => "i", 64 => "l") :
+        Dict(8 => "C", 16 => "S", 32 => "I", 64 => "L")
+    )[t.bits]
+end
+formatstring(t::FloatType) = Dict(16 => "e", 32 => "f", 64 => "g")[t.bits]
+formatstring(::BoolType) = "b"
+formatstring(::NullType) = "n"
+formatstring(t::Utf8Type) = t.large ? "U" : "u"
+formatstring(t::BinaryType) = t.large ? "Z" : "z"
+formatstring(t::FixedSizeBinaryType) = "w:$(t.nbytes)"
+formatstring(t::DecimalType) =
+    t.bits == 128 ? "d:$(t.precision),$(t.scale)" : "d:$(t.precision),$(t.scale),$(t.bits)"
+formatstring(t::DateType) = t.unit == AC.DAY ? "tdD" : "tdm"
+formatstring(t::TimeType) = "tt" * _tuchar(t.unit)
+formatstring(t::TimestampType) = "ts" * _tuchar(t.unit) * ":" * something(t.timezone, "")
+formatstring(t::DurationType) = "tD" * _tuchar(t.unit)
+formatstring(t::IntervalType) =
+    t.unit == AC.YEAR_MONTH ? "tiM" : t.unit == AC.DAY_TIME ? "tiD" : "tin"
+formatstring(t::ListType) = t.large ? "+L" : "+l"
+formatstring(t::FixedSizeListType) = "+w:$(t.listsize)"
+formatstring(::StructType) = "+s"
+formatstring(::MapType) = "+m"
+formatstring(t::UnionType) =
+    (t.mode == AC.SparseMode ? "+us:" : "+ud:") * join(Int.(t.typeids), ",")
+formatstring(t::ViewType) = t.utf8 ? "vu" : "vz"
+formatstring(t::ListViewType) = t.large ? "+vL" : "+vl"
+formatstring(::RunEndEncodedType) = "+r"
+
+# Closed-set ladder (same devirtualization story as AC.layoutspec_of): the
+# export walk reaches this with an abstract-typed Field slot.
+@inline function formatstring_of(t::ArrowType)::String
+    t isa IntType && return formatstring(t)
+    t isa FloatType && return formatstring(t)
+    t isa BoolType && return formatstring(t)
+    t isa NullType && return formatstring(t)
+    t isa Utf8Type && return formatstring(t)
+    t isa BinaryType && return formatstring(t)
+    t isa FixedSizeBinaryType && return formatstring(t)
+    t isa DecimalType && return formatstring(t)
+    t isa DateType && return formatstring(t)
+    t isa TimeType && return formatstring(t)
+    t isa TimestampType && return formatstring(t)
+    t isa DurationType && return formatstring(t)
+    t isa IntervalType && return formatstring(t)
+    t isa ListType && return formatstring(t)
+    t isa FixedSizeListType && return formatstring(t)
+    t isa StructType && return formatstring(t)
+    t isa MapType && return formatstring(t)
+    t isa UnionType && return formatstring(t)
+    t isa ViewType && return formatstring(t)
+    t isa ListViewType && return formatstring(t)
+    t isa RunEndEncodedType && return formatstring(t)
+    # per spec: the index format on the node; values on schema.dictionary
+    t isa DictionaryType && return formatstring_of(t.indextype)
+    throw(ArgumentError("unregistered ArrowType"))
+end
+
+_formaterror(fmt) = throw(ValidationError("unsupported C format string \"$fmt\""))
+
+function _parseformatint(fmt, s, what; low=0, high=typemax(Int32))
+    bytes = codeunits(s)
+    isempty(bytes) && throw(ValidationError("invalid $what in C format string \"$fmt\""))
+    firstdigit = 1
+    if bytes[1] == UInt8('-')
+        low < 0 || throw(ValidationError("invalid $what in C format string \"$fmt\""))
+        length(bytes) > 1 ||
+            throw(ValidationError("invalid $what in C format string \"$fmt\""))
+        firstdigit = 2
+    end
+    for i = firstdigit:length(bytes)
+        UInt8('0') <= bytes[i] <= UInt8('9') ||
+            throw(ValidationError("invalid $what in C format string \"$fmt\""))
+    end
+    n = tryparse(Int64, s)
+    (n === nothing || !(low <= n <= high)) &&
+        throw(ValidationError("invalid $what in C format string \"$fmt\""))
+    return Int(n)
+end
+
+_parsetimeunit(fmt, c) =
+    c == UInt8('s') ? AC.SECOND :
+    c == UInt8('m') ? AC.MILLISECOND :
+    c == UInt8('u') ? AC.MICROSECOND : c == UInt8('n') ? AC.NANOSECOND : _formaterror(fmt)
+
+function _parseunionids(fmt, body)
+    ids = Int8[]
+    isempty(body) && return ids
+    # A valid Int8-domain union has at most 128 children. Count separators
+    # without splitting so an overlong malformed string cannot direct a large
+    # temporary allocation before it is rejected.
+    nids = 1
+    for b in codeunits(body)
+        b == UInt8(',') || continue
+        nids += 1
+        nids <= 128 ||
+            throw(ValidationError("union C format string declares more than 128 type ids"))
+    end
+    sizehint!(ids, nids)
+    seen = UInt128(0)
+    value = 0
+    have_digit = false
+    for b in codeunits(body)
+        if UInt8('0') <= b <= UInt8('9')
+            have_digit = true
+            value = 10 * value + Int(b - UInt8('0'))
+            value <= 127 || throw(ValidationError("union type ids must be in [0, 127]"))
+        elseif b == UInt8(',')
+            have_digit ||
+                throw(ValidationError("invalid union type id in C format string \"$fmt\""))
+            bit = UInt128(1) << value
+            seen & bit == 0 || throw(ValidationError("union type ids must be unique"))
+            push!(ids, Int8(value))
+            seen |= bit
+            value = 0
+            have_digit = false
+        else
+            throw(ValidationError("invalid union type id in C format string \"$fmt\""))
+        end
+    end
+    have_digit ||
+        throw(ValidationError("invalid union type id in C format string \"$fmt\""))
+    bit = UInt128(1) << value
+    seen & bit == 0 || throw(ValidationError("union type ids must be unique"))
+    push!(ids, Int8(value))
+    return ids
+end
+
+function parseformat(fmt::AbstractString, flags::Int64=0)::ArrowType
+    isvalid(fmt) || throw(ValidationError("C format string is not valid UTF-8"))
+    occursin('\0', fmt) &&
+        throw(ValidationError("C format string cannot contain embedded NUL characters"))
+    fmt = String(fmt)
+    fmt == "b" && return BoolType()
+    fmt == "n" && return NullType()
+    fmt == "u" && return Utf8Type(false)
+    fmt == "U" && return Utf8Type(true)
+    fmt == "z" && return BinaryType(false)
+    fmt == "Z" && return BinaryType(true)
+    fmt == "+l" && return ListType(false)
+    fmt == "+L" && return ListType(true)
+    fmt == "vu" && return ViewType(true)
+    fmt == "vz" && return ViewType(false)
+    fmt == "+vl" && return ListViewType(false)
+    fmt == "+vL" && return ListViewType(true)
+    fmt == "+r" && return RunEndEncodedType()
+    fmt == "+s" && return StructType()
+    fmt == "+m" && return MapType((flags & ARROW_FLAG_MAP_KEYS_SORTED) != 0)
+    fmt == "e" && return FloatType(16)
+    fmt == "f" && return FloatType(32)
+    fmt == "g" && return FloatType(64)
+    fmt == "tdD" && return DateType(AC.DAY)
+    fmt == "tdm" && return DateType(AC.MILLISECOND_DATE)
+    fmt == "tiM" && return IntervalType(AC.YEAR_MONTH)
+    fmt == "tiD" && return IntervalType(AC.DAY_TIME)
+    fmt == "tin" && return IntervalType(AC.MONTH_DAY_NANO)
+    m = Dict(
+        "c" => (8, true),
+        "C" => (8, false),
+        "s" => (16, true),
+        "S" => (16, false),
+        "i" => (32, true),
+        "I" => (32, false),
+        "l" => (64, true),
+        "L" => (64, false),
+    )
+    haskey(m, fmt) && return IntType(m[fmt]...)
+    if ncodeunits(fmt) == 3 && startswith(fmt, "tt")
+        u = _parsetimeunit(fmt, codeunit(fmt, 3))
+        return TimeType(u, u == AC.SECOND || u == AC.MILLISECOND ? 32 : 64)
+    end
+    ncodeunits(fmt) == 3 &&
+        startswith(fmt, "tD") &&
+        return DurationType(_parsetimeunit(fmt, codeunit(fmt, 3)))
+    if startswith(fmt, "ts") && ncodeunits(fmt) >= 4 && codeunit(fmt, 4) == UInt8(':')
+        u = _parsetimeunit(fmt, codeunit(fmt, 3))
+        tz = SubString(fmt, 5)
+        return TimestampType(u, isempty(tz) ? nothing : String(tz))
+    end
+    if startswith(fmt, "w:")
+        return FixedSizeBinaryType(_parseformatint(fmt, fmt[3:end], "byte width"))
+    end
+    if startswith(fmt, "+w:")
+        return FixedSizeListType(_parseformatint(fmt, fmt[4:end], "list size"))
+    end
+    if startswith(fmt, "d:")
+        parts = split(fmt[3:end], ","; limit=4, keepempty=true)
+        2 <= length(parts) <= 3 ||
+            throw(ValidationError("invalid decimal C format string \"$fmt\""))
+        precision = _parseformatint(fmt, parts[1], "decimal precision")
+        scale = _parseformatint(fmt, parts[2], "decimal scale"; low=typemin(Int32))
+        bits =
+            length(parts) == 3 ? _parseformatint(fmt, parts[3], "decimal bit width") : 128
+        t = DecimalType(precision, scale, bits)
+        AC._validate_descriptor(t)
+        return t
+    end
+    startswith(fmt, "+us:") &&
+        return UnionType(AC.SparseMode, _parseunionids(fmt, fmt[5:end]))
+    startswith(fmt, "+ud:") &&
+        return UnionType(AC.DenseMode, _parseunionids(fmt, fmt[5:end]))
+    _formaterror(fmt)
+end
+
+# ---------------------------------------------------------------------------
+# Export: Core -> C structs, one live-node count per export
+# ---------------------------------------------------------------------------
+
+# One export's Julia roots and native allocations. `live` is a malloc'd count
+# of the C nodes the consumer has not released; every node's `private_data`
+# points at it, so a release callback needs no Julia object. The 8 bytes after
+# the count hold an exported stream's last error message. `top` holds
+# `to_c_data`'s two top-level structs (C_NULL for a stream's exports, which fill
+# structs the consumer allocated); see `_RETIRED`.
+struct Export
+    roots::Vector{Any}
+    mallocs::Vector{Ptr{Cvoid}}
+    live::Ptr{Int64}
+    top::Ptr{Cvoid}
+end
+
+const EXPORTS = Dict{Ptr{Int64},Export}()
+const REGISTRY_LOCK = ReentrantLock()
+# Exports left to make before one reaps. A reap scans every registered export, so it
+# sets this to the number still unreleased (at least 64), and reaping costs constant
+# time per export however many exports a consumer holds.
+const _EXPORTS_UNTIL_REAP = Ref(64)
+# The most exports registered since `EXPORTS` last shrank. Deleting keeps the slots a
+# past peak grew, and a reap walks every slot, so a reap that leaves far fewer shrinks it.
+const _EXPORTS_PEAK = Ref(0)
+# The `top` blocks of freed exports, oldest first, with the `time_ns()` of the reap that
+# freed them. A consumer that releases a top-level struct in place may read it after the
+# release callback returns (Arrow C++ checks that its `release` is NULL), and a preempted
+# consumer can take a while to get there, so a reap frees a block only once it has been
+# retired for `_TOP_FREE_AFTER_NS`.
+const _RETIRED = Tuple{UInt64,Ptr{Cvoid}}[]
+const _TOP_FREE_AFTER_NS = UInt64(10_000_000)
+
+# A new export of `roots`; `topsize` bytes for top-level structs it allocates itself.
+function _newexport(roots::Vector{Any}, topsize::Integer=0)
+    reap = lock(REGISTRY_LOCK) do
+        return (_EXPORTS_UNTIL_REAP[] -= 1) <= 0
+    end
+    reap && _reap!()
+    live = Ptr{Int64}(Libc.calloc(2, 8))
+    live == C_NULL && throw(OutOfMemoryError())
+    top = topsize > 0 ? Libc.malloc(topsize) : C_NULL
+    if topsize > 0 && top == C_NULL
+        Libc.free(live)
+        throw(OutOfMemoryError())
+    end
+    return Export(roots, Ptr{Cvoid}[live], live, top)
+end
+
+function _malloc!(e::Export, n::Integer)
+    p = Libc.malloc(max(Int(n), 1))
+    p == C_NULL && throw(OutOfMemoryError())
+    push!(e.mallocs, p)
+    return p
+end
+
+function _free!(e::Export)
+    message = unsafe_load(Ptr{Ptr{UInt8}}(e.live + 8))
+    message == C_NULL || Libc.free(message)
+    foreach(Libc.free, e.mallocs)
+    empty!(e.mallocs)
+    empty!(e.roots)
+    return nothing
+end
+
+# An object whose finalizer reaps and then registers itself again, so a
+# consumer's releases free memory at later garbage collections even when
+# nothing exports again. Created once, by the first export.
+mutable struct _ReapHook end
+const _REAP_HOOK_ARMED = Ref(false)
+# Set when Julia starts exiting; see `_finalizeowner`.
+const _EXITING = Ref(false)
+function _setexiting()
+    _EXITING[] = true
+    return nothing
+end
+
+function __init__()
+    # No export outlives the process that made it: drop what a precompile
+    # workload left (its pointers come back NULL), and re-arm the reap hook,
+    # whose finalizer is not saved.
+    empty!(EXPORTS)
+    empty!(_RETIRED)
+    _EXPORTS_UNTIL_REAP[] = 64
+    _EXPORTS_PEAK[] = 0
+    _REAP_HOOK_ARMED[] = false
+    atexit(_setexiting)
+    return nothing
+end
+
+function _reaphook(h::_ReapHook)
+    finalizer(_reaphook, h)
+    trylock(REGISTRY_LOCK) || return nothing
+    try
+        _reap!()
+    finally
+        unlock(REGISTRY_LOCK)
+    end
+    return nothing
+end
+
+function _register!(e::Export)
+    lock(REGISTRY_LOCK) do
+        EXPORTS[e.live] = e
+        if !_REAP_HOOK_ARMED[]
+            _REAP_HOOK_ARMED[] = true
+            finalizer(_reaphook, _ReapHook())
+        end
+    end
+    return nothing
+end
+
+# Free every export whose C nodes are all released, retire its `top` block, free the
+# blocks retired long enough ago, and return how many exports it freed. Runs from
+# `_newexport` (see `_EXPORTS_UNTIL_REAP`) and from `_ReapHook`, so no caller needs to.
+function _reap!()
+    done = Export[]
+    expired = Ptr{Cvoid}[]
+    lock(REGISTRY_LOCK) do
+        peak = _EXPORTS_PEAK[] = max(_EXPORTS_PEAK[], length(EXPORTS))
+        for e in values(EXPORTS)
+            unsafe_load(e.live, :sequentially_consistent) == 0 && push!(done, e)
+        end
+        # Read after the scan, so a block's stamp is later than the release the scan saw.
+        now = time_ns()
+        for e in done
+            delete!(EXPORTS, e.live)
+            e.top == C_NULL || push!(_RETIRED, (now, e.top))
+        end
+        while !isempty(_RETIRED) && now - first(_RETIRED)[1] >= _TOP_FREE_AFTER_NS
+            push!(expired, popfirst!(_RETIRED)[2])
+        end
+        # A drained queue gives back the capacity a burst grew.
+        isempty(_RETIRED) && sizehint!(_RETIRED, 0)
+        n = length(EXPORTS)
+        if peak > 4 * max(64, n)
+            sizehint!(EXPORTS, n)
+            _EXPORTS_PEAK[] = n
+        end
+        _EXPORTS_UNTIL_REAP[] = max(64, n)
+        return nothing
+    end
+    foreach(Libc.free, expired)
+    foreach(_free!, done)
+    return length(done)
+end
+
+# Release callbacks do only native work: release the children and dictionary
+# still in place (a moved one has `release == NULL`), mark the node released,
+# and count it off its export. No lock, no allocation, no Julia object, and
+# nothing that can throw: consumers call them from their own threads, and
+# PythonCall runs pyarrow's releases from GC finalizers.
+function _release_array(a::Ptr{CArrowArray})::Cvoid
+    arr = unsafe_load(a)
+    arr.release == C_NULL && return nothing
+    for i = 1:arr.n_children
+        _release_c!(unsafe_load(arr.children, i))
+    end
+    arr.dictionary == C_NULL || _release_c!(arr.dictionary)
+    _store_field!(a, Val(:release), Ptr{Cvoid}(C_NULL))
+    Base.unsafe_modify!(Ptr{Int64}(arr.private_data), -, 1, :sequentially_consistent)
+    return nothing
+end
+
+function _release_schema(s::Ptr{CArrowSchema})::Cvoid
+    sch = unsafe_load(s)
+    sch.release == C_NULL && return nothing
+    for i = 1:sch.n_children
+        _release_c!(unsafe_load(sch.children, i))
+    end
+    sch.dictionary == C_NULL || _release_c!(sch.dictionary)
+    _store_field!(s, Val(:release), Ptr{Cvoid}(C_NULL))
+    Base.unsafe_modify!(Ptr{Int64}(sch.private_data), -, 1, :sequentially_consistent)
+    return nothing
+end
+
+# Field metadata per the C data interface: int32 pair count, then per pair an
+# int32 key length, key bytes, int32 value length, value bytes (native
+# endian, not NUL-terminated). NULL when there is no metadata.
+function _cmetadata!(
+    e::Export,
+    metadata::Union{Nothing,AC.FrozenVector{Pair{String,String}}},
+)::Ptr{UInt8}
+    (metadata === nothing || isempty(metadata)) && return Ptr{UInt8}(C_NULL)
+    buf = UInt8[]
+    append!(buf, reinterpret(UInt8, Int32[Int32(length(metadata))]))
+    for kv in metadata
+        k = first(kv)
+        v = last(kv)
+        append!(buf, reinterpret(UInt8, Int32[Int32(sizeof(k))]))
+        append!(buf, codeunits(k))
+        append!(buf, reinterpret(UInt8, Int32[Int32(sizeof(v))]))
+        append!(buf, codeunits(v))
+    end
+    p = Ptr{UInt8}(_malloc!(e, length(buf)))
+    GC.@preserve buf unsafe_copyto!(p, pointer(buf), length(buf))
+    return p
+end
+
+function _cstring!(e::Export, s::String)
+    isvalid(s) || throw(ValidationError("C Data strings must be valid UTF-8"))
+    occursin('\0', s) &&
+        throw(ValidationError("C Data strings cannot contain embedded NUL characters"))
+    n = ncodeunits(s)
+    p = Ptr{UInt8}(_malloc!(e, n + 1))
+    GC.@preserve s unsafe_copyto!(p, pointer(s), n)
+    unsafe_store!(p, 0x00, n + 1)
+    return p
+end
+
+# A dictionary Field's extension pairs name its VALUE type, as in IPC. For a
+# canonical extension (the format reserves the `arrow.` prefix for them), export
+# them on the dependent value node, as the C++ bridge does for an extension type
+# it knows: on the wrapper they would declare dictionary storage, which PyArrow
+# refuses. Other extension names stay on the wrapper with the field's metadata,
+# where a consumer that does not know them keeps them as field metadata (PyArrow
+# drops unknown extension pairs on a dependent node).
+# (Literal keys: the trim gate includes this file without arrowtypes.jl.)
+_isextensionpair(kv) =
+    first(kv) == "ARROW:extension:name" || first(kv) == "ARROW:extension:metadata"
+
+_iscanonicalextension(kv) =
+    first(kv) == "ARROW:extension:name" && startswith(last(kv), "arrow.")
+
+function _splitdictmetadata(metadata::Union{Nothing,AC.FrozenVector{Pair{String,String}}})
+    (metadata === nothing || !any(_iscanonicalextension, metadata)) &&
+        return metadata, nothing
+    wrapper = Pair{String,String}[kv for kv in metadata if !_isextensionpair(kv)]
+    values = Pair{String,String}[kv for kv in metadata if _isextensionpair(kv)]
+    return (isempty(wrapper) ? nothing : AC.FrozenVector{Pair{String,String}}(wrapper)),
+    AC.FrozenVector{Pair{String,String}}(values)
+end
+
+# Export the schema tree of `f` into `at`, a struct the caller allocated, or into
+# a malloc'd one. The node is stored last, after its children, so a failed
+# export leaves `at` untouched.
+function _export_schema!(
+    e::Export,
+    f::Field,
+    release::Ptr{Cvoid};
+    at::Ptr{CArrowSchema}=Ptr{CArrowSchema}(C_NULL),
+    metadata::Union{Nothing,AC.FrozenVector{Pair{String,String}}}=f.metadata,
+)::Ptr{CArrowSchema}
+    p = at == C_NULL ? Ptr{CArrowSchema}(_malloc!(e, sizeof(CArrowSchema))) : at
+    childfields = f.type isa DictionaryType ? Field[] : f.children
+    childptrs = Ptr{Ptr{CArrowSchema}}(C_NULL)
+    if !isempty(childfields)
+        childptrs = Ptr{Ptr{CArrowSchema}}(_malloc!(e, length(childfields) * sizeof(Ptr)))
+        for (i, cf) in enumerate(childfields)
+            unsafe_store!(childptrs, _export_schema!(e, cf, release), i)
+        end
+    end
+    dict = Ptr{CArrowSchema}(C_NULL)
+    wrappermetadata = metadata
+    if f.type isa DictionaryType
+        wrappermetadata, valuemetadata = _splitdictmetadata(metadata)
+        dict = _export_schema!(
+            e,
+            AC.dictvaluefield(f, f.type),
+            release;
+            metadata=valuemetadata,
+        )
+    end
+    flags = f.nullable ? ARROW_FLAG_NULLABLE : Int64(0)
+    f.type isa DictionaryType && f.type.ordered && (flags |= ARROW_FLAG_DICTIONARY_ORDERED)
+    f.type isa MapType && f.type.keyssorted && (flags |= ARROW_FLAG_MAP_KEYS_SORTED)
+    unsafe_store!(e.live, unsafe_load(e.live) + 1)
+    unsafe_store!(
+        p,
+        CArrowSchema(
+            _cstring!(e, formatstring_of(f.type)),
+            _cstring!(e, f.name),
+            # Field metadata rides the OUTER node for every field, dictionary
+            # wrappers included; PyArrow imports only the wrapper's pairs.
+            _cmetadata!(e, wrappermetadata),
+            flags,
+            length(childfields),
+            childptrs,
+            dict,
+            release,
+            Ptr{Cvoid}(e.live),
+        ),
+    )
+    return p
+end
+
+function _export_array!(
+    e::Export,
+    d::ArrayData,
+    release::Ptr{Cvoid};
+    at::Ptr{CArrowArray}=Ptr{CArrowArray}(C_NULL),
+)::Ptr{CArrowArray}
+    p = at == C_NULL ? Ptr{CArrowArray}(_malloc!(e, sizeof(CArrowArray))) : at
+    spec = AC.layoutspec_of(d.type)
+    ncore = length(d.buffers)
+    # C Data appends one int64 buffer of variadic data-buffer LENGTHS to view
+    # arrays (extents are not otherwise recoverable from the ABI); it counts
+    # toward n_buffers here and nowhere else in the format.
+    nvariadic = spec.variadic ? ncore - length(spec.buffers) : 0
+    nbuf = spec.variadic ? ncore + 1 : ncore
+    bufptrs = Ptr{Ptr{Cvoid}}(_malloc!(e, max(nbuf, 1) * sizeof(Ptr)))
+    for (i, b) in enumerate(d.buffers)
+        role = i <= length(spec.buffers) ? spec.buffers[i] : AC.DATA
+        bufferp =
+            if role == AC.OFFSETS && d.len == 0 && d.offset == 0 && AC.isempty_buffer(b)
+                # Core omits the offsets of an empty array; C Data still
+                # expects the length+1 offsets, so export one zero.
+                Libc.memset(_malloc!(e, spec.offsetwidth), 0, spec.offsetwidth)
+            elseif AC.isempty_buffer(b)
+                # An absent validity bitmap, or any zero-byte buffer, is NULL.
+                Ptr{Cvoid}(C_NULL)
+            else
+                Ptr{Cvoid}(AC.sliceptr(b))
+            end
+        unsafe_store!(bufptrs, bufferp, i)
+    end
+    if spec.variadic
+        sizesp = Ptr{Int64}(_malloc!(e, max(nvariadic, 1) * 8))
+        for k = 1:nvariadic
+            unsafe_store!(sizesp, d.buffers[length(spec.buffers) + k].len, k)
+        end
+        unsafe_store!(bufptrs, Ptr{Cvoid}(sizesp), nbuf)
+    end
+    childptrs = Ptr{Ptr{CArrowArray}}(C_NULL)
+    if !isempty(d.children)
+        childptrs = Ptr{Ptr{CArrowArray}}(_malloc!(e, length(d.children) * sizeof(Ptr)))
+        for (i, c) in enumerate(d.children)
+            unsafe_store!(childptrs, _export_array!(e, c, release), i)
+        end
+    end
+    dict =
+        d.dictionary === nothing ? Ptr{CArrowArray}(C_NULL) :
+        _export_array!(e, d.dictionary, release)
+    unsafe_store!(e.live, unsafe_load(e.live) + 1)
+    unsafe_store!(
+        p,
+        CArrowArray(
+            d.len,
+            nullcount(d),
+            d.offset,
+            nbuf,
+            length(d.children),
+            bufptrs,
+            childptrs,
+            dict,
+            release,
+            Ptr{Cvoid}(e.live),
+        ),
+    )
+    return p
+end
+
+"""
+    Arrow.to_c_data(field, data) -> (Ptr{CArrowSchema}, Ptr{CArrowArray})
+
+The low-level form of [`Arrow.to_c_data`](@ref): export one column, an
+`Arrow.Field` and its `Arrow.ArrayData`, as an `ArrowSchema` and an `ArrowArray`
+that Arrow.jl allocates, pointing at `data`'s buffers without copying them. The
+column is validated before it is exported. The consumer moves or releases the
+two structs; `data` stays reachable until it has released the array, and what
+Arrow.jl allocated is freed by later exports or garbage collections.
+"""
+function to_c_data(f::Field, d::ArrayData)
+    validate_semantic(f, d)
+    e = _newexport(Any[f, d], sizeof(CArrowSchema) + sizeof(CArrowArray))
+    try
+        sp = _export_schema!(
+            e,
+            f,
+            @cfunction(_release_schema, Cvoid, (Ptr{CArrowSchema},));
+            at=Ptr{CArrowSchema}(e.top),
+        )
+        ap = _export_array!(
+            e,
+            d,
+            @cfunction(_release_array, Cvoid, (Ptr{CArrowArray},));
+            at=Ptr{CArrowArray}(e.top + sizeof(CArrowSchema)),
+        )
+        _register!(e)
+        return sp, ap
+    catch
+        _free!(e)
+        Libc.free(e.top)
+        rethrow()
+    end
+end
+
+# ---------------------------------------------------------------------------
+# Import: C structs -> Core, one ForeignOwner per moved tree
+# ---------------------------------------------------------------------------
+
+# One owner for one MOVED ArrowArray tree. Every `BufferSlice` of the tree
+# (children and dictionary) has a region whose `root` is this object and whose
+# cell is `cell`, so the tree outlives every slice, `release!` on the owner or
+# on any region revokes all of them, and the producer's release callback runs
+# exactly once: from `release!` or from the GC finalizer, whichever comes first.
+mutable struct ForeignOwner
+    # A malloc'd copy of the moved struct: the stable address its callback takes.
+    const block::Ptr{CArrowArray}
+    const thread::Int   # where a collected owner releases (`_releasethread`)
+    cell::AC.ReleaseCell
+    ForeignOwner(block::Ptr{CArrowArray}) = new(block, _releasethread())
+end
+
+# The thread whose task releases an import made on this thread once it is collected:
+# this thread, or thread 1 for a thread Julia adopted from a foreign library, which
+# runs no Julia tasks.
+_releasethread() = Threads.threadpool() === :foreign ? 1 : Threads.threadid()
+
+# The finalizer of an imported array or stream owner. A producer's release can
+# wait on a lock the importing thread holds (pyarrow's release of NumPy memory
+# takes Python's GIL, which PythonCall's main thread keeps), and a thread waiting
+# inside a finalizer stalls every garbage collection. So a finalizer on another
+# thread hands the release to a task on the owner's `thread` (the importing thread,
+# or thread 1), which runs it at its next yield. At exit, a release that would be
+# handed to another thread is skipped: Julia runs the finalizers of live objects then,
+# and the process is ending.
+function _finalizeowner(o)
+    Threads.threadid() == o.thread && return release!(o)
+    _EXITING[] && return nothing
+    t = Task(() -> release!(o))
+    t.sticky = true
+    ccall(:jl_set_task_tid, Cint, (Any, Cint), t, o.thread - 1)
+    schedule(errormonitor(t))
+    return nothing
+end
+
+function _release_owner_action(p::Ptr{Cvoid})::Cvoid
+    o = unsafe_pointer_to_objref(p)::ForeignOwner
+    GC.@preserve o try
+        _release_producer!(o.block)
+    finally
+        Libc.free(o.block)
+    end
+    return nothing
+end
+
+# Release an imported tree now: later access to its buffers throws an
+# `InvalidStateException`, and the producer's release callback runs, once. A
+# producer whose callback does not mark the struct released makes this throw.
+release!(o::ForeignOwner) = release!(o.cell)
+
+# A deep copy of imported data shares its owner, so the producer's release runs
+# once, for the original and every copy.
+Base.deepcopy_internal(o::ForeignOwner, ::IdDict) = o
+
+# Move the array at `ap`: copy its struct, mark the source released, and give
+# the copy an owner whose `release!` or finalizer runs the producer's release.
+function _moveowner(ap::Ptr{CArrowArray})
+    block = Ptr{CArrowArray}(Libc.malloc(sizeof(CArrowArray)))
+    block == C_NULL && throw(OutOfMemoryError())
+    unsafe_store!(block, unsafe_load(ap))
+    _store_field!(ap, Val(:release), Ptr{Cvoid}(C_NULL))
+    try
+        o = ForeignOwner(block)
+        o.cell = AC.ReleaseCell(@cfunction(_release_owner_action, Cvoid, (Ptr{Cvoid},)), o)
+        return finalizer(_finalizeowner, o)
+    catch
+        try
+            _release_producer!(block)
+        finally
+            Libc.free(block)
+        end
+        rethrow()
+    end
+end
+
+"Load child `i`'s CArrowArray by value out of a parent's children table."
+childat(a::CArrowArray, i::Int) = unsafe_load(unsafe_load(a.children, i))
+"Load buffer pointer `i` out of a CArrowArray's buffer table."
+bufferptr(a::CArrowArray, i::Int) = unsafe_load(a.buffers, i)
+
+"""
+    Arrow.from_c_data(schemaptr, arrayptr) -> (Arrow.Field, Arrow.ArrayData)
+
+The low-level form of [`Arrow.Table(schemaptr, arrayptr)`](@ref Arrow.Table): import
+one column. The array is moved, as the interface requires: Arrow.jl takes over its
+`release` callback and marks the struct at `arrayptr` released. The schema is read and
+then released. The imported buffers stay valid while the returned data is reachable;
+the producer's release callback runs when it no longer is.
+
+Buffer sizes follow from the declared lengths and offsets, which the producer is
+trusted to get right, as the interface cannot check them; the column is then validated
+as an IPC read is. A failed import releases the array.
+"""
+function from_c_data(sp::Ptr{CArrowSchema}, ap::Ptr{CArrowArray})
+    sp == C_NULL && throw(ArgumentError("ArrowSchema pointer is NULL"))
+    ap == C_NULL && throw(ArgumentError("ArrowArray pointer is NULL"))
+    sch = unsafe_load(sp)
+    (sch.release == C_NULL || unsafe_load(ap).release == C_NULL) &&
+        throw(ArgumentError("cannot import a released structure"))
+    owner = _moveowner(ap)
+    f = try
+        _preflight_schema(sch)
+        _import_field(sch)
+    catch
+        release!(owner)
+        rethrow()
+    finally
+        _release_producer!(sp)
+    end
+    return f, _importarray(f, owner)
+end
+
+# Import the moved array `owner` holds as a column of `f`; a failed import
+# releases it.
+function _importarray(f::Field, owner::ForeignOwner)
+    try
+        arr = unsafe_load(owner.block)
+        _preflight_array(f, arr)
+        d = _import_array(f, arr, owner)
+        validate_semantic(f, d)
+        return d
+    catch
+        release!(owner)
+        rethrow()
+    end
+end
+
+function _preflight_schema(sch::CArrowSchema, depth::Int=0)
+    depth <= 64 || throw(ValidationError("C schema nesting exceeds 64 levels"))
+    sch.release != C_NULL || throw(ValidationError("released C schema node"))
+    sch.format != C_NULL || throw(ValidationError("C schema format is NULL"))
+    sch.n_children >= 0 || throw(ValidationError("negative C schema child count"))
+    sch.n_children <= 1_000_000 ||
+        throw(ValidationError("C schema child count exceeds import limit"))
+    sch.n_children == 0 ||
+        sch.children != C_NULL ||
+        throw(ValidationError("C schema child table is NULL"))
+    for i = 1:sch.n_children
+        childptr = unsafe_load(sch.children, i)
+        childptr != C_NULL || throw(ValidationError("C schema child $i is NULL"))
+        _preflight_schema(unsafe_load(childptr), depth + 1)
+    end
+    if sch.dictionary != C_NULL
+        _preflight_schema(unsafe_load(sch.dictionary), depth + 1)
+    end
+    return nothing
+end
+
+function _preflight_array(f::Field, arr::CArrowArray, depth::Int=0)
+    depth <= 64 || throw(ValidationError("C array nesting exceeds 64 levels"))
+    arr.release != C_NULL || throw(ValidationError("released C array node"))
+    arr.length >= 0 || throw(ValidationError("negative C array length"))
+    arr.offset >= 0 || throw(ValidationError("negative C array offset"))
+    arr.length <= typemax(Int64) - arr.offset || throw(
+        ValidationError(
+            "C array length $(arr.length) plus offset $(arr.offset) overflows Int64",
+        ),
+    )
+    -1 <= arr.null_count <= arr.length ||
+        throw(ValidationError("invalid C array null count $(arr.null_count)"))
+    arr.n_buffers >= 0 || throw(ValidationError("negative C array buffer count"))
+    arr.n_children >= 0 || throw(ValidationError("negative C array child count"))
+    arr.n_buffers == 0 ||
+        arr.buffers != C_NULL ||
+        throw(ValidationError("C array buffer table is NULL"))
+    arr.n_children == 0 ||
+        arr.children != C_NULL ||
+        throw(ValidationError("C array child table is NULL"))
+
+    spec = AC.layoutspec_of(f.type)
+    expected_buffers = length(spec.buffers)
+    if spec.variadic
+        # validity + views + N variadic data buffers + the trailing int64
+        # sizes buffer: at least the fixed pair plus the sizes buffer.
+        Int64(arr.n_buffers) >= expected_buffers + 1 || throw(
+            ValidationError(
+                "view layout $(typeof(f.type)) requires at least $(expected_buffers + 1) buffers, producer sent $(arr.n_buffers)",
+            ),
+        )
+    else
+        Int64(arr.n_buffers) == expected_buffers || throw(
+            ValidationError(
+                "layout $(typeof(f.type)) declares $expected_buffers buffers, producer sent $(arr.n_buffers)",
+            ),
+        )
+    end
+    expected_children = spec.childcount == -1 ? length(f.children) : spec.childcount
+    Int64(arr.n_children) == expected_children || throw(
+        ValidationError(
+            "layout $(typeof(f.type)) declares $expected_children children, producer sent $(arr.n_children)",
+        ),
+    )
+
+    for i = 1:arr.n_children
+        childptr = unsafe_load(arr.children, i)
+        childptr != C_NULL || throw(ValidationError("C array child $i is NULL"))
+        child = unsafe_load(childptr)
+        cf = f.children[i]
+        _preflight_array(cf, child, depth + 1)
+    end
+    if f.type isa DictionaryType
+        arr.dictionary != C_NULL ||
+            throw(ValidationError("dictionary C array has no dictionary values"))
+        _preflight_array(
+            AC.dictvaluefield(f, f.type),
+            unsafe_load(arr.dictionary),
+            depth + 1,
+        )
+    elseif arr.dictionary != C_NULL
+        throw(ValidationError("non-dictionary C array has dictionary values"))
+    end
+    return nothing
+end
+
+# Longest C string a schema may carry. Format strings are tens of bytes;
+# names and metadata keys are human-scale. The cap converts a missing NUL
+# terminator from an unbounded memory scan into a clean refusal.
+const CSTRING_SCAN_LIMIT = Int64(1) << 20
+
+function _import_cstring(p::Ptr{UInt8}, what::AbstractString)
+    # The limit is enforced BEFORE every dereference: the scan window is
+    # exactly CSTRING_SCAN_LIMIT bytes, so the NUL must fall inside it
+    # (maximum payload is the limit minus one) and byte limit+1 is never
+    # touched — a guard page there must produce this refusal, not SIGBUS.
+    n = Int64(0)
+    while true
+        n >= CSTRING_SCAN_LIMIT && throw(
+            ValidationError(
+                "C Data $what has no NUL terminator within " *
+                "$(CSTRING_SCAN_LIMIT) bytes",
+            ),
+        )
+        unsafe_load(p + n) == 0x00 && break
+        n += 1
+    end
+    s = unsafe_string(p, n)
+    isvalid(s) || throw(ValidationError("C Data $what is not valid UTF-8"))
+    return s
+end
+
+function _validate_schema_flags(sch::CArrowSchema, fmt::AbstractString)
+    sch.flags & ~ARROW_FLAG_ALL_SUPPORTED == 0 ||
+        throw(ValidationError("C schema contains unsupported flag bits"))
+    (sch.flags & ARROW_FLAG_DICTIONARY_ORDERED == 0 || sch.dictionary != C_NULL) ||
+        throw(ValidationError("ARROW_FLAG_DICTIONARY_ORDERED requires a dictionary schema"))
+    (sch.flags & ARROW_FLAG_MAP_KEYS_SORTED == 0 || fmt == "+m") ||
+        throw(ValidationError("ARROW_FLAG_MAP_KEYS_SORTED requires a map schema"))
+    return nothing
+end
+
+"""
+Parse a C metadata blob. The pair count and the key/value lengths are
+producer-declared, the same trust as every other C Data pointer, but a
+negative length is rejected: it would wrap the walk. Metadata bytes are
+opaque binary key/value data, copied by declared length without UTF-8
+validation. Embedded NUL bytes are preserved.
+"""
+function _import_cmetadata(p::Ptr{UInt8})
+    p == C_NULL && return nothing
+    n = unsafe_load(Ptr{Int32}(p))
+    n < 0 && throw(ValidationError("C schema metadata declares a negative pair count"))
+    n == 0 && return nothing
+    off = Int64(4)
+    out = Pair{String,String}[]
+    for _ = 1:n
+        klen = unsafe_load(Ptr{Int32}(p + off))
+        klen < 0 &&
+            throw(ValidationError("C schema metadata declares a negative key length"))
+        k = unsafe_string(p + off + 4, klen)
+        off += 4 + Int64(klen)
+        vlen = unsafe_load(Ptr{Int32}(p + off))
+        vlen < 0 &&
+            throw(ValidationError("C schema metadata declares a negative value length"))
+        v = unsafe_string(p + off + 4, vlen)
+        off += 4 + Int64(vlen)
+        push!(out, k => v)
+    end
+    return out
+end
+
+function _import_field(sch::CArrowSchema)::Field
+    fmt = _import_cstring(sch.format, "format")
+    _validate_schema_flags(sch, fmt)
+    name = sch.name == C_NULL ? "" : _import_cstring(sch.name, "field name")
+    nullable = (sch.flags & ARROW_FLAG_NULLABLE) != 0
+    meta = _import_cmetadata(sch.metadata)
+    t = parseformat(fmt, sch.flags)
+
+    # Check the schema shape before indexing any recursively-created child.
+    # Struct is the only mapped layout with field-declared arity.
+    spec = AC.layoutspec_of(t)
+    expected_children = spec.childcount
+    if expected_children >= 0 && sch.n_children != expected_children
+        throw(
+            ValidationError(
+                "C schema for $(typeof(t)) declares $(sch.n_children) children; expected $expected_children",
+            ),
+        )
+    end
+    t isa UnionType &&
+        length(t.typeids) != sch.n_children &&
+        throw(
+            ValidationError(
+                "union format declares $(length(t.typeids)) type ids for $(sch.n_children) children",
+            ),
+        )
+
+    children = Field[]
+    for i = 1:sch.n_children
+        push!(children, _import_field(unsafe_load(unsafe_load(sch.children, i))))
+    end
+    if sch.dictionary != C_NULL
+        vf = _import_field(unsafe_load(sch.dictionary))
+        t isa IntType ||
+            throw(ValidationError("dictionary index format must be an integer"))
+        isempty(children) ||
+            throw(ValidationError("dictionary index schema must not have children"))
+        ordered = (sch.flags & ARROW_FLAG_DICTIONARY_ORDERED) != 0
+        # The value node's metadata joins the wrapper's (wrapper pairs
+        # first; duplicate keys are legal): Core's one slot cannot express
+        # the two-node attribution, but no pair is lost.
+        vmeta = vf.metadata
+        dmeta =
+            meta === nothing ?
+            (vmeta === nothing ? nothing : collect(Pair{String,String}, vmeta)) :
+            (vmeta === nothing ? meta : vcat(meta, collect(Pair{String,String}, vmeta)))
+        # Branch on the metadata's presence: a Union-typed keyword makes
+        # the kwcall tuple imprecise, which trim cannot resolve.
+        dmeta === nothing && return Field(
+            name,
+            DictionaryType(t, vf.type, ordered);
+            nullable=nullable,
+            children=vf.children,
+        )
+        return Field(
+            name,
+            DictionaryType(t, vf.type, ordered);
+            nullable=nullable,
+            metadata=dmeta,
+            children=vf.children,
+        )
+    end
+    meta === nothing && return Field(name, t; nullable=nullable, children=children)
+    return Field(name, t; nullable=nullable, metadata=meta, children=children)
+end
+
+"""
+Compute each buffer's DECLARED byte extent from the layout registry and wrap
+it as a slice over a foreign region rooted by `owner`. Offsets buffers are
+sized first (len+1 entries) and then READ — inside their own declared bounds
+— to size the data buffer they govern; that dependency order is exactly the
+registry's buffer order, so the loop stays generic.
+"""
+function _import_array(f::Field, arr::CArrowArray, owner::ForeignOwner)::ArrayData
+    t = f.type
+    spec = AC.layoutspec_of(t)
+    total = AC.checked_add(arr.offset, arr.length)
+    buffers = BufferSlice[]
+    offsets_slice = nothing
+    for (i, role) in enumerate(spec.buffers)
+        p = bufferptr(arr, i)
+        nbytes = if role == AC.VALIDITY
+            p == C_NULL &&
+                total > 0 &&
+                arr.null_count != 0 &&
+                throw(ValidationError("NULL validity buffer requires null_count == 0"))
+            p == C_NULL ? Int64(0) : AC.expected_validity_bytes(total)
+        elseif role == AC.OFFSETS
+            # Hostile extents overflow as ValidationErrors, as in Core's own
+            # structural checks.
+            total < typemax(Int64) ||
+                throw(ValidationError("required offsets buffer bytes overflow Int64"))
+            AC._required_extent(
+                total + Int64(1),
+                Int64(spec.offsetwidth),
+                "offsets buffer bytes",
+            )
+        elseif role == AC.DATA
+            if spec.fixedwidth > 0
+                AC._required_extent(total, Int64(spec.fixedwidth), "data buffer bytes")
+            elseif spec.fixedwidth == -1
+                AC.expected_validity_bytes(total)
+            else
+                # varbinary data: sized by the final offset, read from the
+                # offsets slice we just built (bounded by ITS declared size).
+                if offsets_slice === nothing || AC.isempty_buffer(offsets_slice)
+                    Int64(0)
+                else
+                    finaloffset = if spec.offsetwidth == 8
+                        AC.loadat(offsets_slice, Int64, AC.checked_mul(total, Int64(8)))
+                    else
+                        Int64(AC.loadat(offsets_slice, Int32, AC.checked_mul(total, Int64(4))))
+                    end
+                    finaloffset >= 0 ||
+                        throw(ValidationError("negative final offset $finaloffset"))
+                    finaloffset
+                end
+            end
+        elseif role == AC.TYPE_IDS
+            # One Int8 discriminator per union slot.
+            total
+        elseif role == AC.ELEMENT_OFFSETS || role == AC.SIZES
+            # Per-slot values (dense-union offsets; list-view offsets and
+            # sizes), not monotone ranges: exactly `total` entries, no +1.
+            AC._required_extent(total, Int64(spec.offsetwidth), "per-slot buffer bytes")
+        elseif role == AC.VIEWS
+            AC._required_extent(total, Int64(16), "views buffer bytes")
+        else
+            throw(ValidationError("unsupported buffer role $role in C data import"))
+        end
+        if p == C_NULL
+            nbytes == 0 ||
+                throw(ValidationError("NULL $role buffer with nonzero required size"))
+            push!(buffers, BufferSlice())
+        else
+            region = OwnerRegion(Ptr{UInt8}(p), nbytes; root=owner, cell=owner.cell)
+            slice = BufferSlice(region, 0, nbytes)
+            role == AC.OFFSETS && (offsets_slice = slice)
+            push!(buffers, slice)
+        end
+    end
+    if spec.variadic
+        # The trailing int64 sizes buffer declares each variadic data
+        # buffer's extent — the one place the ABI carries a length for them.
+        nfixed = length(spec.buffers)
+        nvariadic = Int(arr.n_buffers) - nfixed - 1
+        sizesp = Ptr{Int64}(bufferptr(arr, Int(arr.n_buffers)))
+        (nvariadic == 0 || sizesp != C_NULL) || throw(
+            ValidationError("view array with variadic buffers has a NULL sizes buffer"),
+        )
+        for k = 1:nvariadic
+            len = unsafe_load(sizesp, k)
+            len >= 0 || throw(ValidationError("negative variadic buffer length $len"))
+            p = bufferptr(arr, nfixed + k)
+            if p == C_NULL
+                len == 0 || throw(
+                    ValidationError("NULL variadic buffer with nonzero declared length"),
+                )
+                push!(buffers, BufferSlice())
+            else
+                region = OwnerRegion(Ptr{UInt8}(p), len; root=owner, cell=owner.cell)
+                push!(buffers, BufferSlice(region, 0, len))
+            end
+        end
+    end
+    children = ArrayData[]
+    for i = 1:arr.n_children
+        # Preflight already rejects children on a dictionary node, so this
+        # branch is unreachable; it keeps the expression total for inference.
+        cf = t isa DictionaryType ? error("dictionary carries no children") : f.children[i]
+        push!(children, _import_array(cf, childat(arr, i), owner))
+    end
+    dict = nothing
+    if arr.dictionary != C_NULL
+        t isa DictionaryType ||
+            throw(ValidationError("dictionary array on a non-dictionary field"))
+        dict = _import_array(AC.dictvaluefield(f, t), unsafe_load(arr.dictionary), owner)
+    end
+    return AC._arraydata(
+        t,
+        arr.length,
+        buffers,
+        arr.offset,
+        children,
+        dict,
+        owner,
+        arr.null_count,
+    )
+end
diff --git a/src/cdata_table.jl b/src/cdata_table.jl
new file mode 100644
index 00000000..6da691ef
--- /dev/null
+++ b/src/cdata_table.jl
@@ -0,0 +1,274 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The table-level C data interface: `Arrow.Table` and `Arrow.Stream` over
+# imported C structs, and `Arrow.to_c_data` and `Arrow.export_stream!` over any
+# Tables.jl table. Imports build columns the way an IPC read does; exports
+# build record batches the way `Arrow.write` does.
+
+# --- import -----------------------------------------------------------------
+
+# The read keywords, checked before anything is moved out of a C struct, so a
+# bad keyword cannot strand an import.
+function _creadargs(;
+    stringtype::Type=DataStrings.DataString,
+    ntasks::Integer=Threads.nthreads(),
+    limits::Limits=Limits(),
+    unknown...,
+)
+    isempty(unknown) || throw(
+        ArgumentError(
+            "a C data import takes the keywords stringtype, ntasks, and limits, not " *
+            join(keys(unknown), ", "),
+        ),
+    )
+    _checkstringtype(stringtype)
+    return stringtype, _checkntasks(ntasks), limits
+end
+
+# The table of `batches` with schema `sch`, built by the scan executor as an IPC
+# read builds one. View columns read the producer's memory without checking a flag,
+# and the Table contract lets columns outlive `release!`, so `release!(table)` only
+# refuses further column access; the producer's release runs when the last column is
+# garbage collected, as a mapped file is unmapped.
+function _ctable(
+    sch::AC.Schema,
+    batches::Vector{AC.RecordBatch},
+    stringtype,
+    ntasks,
+    limits,
+)
+    budget = _readbudget(limits, sum(_databytes, batches; init=Int64(0)))
+    fields = collect(AC.Field, sch.fields)
+    plan = _ScanPlan(Tables.Scan(), fields, budget)
+    ctx = _ScanContext(_ViewContext(stringtype, budget), _ArrowTypesContext(budget=budget))
+    t, _ = _scantable(
+        _DecodedRecord[_DecodedRecord(b) for b in batches],
+        _importdecoder(fields, limits),
+        plan,
+        nothing,
+        ctx,
+        _uniqueschema(sch),
+        AC.OwnerRegion[AC.OwnerRegion(Ptr{UInt8}(C_NULL), 0)],
+        budget;
+        ntasks,
+        lazy=true,
+    )
+    return t
+end
+
+# A decoder for imported batches, which arrive decoded and validated.
+_importdecoder(fields, limits) =
+    _Decoder(fields, IdDict{Field,Int64}(), AC._ValidatedDictionaries(), limits)
+
+# The bytes of a batch's buffers, which size the allowance its read charges.
+_databytes(b::AC.RecordBatch) = sum(_databytes, b.columns; init=Int64(0))
+_databytes(d::AC.ArrayData) =
+    sum(x -> Int64(x.len), d.buffers; init=Int64(0)) +
+    sum(_databytes, d.children; init=Int64(0))
+
+# Release the batches of a failed import; a batch without columns has nothing to hold.
+function _releasebatches!(batches)
+    for b in batches
+        isempty(b.columns) || release!(b.columns[1].owner::ForeignOwner)
+    end
+    return nothing
+end
+
+# A struct array is a record batch of its fields; any other array is a
+# one-column batch named after its schema.
+function _recordbatch(f::AC.Field, d::AC.ArrayData)
+    if f.type isa AC.StructType
+        sch = AC.Schema(collect(AC.Field, f.children); metadata=f.metadata)
+        return sch, _structbatch(sch, d)
+    end
+    sch = AC.Schema(AC.Field[f])
+    return sch, AC.RecordBatch(sch, AC.ArrayData[d], d.len)
+end
+
+"""
+    Arrow.Table(schemaptr::Ptr{Arrow.CArrowSchema}, arrayptr::Ptr{Arrow.CArrowArray};
+                stringtype=DataString, ntasks=Threads.nthreads(), limits=Arrow.Limits())
+
+Import one array through the C data interface as a table. A struct array (a record
+batch) becomes a table of its fields; any other array becomes a one-column table named
+after the schema. The array is moved, as the interface requires, and the schema is read
+and released. The columns have the types an IPC read of the same data has. Numbers,
+dates, and other fixed-width values are read in the producer's memory, and string and
+binary values are copied. `Arrow.release!(table)` refuses further column access, and the
+producer's `release` callback runs once the table and its columns are garbage collected.
+`stringtype`, `ntasks`, and `limits` mean what they mean for `Arrow.Table`.
+"""
+function Table(sp::Ptr{CArrowSchema}, ap::Ptr{CArrowArray}; kw...)
+    stringtype, ntasks, limits = _creadargs(; kw...)
+    f, d = from_c_data(sp, ap)
+    try
+        sch, b = _recordbatch(f, d)
+        return _ctable(sch, AC.RecordBatch[b], stringtype, ntasks, limits)
+    catch
+        release!(d.owner::ForeignOwner)
+        rethrow()
+    end
+end
+
+"""
+    Arrow.Table(streamptr::Ptr{Arrow.CArrowArrayStream};
+                stringtype=DataString, ntasks=Threads.nthreads(), limits=Arrow.Limits())
+
+Import a whole C stream as a table. The stream is moved, as the interface requires,
+every record batch is read, and the stream is released. The columns chain the batches
+as an IPC read's do; fixed-width values stay in the producer's memory, which its
+`release` callbacks give back once the table and its columns are garbage collected.
+[`Arrow.Stream(streamptr)`](@ref Arrow.Stream) reads one batch at a time instead.
+"""
+function Table(p::Ptr{CArrowArrayStream}; kw...)
+    stringtype, ntasks, limits = _creadargs(; kw...)
+    s = from_c_stream(p; limits)
+    batches = AC.RecordBatch[]
+    try
+        while (b = AC.nextbatch!(s)) !== nothing
+            push!(batches, b)
+        end
+        return _ctable(s.schema, batches, stringtype, ntasks, limits)
+    catch
+        _releasebatches!(batches)
+        rethrow()
+    finally
+        release!(s)
+    end
+end
+
+# The cell action of an `Arrow.Stream` over a C stream: release the producer's stream.
+function _release_imported_stream(p::Ptr{Cvoid})::Cvoid
+    release!(unsafe_pointer_to_objref(p)::ImportedStream)
+    return nothing
+end
+
+"""
+    Arrow.Stream(streamptr::Ptr{Arrow.CArrowArrayStream};
+                 stringtype=DataString, ntasks=Threads.nthreads(), limits=Arrow.Limits())
+
+Read a C stream one record batch at a time: each iteration pulls the next batch from the
+producer and gives it as an [`Arrow.Table`](@ref), built as
+[`Arrow.Table(streamptr)`](@ref Arrow.Table) builds its columns. The stream is moved, as the interface requires. It is iterated once,
+from one task at a time, and its length is unknown until it is read. As for any
+`Arrow.Stream`, [`Arrow.release!`](@ref) of the stream or of a table it yielded
+releases the producer's stream and refuses further column access; columns already
+taken stay valid.
+"""
+function Stream(p::Ptr{CArrowArrayStream}; kw...)
+    stringtype, ntasks, limits = _creadargs(; kw...)
+    src = from_c_stream(p; limits)
+    budget = _readbudget(limits, 0)
+    closed = AC.ReleaseCell(@cfunction(_release_imported_stream, Cvoid, (Ptr{Cvoid},)), src)
+    fields = _batchfields(src)
+    return Stream(
+        src,
+        AC.OwnerRegion[AC.OwnerRegion(Ptr{UInt8}(C_NULL), 0; cell=closed)],
+        budget,
+        closed,
+        _ArrowTypesContext(budget=budget),
+        ReentrantLock(),
+        _ViewContext(stringtype, budget),
+        ntasks,
+        nothing,
+        _ScanPlan(Tables.Scan(), fields, budget),
+        trues(length(fields)),
+    )
+end
+
+# The imported stream as an `Arrow.Stream` source: its batches arrive as the
+# iteration pulls them (`_streambatch`), so their number is unknown until then.
+_configuredlimits(s::ImportedStream) = s.limits
+_tableschema(s::ImportedStream) = _uniqueschema(s.schema)
+_batchfields(s::ImportedStream) = s.schema.fields
+_decoder(s::ImportedStream) = _importdecoder(s.schema.fields, s.limits)
+_nbatches(::ImportedStream) = throw(
+    ArgumentError(
+        "the number of batches of a C stream is unknown until it is read; " *
+        "iterate the Arrow.Stream",
+    ),
+)
+
+# --- export -----------------------------------------------------------------
+
+# The schema and record batches of `tbl`: a one-shot IPC stream write to nowhere
+# that keeps each batch it builds, so construction, dictionary state, and refusals
+# are the writer's own and a C consumer sees what pyarrow reads from the IPC bytes.
+# The kept buffers are fresh allocations (`exported` turns off the writer's reusable
+# pool), because the consumer holds on to them. One record batch per partition, unless
+# `batchsize` splits it or a batch's string data outgrows 32-bit offsets. A first
+# partition with no rows still fixes the schema; its empty batch is the only one with
+# no rows.
+function _exportbatches(tbl; batchsize::Integer=typemax(Int), kw...)
+    for k in (:file, :compress, :compresslevel, :dictdeltas, :dictreplacement)
+        haskey(kw, k) && throw(ArgumentError("$k does not apply to the C data interface"))
+    end
+    batches = AC.RecordBatch[]
+    w = _writer(devnull; oneshot=true, batchsize, exported=batches, kw...)
+    _writeall!(w, tbl)
+    return w.schema::AC.Schema, batches
+end
+
+"""
+    Arrow.to_c_data(table; kw...) -> (Ptr{Arrow.CArrowSchema}, Ptr{Arrow.CArrowArray})
+
+Export a Tables.jl table as one record batch through the C data interface: an
+`ArrowSchema` and an `ArrowArray` that Arrow.jl allocates, whose struct array has one
+child per column. The columns are built as [`Arrow.write`](@ref) builds them, with the
+same keywords (`dictencode`, `stringview`, `largelists`, `metadata`, `colmetadata`), so a
+consumer reads what it would read from the IPC bytes. A `Vector` of `Int8` to `Int64`,
+`UInt8` to `UInt64`, or `Float16` to `Float64` crosses without copying, as do an
+[`Arrow.Table`](@ref) column's integer, float, and boolean values and validity bitmaps;
+what crosses without copying must not be modified or resized while the consumer reads
+it. Everything else, `Bool` and `missing` in Julia vectors, decimals, dates and
+timestamps, string and list offsets, a list's own validity bitmap, and fixed-size list
+values included, is built into new buffers, and string bytes may be copied. The consumer
+moves or releases the two structs; the table's memory stays reachable until it has
+released the array, and what Arrow.jl allocated is freed by later exports or garbage
+collections. A table that needs more than one record batch (several partitions
+with rows, or string data past 2 GiB) is an `ArgumentError`; export it with
+[`Arrow.export_stream!`](@ref).
+"""
+function to_c_data(tbl; kw...)
+    sch, batches = _exportbatches(tbl; kw...)
+    # An empty first partition only fixed the schema.
+    length(batches) > 1 && filter!(b -> b.nrows > 0, batches)
+    length(batches) == 1 || throw(
+        ArgumentError(
+            "the table needs $(length(batches)) record batches; export it with " *
+            "Arrow.export_stream!",
+        ),
+    )
+    return to_c_data(_batchfield(sch), _structarray(only(batches)))
+end
+
+"""
+    Arrow.export_stream!(streamptr::Ptr{Arrow.CArrowArrayStream}, table; kw...)
+
+Fill the `ArrowArrayStream` the caller allocated at `streamptr` with the record batches
+of a Tables.jl table: one per `Tables.partitions` partition (an [`Arrow.Stream`](@ref)
+is a partition per batch read), split only when `batchsize` is given or a batch's string
+data outgrows 32-bit offsets. The batches are built as [`Arrow.write`](@ref) builds them,
+with the same keywords, before this returns; the consumer pulls them through the stream
+and releases it. Buffers cross without copying where `Arrow.write` would not copy them.
+Memory stays reachable until the consumer has released the stream and every batch it
+pulled.
+"""
+function export_stream!(sp::Ptr{CArrowArrayStream}, tbl; kw...)
+    sch, batches = _exportbatches(tbl; kw...)
+    return export_stream!(sp, sch, AC.RecordBatch[b for b in batches if b.nrows > 0])
+end
diff --git a/src/columnconstruction.jl b/src/columnconstruction.jl
new file mode 100644
index 00000000..2bb03fb1
--- /dev/null
+++ b/src/columnconstruction.jl
@@ -0,0 +1,4398 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# Column construction: Julia columns -> Arrow Field + ArrayData.
+#
+# This file owns fresh inference, retained-schema reconstruction, recursive
+# ArrowTypes lowering, dictionary pool policy, and field metadata. The write
+# facade binds partitions and delegates each complete column through
+# `_constructcolumn`.
+# =============================================================================
+
+"Copy a Field's metadata into stable, owned key-value pairs."
+_fieldmetadata(f::AC.Field) =
+    f.metadata === nothing ? nothing : collect(Pair{String,String}, f.metadata)
+
+# The Arrow unit of a Timestamp/ZonedTimestamp element type. Only the four
+# built-in resolutions have an Arrow timestamp unit; Durations 1.3+ permits
+# package-defined periods, which have no Arrow representation.
+function _instantunit(T::Type)
+    P = _instantelementperiod(T)
+    P === Dates.Second && return AC.SECOND
+    P === Dates.Millisecond && return AC.MILLISECOND
+    P === Dates.Microsecond && return AC.MICROSECOND
+    P === Dates.Nanosecond && return AC.NANOSECOND
+    throw(
+        ArgumentError(
+            "timestamp period $P has no Arrow timestamp unit; use Second, " *
+            "Millisecond, Microsecond, or Nanosecond resolution",
+        ),
+    )
+end
+_instantelementperiod(::Type{Durations.Timestamp{P}}) where {P} = P
+_instantelementperiod(::Type{<:Durations.ZonedTimestamp{P}}) where {P} = P
+
+"One native (Field, ArrayData) column from a Julia vector, facade conversions included."
+# The column-level dispatchers (`_constructnativepart`, `_constructpart`) do
+# not specialize on the vector type: the builders they call do, so each new
+# column type compiles its builder and not the whole dispatch. Each keyword
+# method calls its body through `_uninferred`, so a method another package adds
+# under a body makes only that body compile again, not every column type's
+# keyword method.
+Base.@nospecializeinfer _constructnativepart(
+    name::String,
+    @nospecialize(v::AbstractVector);
+    context=nothing,
+) = _uninferred(_nativepart, name, v, context)::Tuple{AC.Field,AC.ArrayData}
+
+Base.@nospecializeinfer function _nativepart(
+    name::String,
+    @nospecialize(v::AbstractVector),
+    context,
+)
+    T = Base.nonmissingtype(_eltypeof(v))
+    # With TimeZones loaded, a fresh ZonedDateTime column writes as a
+    # timezone-declared millisecond timestamp (ext/ArrowTimeZonesExt.jl)
+    # instead of reflecting the zone's whole transition table as a struct.
+    if _zonedwritertype(T)
+        zoned = _uninferred(_zonednativepart, name, v, T)
+        zoned === nothing || return zoned
+    end
+    if _eltypeof(v) === Missing
+        t = AC.NullType()
+        return AC.Field(name, t; nullable=true),
+        AC.ArrayData(t, length(v), AC.BufferSlice[]; nullcount=length(v))
+    elseif T === Union{}
+        throw(
+            ArgumentError(
+                "column $(_errname(context, name)) has no values to infer an Arrow " *
+                "type from; give the empty column a concrete element type " *
+                "(Int64[] or String[], say)",
+            ),
+        )
+    elseif T <: Union{DataDecimals.Decimal,Durations.Duration}
+        return _uninferred(_constructsharedpart, name, v, T)
+    elseif T <: Durations.Timestamp
+        isconcretetype(T) || throw(
+            ArgumentError(
+                "column $(_errname(context, name)) has abstract Timestamp element " *
+                "type $T; give the column one concrete resolution",
+            ),
+        )
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.TimestampType(_instantunit(T), nothing),
+            x -> Int64(Dates.value(x)),
+        )
+    elseif T <: Durations.ZonedTimestamp
+        isconcretetype(T) || throw(
+            ArgumentError(
+                "column $(_errname(context, name)) has abstract ZonedTimestamp " *
+                "element type $T; an Arrow column declares one time zone and one " *
+                "resolution — " *
+                "convert the values with Durations.astimezone first",
+            ),
+        )
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.TimestampType(_instantunit(T), Durations.zonename(T)::String),
+            x -> Int64(Dates.value(x)),
+        )
+    elseif T <: Dates.Date
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.DateType(AC.DAY),
+            x -> Int32(Dates.value(x) - _EPOCH_DAYS),
+        )
+    elseif T <: Dates.DateTime
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.TimestampType(AC.MILLISECOND, nothing),
+            x -> Int64(Dates.value(x) - Dates.UNIXEPOCH),
+        )
+    elseif T <: Dates.Time
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.TimeType(AC.NANOSECOND, 64),
+            x -> Int64(Dates.value(x)),
+        )
+    elseif T <: Dates.Period &&
+           T <: Union{Dates.Second,Dates.Millisecond,Dates.Microsecond,Dates.Nanosecond}
+        unit =
+            T <: Dates.Second ? AC.SECOND :
+            T <: Dates.Millisecond ? AC.MILLISECOND :
+            T <: Dates.Microsecond ? AC.MICROSECOND : AC.NANOSECOND
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.DurationType(unit),
+            x -> Int64(Dates.value(x)),
+        )
+    elseif T <: Union{Dates.Week,Dates.Day,Dates.Hour,Dates.Minute}
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.DurationType(AC.SECOND),
+            _periodseconds,
+        )
+    elseif T <: Union{Dates.Month,Dates.Year}
+        return _uninferred(
+            _constructtemporalpart,
+            name,
+            v,
+            AC.IntervalType(AC.YEAR_MONTH),
+            _periodmonths,
+        )
+    elseif T <: NamedTuple
+        _uninferred(any, ismissing, v)::Bool && throw(
+            ArgumentError(
+                "column $name has nullable NamedTuple rows that require the " *
+                "recursive column adapter",
+            ),
+        )
+        isconcretetype(T) || throw(
+            ArgumentError(
+                "column $(_errname(context, name)) has abstract NamedTuple element " *
+                "type; give it a concrete NamedTuple type with declared field names " *
+                "and types",
+            ),
+        )
+        # Only the empty NamedTuple reaches here: `_nestedkind` takes every
+        # other NamedTuple column.
+        return _structpart(name, v, context)
+    elseif T <: AbstractString
+        _stringview(context) && return _uninferred(
+            _retainedview,
+            AC.Field(name, AC.ViewType(true); nullable=Missing <: _eltypeof(v)),
+            v,
+        )
+        return _uninferred(_varbytespart, name, v, AC.Utf8Type(_largelists(context)))
+    elseif T <: AbstractVector{UInt8}
+        _stringview(context) && return _uninferred(
+            _retainedview,
+            AC.Field(name, AC.ViewType(false); nullable=Missing <: _eltypeof(v)),
+            v,
+        )
+        return _uninferred(_varbytespart, name, v, AC.BinaryType(_largelists(context)))
+    elseif T === Any || (T <: AbstractVector && eltype(T) === Any)
+        # Materialized facade columns are Any-eltype for composite layouts;
+        # one narrowing pass recovers list columns (inner vectors narrow
+        # element-wise, empties adopt the joined element type).
+        w = _uninferred(_narrowlists, v, _errname(context, name))
+        NW = Base.nonmissingtype(_eltypeof(w))
+        (NW === Any || (NW <: AbstractVector && eltype(NW) === Any)) && throw(
+            ArgumentError(
+                "column $(_errname(context, name)) has element type Any and cannot " *
+                "be narrowed to a writable Arrow column; give it a concrete element type",
+            ),
+        )
+        return _constructpart(name, w; context)
+    elseif T <: AbstractVector
+        context === nothing && (context = _WriterContext())
+        return _uninferred(_listpart, name, v, context)
+    elseif T === Bool
+        return _uninferred(_boolpart, name, v)
+    elseif T <: _FixedPrimitive
+        t = AC.arrowtype_for(T)
+        if _eltypeof(v) === T
+            data = _uninferred(_fixedbuffer, v)
+            data === nothing && return _uninferred(AC.fromjulia, name, _plainvector(v))
+            return AC.Field(name, t; nullable=false),
+            AC.ArrayData(t, length(v), [AC.BufferSlice(), data]; nullcount=0)
+        end
+        vals, validity, nc = _uninferred(_nullablevalues, T, v, zero(T))::Tuple
+        return AC.Field(name, t; nullable=true),
+        AC.ArrayData(t, length(v), [validity, AC._databuffer(vals)]; nullcount=nc)
+    else
+        # The vector's type is known at run time; see `_uninferred`.
+        return _uninferred(AC.fromjulia, name, _plainvector(v))
+    end
+end
+
+const _FixedPrimitive =
+    Union{Int8,Int16,Int32,Int64,UInt8,UInt16,UInt32,UInt64,Float16,Float32,Float64}
+
+"A Bool column: values and validity bit-packed in one pass."
+function _boolpart(name::String, v::AbstractVector)
+    n = length(v)
+    i0 = firstindex(v) - 1
+    values = Vector{UInt8}(undef, cld(n, 8))
+    bits = Vector{UInt8}(undef, cld(n, 8))
+    valid = 0
+    @inbounds for b in eachindex(bits)
+        base = (b - 1) << 3
+        byte = 0x00
+        valuebyte = 0x00
+        for j = 0:(min(8, n - base) - 1)
+            x = v[i0 + base + j + 1]
+            present = x !== missing
+            byte |= UInt8(present) << (j % UInt)
+            valuebyte |= UInt8(present && x::Bool) << (j % UInt)
+        end
+        bits[b] = byte
+        values[b] = valuebyte
+        valid += count_ones(byte)
+    end
+    nc = n - valid
+    t = AC.BoolType()
+    validity = nc == 0 ? AC.BufferSlice() : AC._databuffer(bits)
+    return AC.Field(name, t; nullable=Missing <: _eltypeof(v)),
+    AC.ArrayData(t, n, [validity, AC._databuffer(values)]; nullcount=nc)
+end
+
+"""
+The values of a non-null fixed-width column as one buffer: a `Vector`, or a
+contiguous view of one (a record batch's rows), is borrowed without a copy;
+nothing for any other vector or a nullable element type.
+"""
+function _fixedbuffer(v::AbstractVector{T}) where {T}
+    isbitstype(T) || return nothing
+    v isa Vector{T} && return AC._databuffer(v)
+    v isa SubArray{T,1,Vector{T},<:Tuple{AbstractUnitRange{Int}},true} || return nothing
+    offset = (first(parentindices(v)[1]) - 1) * sizeof(T)
+    return AC.BufferSlice(AC.heapregion(parent(v)), offset, length(v) * sizeof(T))
+end
+
+"One (Field, ArrayData) column, including the ArrowTypes compatibility adapter."
+Base.@nospecializeinfer _constructpart(
+    name::String,
+    @nospecialize(v::AbstractVector);
+    context=nothing,
+    narrowabstract::Bool=true,
+) = _uninferred(_partof, name, v, context, narrowabstract)::Tuple{AC.Field,AC.ArrayData}
+
+Base.@nospecializeinfer function _partof(
+    name::String,
+    @nospecialize(v::AbstractVector),
+    context,
+    narrowabstract::Bool,
+)
+    context === nothing && (context = _WriterContext())
+    if _eltypeof(v) === Any
+        narrowed = _uninferred(_narrowlists, v, _errname(context, name))
+        _eltypeof(narrowed) === Any && throw(
+            ArgumentError(
+                "column $(_errname(context, name)) has element type Any and cannot " *
+                "be narrowed to a writable Arrow column; give it a concrete element type",
+            ),
+        )
+        return _constructpart(name, narrowed; context)
+    end
+    nested = _uninferred(_nestedpart, name, v, context)
+    nested === nothing || return nested
+    if narrowabstract
+        narrowed = _uninferred(_narrowabstractcolumn, name, v, context)
+        if narrowed !== nothing
+            # Julia can canonicalize a Union of concrete Tuple runtime types
+            # back to the original abstract declaration, so eltype may be
+            # unchanged. One narrowing pass is enough; recursing on the same
+            # declaration would loop.
+            _eltypeof(narrowed) === _eltypeof(v) ||
+                return _constructpart(name, narrowed; context, narrowabstract=false)
+        end
+    end
+    # The builders compile for the column's own type (see `_uninferred`).
+    return _uninferred(_arrowtypes_needs, v, context)::Bool ?
+           _uninferred(_constructarrowtypespart, name, v; context) :
+           _constructnativepart(name, v; context)
+end
+
+# --- plain nested columns -------------------------------------------------------
+#
+# Lists (rows are AbstractVectors), fixed-size lists (NTuples of one element
+# type), structs (NamedTuples), and maps (AbstractDicts or AbstractVectors of
+# Pairs) build here in a few typed passes, at any depth and with missing at
+# any level. Their children build as columns do, so leaves keep every
+# mapping. A container with an ArrowTypes.jl mapping or label of its own takes
+# the general route.
+
+# How an error names a column: a nested child also names its top-level column.
+_errname(context, name) =
+    context === nothing || isempty(context.column) || context.column == name ? name :
+    "$(context.column) (child $name)"
+
+"The layout `T` writes as (`:list`, `:fixedlist`, `:struct`, `:map`), or nothing."
+function _nestedkind(context, T::Type)
+    Base.@nospecialize T
+    T isa DataType && T <: Union{AbstractVector,AbstractDict,Tuple,NamedTuple} ||
+        return nothing
+    T <: AbstractVector{UInt8} && return nothing
+    _writerstoragetype!(context, T) === T && _writerextension!(context, T) === nothing ||
+        return nothing
+    if T <: NamedTuple
+        return fieldcount(T) > 0 ? :struct : nothing
+    elseif T <: Tuple
+        # NTuple{N,UInt8} is fixed_size_binary; tuples of mixed types are structs.
+        Base.isvatuple(T) && return nothing
+        types = fieldtypes(T)
+        (isempty(types) || !allequal(types) || types[1] === UInt8) && return nothing
+        return :fixedlist
+    end
+    T <: AbstractDict && return :map
+    E = eltype(T)
+    return E !== Union{} && E <: Pair ? :map : :list
+end
+
+"""
+`v` as a plain nested column, or nothing when it is not one. Nothing too for
+a struct or fixed-size list with missing rows whose non-nullable children
+cannot hide placeholder slots (see `_hidevalidity`).
+"""
+function _nestedpart(name::String, @nospecialize(v::AbstractVector), context)
+    kind = _nestedkind(context, Base.nonmissingtype(_eltypeof(v)))
+    kind === nothing && return nothing
+    # Dispatching on the kind compiles only the matching builder for `v`'s type.
+    return _nestedbuild(Val(kind), name, v, context)
+end
+_nestedbuild(::Val{:list}, name, @nospecialize(v), context) = _listpart(name, v, context)
+_nestedbuild(::Val{:map}, name, @nospecialize(v), context) = _mappart(name, v, context)
+_nestedbuild(::Val{:struct}, name, @nospecialize(v), context) =
+    _structpart(name, v, context)
+_nestedbuild(::Val{:fixedlist}, name, @nospecialize(v), context) =
+    _fixedlistpart(name, v, context)
+
+"""
+List offsets (row `i` holds values `offsets[i]+1:offsets[i+1]` of the
+child), validity, and null count of `v`'s rows, in one pass.
+"""
+function _listoffsets(name::String, v::AbstractVector, ::Type{O}, pool=nothing) where {O}
+    n = length(v)
+    i0 = firstindex(v) - 1
+    offsets = _takevector(pool, O, n + 1)
+    offsets[1] = 0
+    bits = _takevector(pool, UInt8, cld(n, 8))
+    pos = 0
+    valid = 0
+    @inbounds for b in eachindex(bits)
+        base = (b - 1) << 3
+        byte = 0x00
+        for j = 0:(min(8, n - base) - 1)
+            i = base + j + 1
+            x = v[i0 + i]
+            present = x !== missing
+            pos += present ? length(x) : 0
+            pos <= typemax(O) || throw(_OffsetOverflow(name, 0, i))
+            offsets[i + 1] = pos
+            byte |= UInt8(present) << (j % UInt)
+        end
+        bits[b] = byte
+        valid += count_ones(byte)
+    end
+    nc = n - valid
+    validity =
+        nc == 0 ? AC.BufferSlice() : AC.BufferSlice(AC.heapregion(bits), 0, length(bits))
+    return offsets, validity, nc
+end
+
+# A list or map column read from Arrow keeps its offsets, rebased to start at
+# zero: a null row may span child values, which stay in the child.
+function _listoffsets(
+    name::String,
+    @nospecialize(v::Union{ListVector,MapVector}),
+    ::Type{O},
+    pool=nothing,
+) where {O}
+    n = length(v)
+    offsets = _takevector(pool, O, n + 1)
+    # A read column's offsets may view its batch (Int32 or Int64): kept alive
+    # through `v`.
+    GC.@preserve v _rebaseoffsets!(offsets, v.offsets, name)
+    validity, nc = _storedvalidity(v.validity, v.bitoffset, n, pool)
+    return offsets, validity, nc
+end
+
+function _rebaseoffsets!(offsets::AbstractVector{O}, raw, name::String) where {O}
+    lo = raw[1]
+    @inbounds for i in eachindex(offsets)
+        x = raw[i] - lo
+        x <= typemax(O) || throw(_OffsetOverflow(name, 0, i - 1))
+        offsets[i] = x
+    end
+    return offsets
+end
+
+"""
+The validity of `n` rows a read column stores as `bits` from `bitoffset` (no
+bits: no nulls), as a write buffer, and the null count.
+"""
+function _storedvalidity(bits::Vector{UInt8}, bitoffset::Int, n::Int, pool=nothing)
+    isempty(bits) && return AC.BufferSlice(), 0
+    out = _takevector(pool, UInt8, cld(n, 8))
+    valid = 0
+    @inbounds for b in eachindex(out)
+        byte = 0x00
+        for j = 0:(min(8, n - ((b - 1) << 3)) - 1)
+            byte |= UInt8(_bitset(bits, bitoffset, ((b - 1) << 3) + j + 1)) << j
+        end
+        out[b] = byte
+        valid += count_ones(byte)
+    end
+    nc = n - valid
+    return nc == 0 ? AC.BufferSlice() : AC.BufferSlice(AC.heapregion(out), 0, length(out)),
+    nc
+end
+
+"""
+Elements `lo+1:hi` of a read column's child values without copying them: a
+view, or for a nested child the same storage over those rows.
+"""
+_childslice(v::AbstractVector, lo::Int, hi::Int) =
+    lo == 0 && hi == length(v) ? v : view(v, (lo + 1):hi)
+function _childslice(@nospecialize(v::StructVector), lo::Int, hi::Int)
+    lo == 0 && hi == length(v) && return v
+    return typeof(v)(
+        v.children,
+        v.offset + lo,
+        hi - lo,
+        v.validity,
+        v.bitoffset + lo,
+        v.owner,
+    )
+end
+function _childslice(@nospecialize(v::ListVector), lo::Int, hi::Int)
+    lo == 0 && hi == length(v) && return v
+    return typeof(v)(
+        GC.@preserve(v, v.offsets[(lo + 1):(hi + 1)]),
+        v.values,
+        v.validity,
+        v.bitoffset + lo,
+        v.owner,
+    )
+end
+function _childslice(@nospecialize(v::MapVector), lo::Int, hi::Int)
+    lo == 0 && hi == length(v) && return v
+    offsets = GC.@preserve v v.offsets[(lo + 1):(hi + 1)]
+    return typeof(v)(offsets, v.keys, v.values, v.validity, v.bitoffset + lo, v.owner)
+end
+
+# A row whose length differs from the first pass's would write past its slots.
+_changedrows(name) = ArgumentError("column $name changed while it was being written")
+
+# A list column read from Arrow already holds its rows' values in order, as a
+# child of element type `E`; its values are that child, sliced.
+_storedlist(@nospecialize(v), E) = v isa ListVector && _eltypeof(v.values) === E
+function _storedlistvalues(name::String, @nospecialize(v::ListVector), offsets)
+    lo, hi = GC.@preserve v Int(v.offsets[1]), Int(v.offsets[end])
+    hi - lo == offsets[end] || throw(_changedrows(name))
+    return _childslice(v.values, lo, hi)
+end
+
+"The values of `v`'s rows back to back, as `_listoffsets` counted them."
+function _listvalues(name::String, ::Type{E}, v::AbstractVector, offsets) where {E}
+    _storedlist(v, E) && return _storedlistvalues(name, v, offsets)
+    flat = Vector{E}(undef, Int(offsets[end]))
+    i0 = firstindex(v) - 1
+    @inbounds for i = 1:(length(offsets) - 1)
+        x = v[i0 + i]
+        x === missing && continue
+        lo = Int(offsets[i])
+        m = Int(offsets[i + 1]) - lo
+        length(x) == m || throw(_changedrows(name))
+        copyto!(flat, lo + 1, x, firstindex(x), m)
+    end
+    return flat
+end
+
+# A nested builder's `spec` is a fresh column's name, or the retained Field it
+# rebuilds, whose descriptor, child names, nullability, and metadata it keeps.
+_specname(spec::String) = spec
+_specname(f::AC.Field) = f.name
+_childspec(::String, k::Int, name::String) = name
+_childspec(f::AC.Field, k::Int, ::String) = f.children[k]
+
+# The Field a nested builder returns over its built children.
+_nestedfield(name::String, t, v, children) =
+    AC.Field(name, t; nullable=Missing <: _eltypeof(v), children)
+_nestedfield(f::AC.Field, t, v, children) = _retainedfield(f; children)
+
+# Null rows under a retained field that cannot be null mean the column was
+# replaced.
+_checknulls(::String, nc) = nothing
+_checknulls(f::AC.Field, nc) = nc == 0 || f.nullable || throw(_nonnullableerror(f.name))
+
+# A retained column's rows are of its layout's kind `T`.
+function _checkrows(spec, v, ::Type{T}, what::String) where {T}
+    spec isa AC.Field || return nothing
+    Base.nonmissingtype(_eltypeof(v)) <: T && return nothing
+    for x in v
+        x === missing ||
+            x isa T ||
+            throw(ArgumentError("column $(spec.name) retained rows must be $what"))
+    end
+    return nothing
+end
+
+function _listpart(spec, @nospecialize(v::AbstractVector), context)
+    name = _errname(context, _specname(spec))
+    t = spec isa AC.Field ? spec.type : AC.ListType(_largelists(context))
+    _checkrows(spec, v, AbstractVector, "vectors")
+    offsets, validity, nc = _listoffsets(name, v, t.large ? Int64 : Int32, _pool(context))
+    _checknulls(spec, nc)
+    E = eltype(Base.nonmissingtype(_eltypeof(v)))
+    values =
+        _storedlist(v, E) ? _storedlistvalues(name, v, offsets) :
+        _listvalues(name, E, v, offsets)
+    cf, cd = _constructpart(_childspec(spec, 1, "item"), values; context)
+    # A list view's rows are consecutive spans of its child: starts and sizes.
+    buffers =
+        t isa AC.ListViewType ?
+        [validity, AC._databuffer(offsets[1:(end - 1)]), AC._databuffer(diff(offsets))] :
+        [validity, AC._databuffer(offsets)]
+    d = AC.ArrayData(t, length(v), buffers; children=AC.ArrayData[cd], nullcount=nc)
+    return _nestedfield(spec, t, v, AC.Field[cf]), d
+end
+
+"""
+Child `K` of each row of `rows` (a struct field, a map entry's key or value)
+as a lazy vector of `T`; a missing row reads as missing.
+"""
+struct _ChildValues{T,K,V<:AbstractVector} <: AbstractVector{T}
+    rows::V
+end
+_ChildValues{T,K}(rows::V) where {T,K,V} = _ChildValues{T,K,V}(rows)
+Base.size(c::_ChildValues) = (length(c.rows),)
+Base.@propagate_inbounds function Base.getindex(c::_ChildValues{T,K}, i::Int) where {T,K}
+    x = c.rows[firstindex(c.rows) + i - 1]
+    return (x === missing ? missing : getfield(x, K))::T
+end
+
+# Element `j` of a fixed-size list column's child: value `(j-1) % N + 1` of
+# row `(j-1) ÷ N + 1`.
+struct _TupleValues{T,N,V<:AbstractVector} <: AbstractVector{T}
+    rows::V
+end
+_TupleValues{T,N}(rows::V) where {T,N,V} = _TupleValues{T,N,V}(rows)
+Base.size(c::_TupleValues{T,N}) where {T,N} = (N * length(c.rows),)
+Base.@propagate_inbounds function Base.getindex(c::_TupleValues{T,N}, j::Int) where {T,N}
+    r, k = divrem(j - 1, N)
+    x = c.rows[firstindex(c.rows) + r]
+    return (x === missing ? missing : x[k + 1])::T
+end
+
+"""
+Whether a non-nullable child of type `T` can sit under missing parent rows:
+it is built nullable, with missing in those slots, and `_hidevalidity` then
+drops its validity, so the slots hold placeholders (zeros, empty strings,
+empty lists). That needs a layout with a validity buffer that a nullable
+build of `T` keeps: leaves without an ArrowTypes.jl mapping and the plain
+nested kinds.
+"""
+_hideable(context, T::Type) =
+    T !== Missing &&
+    T !== Union{} &&
+    !(T isa Union) &&
+    (
+        _nestedkind(context, T) !== nothing ||
+        !_writerneedstype!(context, T) ||
+        _hideablestorage(context, T)
+    )
+
+# A mapped type whose declared storage is one concrete type (not Null, not a
+# storage union, not inferred from the values) builds with a validity buffer.
+function _hideablestorage(context, T::Type)
+    T === VersionNumber && return true
+    S = _writerstoragetype!(context, T)
+    S === T && return false
+    S isa Union && return false
+    # Null storage (`Nothing`'s is `Missing`) has no validity to hide.
+    (S === Nothing || S === Missing) && return false
+    isconcretetype(S) || return false
+    return _writerneedstype!(context, S) ? _hideablestorage(context, S) : true
+end
+
+"""
+Data built for `f` declared nullable (or for a nullable fresh child) as `f`
+declares it: where `f` cannot be null, the validity that marked only hidden
+slots is dropped, through a union's children and run-end values too. Hidden
+slots are never read, so they keep whatever placeholder the build wrote.
+"""
+function _hidevalidity(f::AC.Field, built::AC.Field, d::AC.ArrayData)
+    t = d.type
+    fields = collect(AC.Field, built.children)
+    datas = collect(AC.ArrayData, d.children)
+    buffers = collect(AC.BufferSlice, d.buffers)
+    nc = AC.nullcount(d)
+    if t isa Union{AC.UnionType,AC.RunEndEncodedType}
+        for i in (t isa AC.UnionType ? eachindex(datas) : 2:2)
+            fields[i], datas[i] = _hidevalidity(f.children[i], fields[i], datas[i])
+        end
+    elseif !f.nullable && !(t isa AC.NullType)
+        buffers[1] = AC.BufferSlice()
+        nc = 0
+    end
+    field = AC.Field(
+        built.name,
+        built.type;
+        nullable=f.nullable,
+        metadata=_fieldmetadata(built),
+        children=fields,
+    )
+    data = AC.ArrayData(
+        t,
+        d.len,
+        buffers;
+        offset=d.offset,
+        children=datas,
+        dictionary=d.dictionary,
+        owner=d.owner,
+        nullcount=nc,
+    )
+    return field, data
+end
+
+"""
+Whether field `f` holds a null. A Null field with an extension label (such as
+`JuliaLang.Nothing`) holds a value. A union holds nulls in the child
+`_unionnullchild` names, and a run-end column in its values: neither has
+validity of its own.
+"""
+function _holdsnull(f::AC.Field)
+    t = f.type
+    t isa AC.UnionType && return _unionnullchild(f) !== nothing
+    t isa AC.RunEndEncodedType && return _holdsnull(last(f.children))
+    t isa AC.NullType && return _arrowtypesextension(f) === nothing
+    return f.nullable
+end
+
+"""
+The child of union field `f` that takes a missing value, or nothing: a Null
+child without an extension label, else, in a union without a label of its
+own, a child of another type that holds a null. Every child of a labelled
+union holds its storage values.
+"""
+function _unionnullchild(f::AC.Field)
+    k = findfirst(c -> c.type isa AC.NullType && _holdsnull(c), f.children)
+    k === nothing &&
+        _arrowtypesextension(f) === nothing &&
+        (k = findfirst(c -> !(c.type isa AC.NullType) && _holdsnull(c), f.children))
+    return k
+end
+
+# Missing values under a union or Null field that holds no null.
+function _nonullerror(f::AC.Field)
+    f.type isa AC.NullType && return ArgumentError(
+        "column $(f.name) holds missing values, but it writes as Arrow Null labelled " *
+        "$(first(_arrowtypesextension(f))), whose slots read as that label's value",
+    )
+    return ArgumentError(
+        "column $(f.name) holds missing values, but no child of the union it writes " *
+        "as holds a null: a missing value needs a Null child without an extension " *
+        "label or, in a union without a label of its own, a nullable child",
+    )
+end
+
+"""
+Retained child `f` over `values`, `hidden` of which sit under null parent
+rows and read as missing. A child that holds nulls takes them there. In a
+child that cannot, any other missing value means the column was replaced,
+and the hidden slots take a stand-in: a dense union points each at the slot
+of the visible row before it; a sparse union, run-end, or Null column, which
+has no validity buffer, takes the visible value before it; any other child is
+built nullable and its validity then dropped (`_hidevalidity`).
+"""
+function _hiddenchild(f::AC.Field, values, hidden::Int, context)
+    hidden == 0 && return _constructpart(f, values; context)
+    hidden == length(values) && return _constructhiddenpart(f, hidden, context)
+    _holdsnull(f) && return _constructpart(f, values; context)
+    count(ismissing, values) == hidden || throw(_nonnullableerror(f.name))
+    if f.type isa AC.UnionType && f.type.mode == AC.DenseMode
+        return _uninferred(
+            _hiddendenseunion,
+            f,
+            values,
+            context,
+        )::Tuple{AC.Field,AC.ArrayData}
+    end
+    # ponytail: a sparse union still copies a value into each hidden slot
+    # (sparse unions come only from other writers' schemas); a child's empty
+    # value there would cost nothing.
+    if f.type isa Union{AC.UnionType,AC.RunEndEncodedType,AC.NullType}
+        return _constructpart(f, _uninferred(_standins, values)::AbstractVector; context)
+    end
+    relaxed = AC.Field(
+        f.name,
+        f.type;
+        nullable=true,
+        metadata=_fieldmetadata(f),
+        children=collect(AC.Field, f.children),
+    )
+    return _hidevalidity(f, _constructpart(relaxed, values; context)...)
+end
+
+# `values` with each missing value replaced by the value before it (the first
+# value, before any), so a run-end column's hidden slots extend a run.
+function _standins(values)
+    x = values[findfirst(!ismissing, values)]
+    return [y === missing ? x : (x = y) for y in values]
+end
+
+# A dense union over its visible values, whose hidden rows share the slot of
+# the visible row before them (the first one's, before any): no value is
+# copied for them, and each child's offsets stay non-decreasing.
+function _hiddendenseunion(f::AC.Field, values, context)
+    uf, ud = _constructpart(f, [x for x in values if x !== missing]; context)
+    src = max.(cumsum(x !== missing for x in values), 1)
+    ids = reinterpret(Int8, AC.slicebytes(ud.buffers[1]))[src]
+    offsets = reinterpret(Int32, AC.slicebytes(ud.buffers[2]))[src]
+    buffers = AC.BufferSlice[AC._databuffer(ids), AC._databuffer(offsets)]
+    d = AC.ArrayData(ud.type, length(values), buffers; children=ud.children, nullcount=0)
+    return uf, d
+end
+
+_nonnullableerror(name) = ArgumentError(
+    "column $name holds missing values but its retained field is non-nullable",
+)
+
+"""
+Child `spec` of nested rows `v`: `V{T}` over `v` gives its values, `hidden` of
+which sit under null rows and read as missing. A retained child builds as
+`_hiddenchild` says. A fresh child that cannot be null is built nullable and
+its validity dropped when its layout keeps one (`_hideable`), else built under
+the field an empty `T` column writes as, as a retained child is.
+"""
+function _rowchild(V::Type, v, spec, T::Type, hidden::Int, context)
+    hidden == 0 && return _constructpart(spec, V{T}(v); context)
+    spec isa AC.Field && return _hiddenchild(spec, V{Union{Missing,T}}(v), hidden, context)
+    Missing <: T && return _constructpart(spec, V{T}(v); context)
+    if _hideable(context, T)
+        f, d = _constructpart(spec, V{Union{Missing,T}}(v); context)
+        declared = AC.Field(
+            f.name,
+            f.type;
+            nullable=false,
+            metadata=_fieldmetadata(f),
+            children=f.children,
+        )
+        return _hidevalidity(declared, f, d)
+    end
+    f, _ = _constructpart(spec, T[]; context)
+    return _hiddenchild(f, V{Union{Missing,T}}(v), hidden, context)
+end
+
+function _structpart(spec, v::AbstractVector, context)
+    R = Base.nonmissingtype(_eltypeof(v))
+    present = Bool[x !== missing for x in v]
+    nc = count(!, present)
+    _checknulls(spec, nc)
+    # Retained rows are typed NamedTuples with the field's names, or rows
+    # materialized under labels (ordered `Pair` vectors).
+    typed = R <: NamedTuple && isconcretetype(R) || !(spec isa AC.Field)
+    if spec isa AC.Field
+        typed ? _checkrownames(spec, R) : _validateretainedstructrows(spec, v)
+    end
+    fields = AC.Field[]
+    children = AC.ArrayData[]
+    for k = 1:(spec isa AC.Field ? length(spec.children) : fieldcount(R))
+        f, d =
+            typed ?
+            _rowchild(
+                _ChildValues{C,k} where {C},
+                v,
+                _childspec(spec, k, string(fieldname(R, k))),
+                fieldtype(R, k),
+                nc,
+                context,
+            ) : _hiddenchild(spec.children[k], _RowFields(v, k), nc, context)
+        push!(fields, f)
+        push!(children, d)
+    end
+    t = spec isa AC.Field ? spec.type : AC.StructType()
+    d = AC.ArrayData(
+        t,
+        length(v),
+        [nc == 0 ? AC.BufferSlice() : AC._bitmapbuffer(present)];
+        children,
+        nullcount=nc,
+    )
+    return _nestedfield(spec, t, v, fields), d
+end
+
+# A struct column read from Arrow writes its children as stored, slots under
+# null rows included, so no child needs hiding.
+function _structpart(spec, @nospecialize(v::StructVector), context)
+    R = Base.nonmissingtype(_eltypeof(v))
+    spec isa AC.Field && _checkrownames(spec, R)
+    n = length(v)
+    validity, nc = _storedvalidity(v.validity, v.bitoffset, n, _pool(context))
+    _checknulls(spec, nc)
+    fields = AC.Field[]
+    children = AC.ArrayData[]
+    for k = 1:fieldcount(R)
+        child = _childslice(v.children[k], v.offset, v.offset + n)
+        f, d = _constructpart(_childspec(spec, k, string(fieldname(R, k))), child; context)
+        push!(fields, f)
+        push!(children, d)
+    end
+    t = spec isa AC.Field ? spec.type : AC.StructType()
+    d = AC.ArrayData(t, n, [validity]; children, nullcount=nc)
+    return _nestedfield(spec, t, v, fields), d
+end
+
+# A typed struct row's field names must be the retained field's children's.
+function _checkrownames(f::AC.Field, R::Type)
+    names = fieldnames(R)
+    length(names) == length(f.children) &&
+    all(k -> string(names[k]) == f.children[k].name, eachindex(names)) || throw(
+        ArgumentError(
+            "column $(f.name) retained struct row has fields $names; expected " *
+            "$(Tuple(c.name for c in f.children))",
+        ),
+    )
+    return nothing
+end
+
+"""
+A fixed-size list column of `N` values per row: `NTuple`s or vectors. A
+retained one's rows may be `Array`s of its tensor shape.
+"""
+function _fixedlistpart(spec, v::AbstractVector, context, N::Int=0)
+    shape = spec isa AC.Field ? _tensorshape(spec) : nothing
+    shape === nothing || (v = _tensorstorage(v, shape))
+    R = Base.nonmissingtype(_eltypeof(v))
+    t =
+        spec isa AC.Field ? spec.type::AC.FixedSizeListType :
+        AC.FixedSizeListType(N == 0 ? fieldcount(R) : N)
+    N = t.listsize
+    # (Not `R <: NTuple{N,Any}`: that type has N parameters.)
+    if !(R isa DataType && R <: Tuple && !Base.isvatuple(R) && fieldcount(R) == N)
+        _checkrows(spec, v, Union{AbstractVector,Tuple}, "vectors")
+        for x in v
+            x === missing ||
+                length(x) == N ||
+                throw(
+                    ArgumentError(
+                        "column $(_specname(spec)) fixed-size list row has " *
+                        "$(length(x)) values; expected $N",
+                    ),
+                )
+        end
+    end
+    present = Bool[x !== missing for x in v]
+    nc = count(!, present)
+    _checknulls(spec, nc)
+    V = _TupleValues{C,N} where {C}
+    cf, cd = _rowchild(V, v, _childspec(spec, 1, "item"), eltype(R), nc * N, context)
+    d = AC.ArrayData(
+        t,
+        length(v),
+        [nc == 0 ? AC.BufferSlice() : AC._bitmapbuffer(present)];
+        children=AC.ArrayData[cd],
+        nullcount=nc,
+    )
+    return _nestedfield(spec, t, v, AC.Field[cf]), d
+end
+
+_maptypes(::Type{T}) where {T<:AbstractDict} = (keytype(T), valtype(T))
+_maptypes(::Type{T}) where {T<:AbstractVector} =
+    eltype(T) isa DataType && eltype(T) <: Pair ? fieldtypes(eltype(T)) : (Any, Any)
+_maptypes(::Type) = (Any, Any)
+
+"The entries of `v`'s map rows back to back, as `_listoffsets` counted them."
+function _mapentries(name::String, ::Type{P}, v::AbstractVector, offsets) where {P}
+    R = Base.nonmissingtype(_eltypeof(v))
+    R <: AbstractVector && eltype(R) === P && return _listvalues(name, P, v, offsets)
+    entries = Vector{P}(undef, Int(offsets[end]))
+    i0 = firstindex(v) - 1
+    @inbounds for i = 1:(length(offsets) - 1)
+        x = v[i0 + i]
+        x === missing && continue
+        pos = Int(offsets[i])
+        length(x) == Int(offsets[i + 1]) - pos || throw(_changedrows(name))
+        # A dictionary iterates its entries as key => value pairs too.
+        for p in x
+            p isa Pair || throw(ArgumentError("column $name map rows must hold Pairs"))
+            entries[pos += 1] = P(first(p), last(p))
+        end
+    end
+    return entries
+end
+
+# Child `k` (key or value) of a map's entries.
+_entryspec(spec::String, k::Int, name::String) = name
+_entryspec(f::AC.Field, k::Int, ::String) = only(f.children).children[k]
+
+function _mappart(spec, v::AbstractVector, context)
+    name = _errname(context, _specname(spec))
+    _checkrows(spec, v, Union{AbstractVector,AbstractDict}, "Pair vectors or dictionaries")
+    R = Base.nonmissingtype(_eltypeof(v))
+    K, V = _maptypes(R)
+    offsets, validity, nc = _listoffsets(name, v, Int32, _pool(context))
+    _checknulls(spec, nc)
+    entries = _mapentries(name, Pair{K,V}, v, offsets)
+    KK = Base.nonmissingtype(K)
+    Missing <: K &&
+        any(p -> first(p) === missing, entries) &&
+        throw(
+            ArgumentError(
+                "column $name has a missing map key; Arrow map keys cannot be null, " *
+                "so drop those entries or replace the key",
+            ),
+        )
+    kf, kd =
+        _constructpart(_entryspec(spec, 1, "key"), _ChildValues{KK,1}(entries); context)
+    vf, vd =
+        _constructpart(_entryspec(spec, 2, "value"), _ChildValues{V,2}(entries); context)
+    # Distinct keys that an ArrowTypes mapping stores alike would read back as
+    # repeated keys of one row. Keys stored as themselves keep a row's
+    # repeated keys, which Arrow maps (and `Arrow.MapValue` rows) allow.
+    keyspec = _entryspec(spec, 1, "key")
+    (
+        R <: AbstractDict && _writerneedstype!(context, KK) ||
+        keyspec isa AC.Field && _arrowtypesextension(keyspec) !== nothing
+    ) && _validatemapphysicalkeys(name, kf, kd, offsets)
+    return _mapcolumn(spec, v, offsets, validity, nc, length(entries), kf, kd, vf, vd)
+end
+
+# A map column read from Arrow writes its offsets, keys, and values as stored.
+function _mappart(spec, @nospecialize(v::MapVector), context)
+    name = _errname(context, _specname(spec))
+    offsets, validity, nc = _listoffsets(name, v, Int32, _pool(context))
+    _checknulls(spec, nc)
+    lo, hi = GC.@preserve v Int(v.offsets[1]), Int(v.offsets[end])
+    kf, kd =
+        _constructpart(_entryspec(spec, 1, "key"), _childslice(v.keys, lo, hi); context)
+    vf, vd =
+        _constructpart(_entryspec(spec, 2, "value"), _childslice(v.values, lo, hi); context)
+    return _mapcolumn(spec, v, offsets, validity, nc, hi - lo, kf, kd, vf, vd)
+end
+
+function _mapcolumn(spec, @nospecialize(v), offsets, validity, nc, nentries, kf, kd, vf, vd)
+    kf.nullable && throw(
+        ArgumentError(
+            "column $(_specname(spec)) has map keys that write as a nullable Arrow " *
+            "type; Arrow map keys cannot be null",
+        ),
+    )
+    t = spec isa AC.Field ? spec.type::AC.MapType : AC.MapType(false)
+    t.keyssorted && _checksortedkeys(spec, kf, kd, offsets)
+    entriestype = AC.StructType()
+    children = AC.Field[kf, vf]
+    ef =
+        spec isa AC.Field ? _retainedfield(only(spec.children); children) :
+        AC.Field("entries", entriestype; nullable=false, children)
+    ed = AC.ArrayData(
+        entriestype,
+        nentries,
+        [AC.BufferSlice()];
+        children=AC.ArrayData[kd, vd],
+        nullcount=0,
+    )
+    d = AC.ArrayData(
+        t,
+        length(v),
+        [validity, AC._databuffer(offsets)];
+        children=AC.ArrayData[ed],
+        nullcount=nc,
+    )
+    return _nestedfield(spec, t, v, AC.Field[ef]), d
+end
+
+# A retained map that declares sorted keys gets rows sorted by stored key.
+function _checksortedkeys(f::AC.Field, kf::AC.Field, kd::AC.ArrayData, offsets)
+    for row = 1:(length(offsets) - 1)
+        lo = Int(offsets[row]) + 1
+        hi = Int(offsets[row + 1])
+        lo >= hi && continue
+        previous = AC.getvalue(kf, kd, Int64(lo))
+        for index = (lo + 1):hi
+            key = AC.getvalue(kf, kd, Int64(index))
+            _writermapkeyisless(f, key, previous) && throw(
+                ArgumentError(
+                    "column $(f.name) row $row is not sorted by its physical key " *
+                    "storage but its retained Map type declares sorted keys",
+                ),
+            )
+            previous = key
+        end
+    end
+    return nothing
+end
+
+"""
+A retained Union column built from its values (public values, or lowered
+storage values under a label), or nothing when some value fits none of the
+union's children or several. A missing value goes to the child that holds
+nulls (`_unionnullchild`), or is refused. Any other value goes to the child
+its runtime type routes to (`_unionroute`); children of one layout cannot be
+told apart and do not route. Each child then builds from its values as a
+composite's child does, so values that lower to storage (dates, extension
+types) lower there.
+"""
+function _constructfacadeunion(f::AC.Field, v::AbstractVector, context)
+    t = f.type::AC.UnionType
+    children = f.children
+    n = length(v)
+    length(t.typeids) == length(children) && n <= typemax(Int32) || return nothing
+    # Lowered values of a labelled union: member i of the storage Union is
+    # child i, as a fresh write orders the children (a nullable one's outer
+    # Null child among them).
+    S = Base.nonmissingtype(_eltypeof(v))
+    members =
+        !context.lowered || !(S isa Union) ? Type[] :
+        Base.uniontypes(
+            length(children) > length(Base.uniontypes(S)) ? Union{Missing,S} : S,
+        )
+    nullchild = _unionnullchild(f)
+    routes = IdDict{Type,Int}()
+    route = Vector{Int}(undef, n)
+    for (i, x) in enumerate(v)
+        k = if x === missing
+            nullchild === nothing && throw(_nonullerror(f))
+            nullchild
+        else
+            get!(routes, typeof(x)) do
+                _unionroute(children, x, members, context)
+            end
+        end
+        k == 0 && return nothing
+        route[i] = k
+    end
+    sparse = t.mode == AC.SparseMode
+    typeids = Vector{Int8}(undef, n)
+    offsets = sparse ? nothing : Vector{Int32}(undef, n)
+    childvalues = [Any[] for _ in children]
+    for (i, x) in enumerate(v)
+        k = route[i]
+        typeids[i] = t.typeids[k]
+        if sparse
+            # A child's slots of other rows are hidden.
+            for j in eachindex(children)
+                push!(childvalues[j], j == k ? x : missing)
+            end
+        elseif x === missing && !isempty(childvalues[k]) && last(childvalues[k]) === missing
+            # Consecutive missing rows share one null slot.
+            offsets[i] = length(childvalues[k]) - 1
+        else
+            offsets[i] = length(childvalues[k])
+            push!(childvalues[k], x)
+        end
+    end
+    hidden =
+        sparse ? [count(!=(k), route) for k in eachindex(children)] :
+        zeros(Int, length(children))
+    fields = AC.Field[]
+    datas = AC.ArrayData[]
+    for (k, c) in enumerate(children)
+        cf, cd = _hiddenchild(c, childvalues[k], hidden[k], context)
+        push!(fields, cf)
+        push!(datas, cd)
+    end
+    field = AC.Field(
+        f.name,
+        t;
+        nullable=f.nullable,
+        metadata=_fieldmetadata(f),
+        children=fields,
+    )
+    buffers =
+        sparse ? AC.BufferSlice[AC._databuffer(typeids)] :
+        AC.BufferSlice[AC._databuffer(typeids), AC._databuffer(offsets)]
+    return field, AC.ArrayData(t, n, buffers; children=datas, nullcount=0)
+end
+
+"""
+The child of a union that takes value `x`: its storage member's child by
+position when that child has the layout of a fresh column of `x`'s type,
+labels included; else the one child with that layout; else, for a lowered
+value, the one child whose storage domain holds it; else the one child of the
+same layout family (`_samefamily`); else 0.
+"""
+function _unionroute(children, x, members, context)
+    probe = first(_constructpart("probe", typeof(x)[x]; context))
+    i = findfirst(M -> x isa M, members)
+    i !== nothing &&
+        i <= length(children) &&
+        _unionfits(children[i], probe; exact=true) &&
+        return i
+    matches = findall(c -> _unionfits(c, probe; exact=true), children)
+    # A lowered temporal value is its storage integer or DateTime.
+    isempty(matches) &&
+        context.lowered &&
+        (
+            matches = findall(
+                c -> isempty(c.children) && x isa _arrowtypesprimitivebasetype(c),
+                children,
+            )
+        )
+    isempty(matches) &&
+        (matches = findall(c -> _unionfits(c, probe; exact=false), children))
+    return length(matches) == 1 ? only(matches) : 0
+end
+
+# A child takes a value whose fresh field has the child's layout (`exact`), or
+# the same layout at another width (a largelists or stringview source,
+# pyarrow's large_string), or, when the child is a union itself, that one of
+# its children takes. Exact matches are tried first: an int64 child and a
+# timestamp child both store Int64.
+_unionfits(c::AC.Field, probe::AC.Field; exact::Bool) =
+    (exact ? _asretained(c, probe) !== nothing : _samefamily(c, probe)) ||
+    c.type isa AC.UnionType && any(cc -> _unionfits(cc, probe; exact), c.children)
+
+# Fields of one layout family, label for label and child for child: the same
+# type, or utf8 or binary at any width (offsets or views), a list, list view,
+# or fixed-size list at any width, a timestamp without a zone (or Date64) at
+# any unit, a duration or time at any unit, a decimal of one precision and
+# scale at any width.
+function _samefamily(f::AC.Field, built::AC.Field)
+    family = _layoutfamily(f.type)
+    (
+        AC.typeequal(f.type, built.type) ||
+        family !== nothing && family == _layoutfamily(built.type)
+    ) &&
+    (f.nullable || !built.nullable) &&
+    _extensionpairs(f) == _extensionpairs(built) &&
+    length(f.children) == length(built.children) || return false
+    return all(p -> _samefamily(p[1], p[2]), zip(f.children, built.children))
+end
+_layoutfamily(t::AC.ArrowType) =
+    t isa AC.Utf8Type || (t isa AC.ViewType && t.utf8) ? :utf8 :
+    t isa AC.BinaryType || t isa AC.ViewType ? :binary :
+    t isa Union{AC.ListType,AC.ListViewType,AC.FixedSizeListType} ? :list :
+    (t isa AC.DateType && t.unit != AC.DAY) ||
+    (t isa AC.TimestampType && t.timezone === nothing) ? :timestamp :
+    t isa AC.DurationType ? :duration :
+    t isa AC.TimeType ? :time :
+    t isa AC.DecimalType ? (:decimal, t.precision, t.scale) : nothing
+
+"""
+A freshly built field as the retained field `f` declares it, or nothing when
+their layouts differ. Names, nullability, and metadata come from `f`; a fresh
+field may be non-nullable where `f` is nullable.
+"""
+function _asretained(f::AC.Field, built::AC.Field)
+    AC.typeequal(f.type, built.type) &&
+    (f.nullable || !built.nullable) &&
+    _extensionpairs(f) == _extensionpairs(built) &&
+    length(f.children) == length(built.children) || return nothing
+    children = AC.Field[]
+    for (fc, bc) in zip(f.children, built.children)
+        c = _asretained(fc, bc)
+        c === nothing && return nothing
+        push!(children, c)
+    end
+    return AC.Field(
+        f.name,
+        f.type;
+        nullable=f.nullable,
+        metadata=_fieldmetadata(f),
+        children,
+    )
+end
+
+# A field's extension name and metadata: its logical type.
+_extensionpairs(f::AC.Field) =
+    f.metadata === nothing ? Pair{String,String}[] :
+    Pair{String,String}[
+        kv for kv in f.metadata if
+        first(kv) == _EXTENSION_NAME_KEY || first(kv) == _EXTENSION_METADATA_KEY
+    ]
+
+"Walk a bounded writer value graph, with optional short-circuit inspection."
+function _walkwritercontainer!(visit, x, active::Base.IdSet{Any}, depth::Int)
+    x === missing && return false
+    depth < _MAX_WRITER_SCHEMA_DEPTH || throw(
+        ArgumentError(
+            "ArrowTypes value nesting exceeds the supported depth " *
+            "$_MAX_WRITER_SCHEMA_DEPTH",
+        ),
+    )
+    visit(x) && return true
+    if x isa NamedTuple || x isa Tuple
+        for value in x
+            _walkwritercontainer!(visit, value, active, depth + 1) === true && return true
+        end
+    elseif x isa Pair
+        _walkwritercontainer!(visit, first(x), active, depth + 1) === true && return true
+        _walkwritercontainer!(visit, last(x), active, depth + 1) === true && return true
+    elseif x isa AbstractVector || x isa AbstractDict
+        x in active &&
+            throw(ArgumentError("recursive ArrowTypes value container cannot be written"))
+        push!(active, x)
+        try
+            if x isa AbstractDict
+                for (key, value) in x
+                    _walkwritercontainer!(visit, key, active, depth + 1) === true &&
+                        return true
+                    _walkwritercontainer!(visit, value, active, depth + 1) === true &&
+                        return true
+                end
+            else
+                for value in x
+                    _walkwritercontainer!(visit, value, active, depth + 1) === true &&
+                        return true
+                end
+            end
+        finally
+            delete!(active, x)
+        end
+    end
+    return false
+end
+
+"Reject recursive or excessively deep value-container graphs before narrowing."
+function _preflightwritercontainers(v::AbstractVector)
+    active = Base.IdSet{Any}()
+    for value in v
+        _walkwritercontainer!(_ -> false, value, active, 0)
+    end
+    return nothing
+end
+
+# An abstract element type no native builder writes as one column (`Real`,
+# `Any`): such values are written as a dense Union of their runtime types.
+_abstractnonnative(T) =
+    T !== Union{} &&
+    !isconcretetype(T) &&
+    !(T isa Union) &&
+    !(T <: Union{AbstractString,AbstractVector,NamedTuple}) &&
+    !_singletypefamily(T)
+
+# Families one Arrow column holds at a single concrete type (one resolution,
+# zone, or precision): their abstract columns narrow only when every value
+# has the same type, and refuse otherwise.
+_singletypefamily(T) =
+    T <: Union{Durations.Timestamp,Durations.ZonedTimestamp,DataDecimals.Decimal}
+
+"The Union of the runtime types of column `name`'s values, `Missing` included."
+function _observedtype(v::AbstractVector, name="")
+    types = Type[]
+    seen = Base.IdSet{Type}()
+    hasmissing = false
+    for x in v
+        if x === missing
+            hasmissing = true
+            continue
+        end
+        _pushobserved!(types, seen, typeof(x), name)
+    end
+    U = _writeruniontype(types)
+    return hasmissing ? Union{Missing,U} : U
+end
+
+"Narrow an Any-eltype column, recovering list-of-T structure when present."
+function _narrowlists(v::AbstractVector, name="")
+    # Narrowing can turn an Any column into a concrete list type before the
+    # ArrowTypes value walk runs. Reject cycles and excessive nesting first,
+    # without resolving any user traits.
+    _preflightwritercontainers(v)
+    # map(identity, …) re-infers a narrowed element type from the values:
+    # inner maps narrow each row, the outer map narrows the column.
+    w = map(x -> x isa AbstractVector ? map(identity, x) : x, v)
+    w = map(identity, w)
+    NT = Base.nonmissingtype(_eltypeof(w))
+    _abstractnonnative(NT) && return _collectas(_observedtype(w, name), w)
+    NT !== Union{} && NT <: AbstractVector || return w
+    # Join the inner element types (empties narrow to Union{} and would
+    # otherwise poison the join), then retype every inner vector. With only
+    # empty rows, their declared element types are all there is.
+    E = Union{}
+    for x in w
+        x === missing && continue
+        isempty(x) && continue
+        E = typejoin(E, eltype(x))
+    end
+    if E === Union{}
+        for x in w
+            x === missing || (E = typejoin(E, eltype(x)))
+        end
+    end
+    E === Union{} && (E = Any)
+    # Rows of different element types: the elements' runtime types.
+    if _abstractnonnative(E)
+        values = collect(Iterators.flatten(x for x in w if x !== missing))
+        isempty(values) || (E = _observedtype(values, name))
+    end
+    E === Any && return w
+    hasm = _eltypeof(w) >: Missing
+    S = hasm ? Union{Missing,Vector{E}} : Vector{E}
+    return S[x === missing ? missing : convert(Vector{E}, x) for x in w]
+end
+
+# A column read as a view over decoded Arrow buffers (one record batch's
+# `ArrayData`) writes those buffers as they are when the writer would declare
+# the same type for the column's element type: no value is converted.
+function _constructpart(
+    name::String,
+    v::Union{Primitive,BoolVector};
+    context=nothing,
+    narrowabstract::Bool=true,
+)
+    d = v.owner
+    # Fixed-size binary rows (`NTuple{N,UInt8}`) and 128-bit integers (stored
+    # as fixed-size binary) have no native construction; the general path
+    # writes them.
+    if d isa AC.ArrayData &&
+       d.offset == 0 &&
+       d.len == length(v) &&
+       !(Base.nonmissingtype(_eltypeof(v)) <: Union{Tuple,Int128,UInt128})
+        f, _ = _constructnativepart(name, _eltypeof(v)[]; context)
+        AC.typeequal(f.type, d.type) && return f, _viewbuffers(d)
+    end
+    return invoke(
+        _constructpart,
+        Tuple{String,AbstractVector},
+        name,
+        v;
+        context,
+        narrowabstract,
+    )
+end
+
+# A fixed-width or Bool batch's buffers cut to its length, so no byte past the
+# last value (padding of the source) is written.
+function _viewbuffers(d::AC.ArrayData)
+    n = d.len
+    databytes = d.type isa AC.BoolType ? cld(n, 8) : n * AC.primwidth(d.type)
+    data = AC.subslice(AC.rolebuffer(d, AC.DATA), 0, databytes)
+    nc = AC.nullcount(d)
+    validity = nc == 0 ? AC.BufferSlice() : AC.subslice(AC.validitybuffer(d), 0, cld(n, 8))
+    return AC.ArrayData(d.type, n, [validity, data]; nullcount=nc)
+end
+
+const _PayloadColumn = Union{DataStrings.StringVector,DataStrings.BytesVector}
+# A record batch's rows of a DataStrings column.
+const _PayloadRows = SubArray{<:Any,1,<:_PayloadColumn,<:Tuple{UnitRange{Int}}}
+_payloadparent(v::_PayloadColumn) = v
+_payloadparent(v::_PayloadRows) = parent(v)
+_payloadentries(v::_PayloadColumn) = v.payloads
+_payloadentries(v::_PayloadRows) = view(parent(v).payloads, only(parentindices(v)))
+
+# A DataStrings column IS Utf8View (BinaryView) memory: its payload vector is
+# the views buffer and its byte buffers are the variadic data buffers. With
+# `stringview=true` it is written as is, without a copy (a row range copies
+# its view entries); otherwise its bytes are packed into utf8 (binary)
+# offsets and data in one pass over the payloads. Nullability comes from the
+# column's eltype. Both keywords are accepted for dispatch uniformity; no
+# narrowing applies.
+function _constructpart(
+    name::String,
+    v::Union{_PayloadColumn,_PayloadRows};
+    context=nothing,
+    narrowabstract::Bool=true,
+)
+    p = _payloadparent(v)
+    utf8 = p isa DataStrings.StringVector
+    nullable = Missing <: _eltypeof(v)
+    if _stringview(context)
+        # View entries are the payloads themselves, so a row range copies them.
+        payloads = v isa _PayloadRows ? collect(_payloadentries(v)) : p.payloads
+        # DataStrings keeps a private append arena, which may be empty.
+        lastbuffer = something(findlast(!isempty, p.buffers), 0)
+        f, d = AC.fromviewentries(name, payloads, p.buffers[1:lastbuffer]; nullable)
+        utf8 && return f, d
+        t = AC.ViewType(false)
+        return AC.Field(name, t; nullable),
+        AC.ArrayData(t, d.len, d.buffers; nullcount=AC.nullcount(d))
+    end
+    large = _largelists(context)
+    t = utf8 ? AC.Utf8Type(large) : AC.BinaryType(large)
+    return _packedpayloadpart(
+        name,
+        _payloadentries(v),
+        p.buffers,
+        t,
+        large ? Int64 : Int32,
+        nullable,
+        _pool(context),
+    )
+end
+
+"""
+utf8/binary offsets and data from DataStrings payloads. One pass measures the
+values and copies them while every value so far is inline; a batch with an
+out-of-line value is a slice of that value's buffer when every value's bytes
+sit there in row order (as a read of utf8 data stores them), else one copy.
+"""
+function _packedpayloadpart(
+    name::String,
+    payloads,
+    buffers,
+    t::AC.ArrowType,
+    ::Type{Offset},
+    nullable::Bool,
+    pool=nothing,
+) where {Offset}
+    n = length(payloads)
+    offsets = _takevector(pool, Offset, n + 1)
+    offsets[1] = 0
+    bits = _takevector(pool, UInt8, cld(n, 8))
+    # Inline values are at most 12 bytes, so this holds every value until the
+    # first out-of-line one; a batch that starts out of line goes without.
+    firstlong =
+        n > 0 && DataStrings.payloadlength(@inbounds payloads[1]) > DataStrings.INLINE_MAX
+    inline = _takevector(pool, UInt8, firstlong ? 16 : 12n + 16)
+    # From the first out-of-line value on, the bytes are a slice of its buffer
+    # (`runbuf`, from `runstart`) when every out-of-line value sits there at
+    # its row's position and every inline value matches the bytes there, as in
+    # a column read from Arrow. This pass checks the values after the first
+    # out-of-line one; the ones copied to `inline` before it are compared once
+    # after.
+    runbuf = 0
+    runstart = 0
+    runok = true
+    prefix = 0
+    run = Ptr{UInt8}(0)
+    room = 0
+    mismatch = UInt64(0)
+    pos = 0
+    valid = 0
+    GC.@preserve payloads inline buffers begin
+        words = Ptr{UInt64}(pointer(payloads))
+        out = pointer(inline)
+        @inbounds for b in eachindex(bits)
+            base = (b - 1) << 3
+            byte = 0x00
+            for j = 0:(min(8, n - base) - 1)
+                i = base + j + 1
+                a = unsafe_load(words, 2i - 1)
+                w = unsafe_load(words, 2i)
+                len = Int(reinterpret(Int32, a % UInt32))
+                present = len >= 0
+                long = len > DataStrings.INLINE_MAX
+                # The payload's last 12 bytes, an inline value's bytes, as words.
+                lo = (a >> 32) | (w << 32)
+                hi = (w >> 32) % UInt32
+                if runbuf == 0
+                    if long
+                        runbuf = Int(reinterpret(Int32, w % UInt32)) + 1
+                        runstart = Int(reinterpret(Int32, (w >> 32) % UInt32)) - pos
+                        prefix = pos
+                        if 1 <= runbuf <= length(buffers) && runstart >= 0
+                            run = pointer(buffers[runbuf]) + runstart
+                            room = length(buffers[runbuf]) - runstart
+                        else
+                            runok = false
+                        end
+                    else
+                        unsafe_store!(Ptr{UInt64}(out + pos), lo)
+                        unsafe_store!(Ptr{UInt32}(out + pos + 8), hi)
+                    end
+                else
+                    k = Int(reinterpret(Int32, w % UInt32)) + 1
+                    at = Int(reinterpret(Int32, (w >> 32) % UInt32)) - pos
+                    # Without branches: the values are a random mix of kinds.
+                    runok &= !long | ((k == runbuf) & (at == runstart))
+                    if pos + 12 <= room
+                        m = clamp(len, 0, DataStrings.INLINE_MAX) + 1
+                        lomask = _INLINELOMASKS[m]
+                        himask = _INLINEHIMASKS[m]
+                        diff =
+                            ((unsafe_load(Ptr{UInt64}(run + pos)) ⊻ lo) & lomask) |
+                            ((unsafe_load(Ptr{UInt32}(run + pos + 8)) ⊻ hi) & himask)
+                        mismatch |= ifelse(long, UInt64(0), diff)
+                    elseif !long & (len > 0)
+                        # Within 12 bytes of the buffer's end: byte by byte.
+                        entry = Ptr{UInt8}(words) + 16 * (i - 1) + 4
+                        runok &= pos + len <= room && _memequal(run + pos, entry, len)
+                    end
+                end
+                pos += ifelse(present, len, 0)
+                pos <= typemax(Offset) || throw(_OffsetOverflow(name, 0, i))
+                offsets[i + 1] = pos % Offset
+                byte |= UInt8(present) << (j % UInt)
+            end
+            bits[b] = byte
+            valid += count_ones(byte)
+        end
+        runok &= (runbuf != 0) & (mismatch == 0) & (pos <= room)
+        runok && (runok = _memequal(pointer(inline), run, prefix))
+    end
+    nc = n - valid
+    validity =
+        nc == 0 ? AC.BufferSlice() : AC.BufferSlice(AC.heapregion(bits), 0, length(bits))
+    if runbuf == 0
+        # The bytes are a slice: the vector keeps its length, which a reused
+        # vector's pool reads as its capacity.
+        databuf =
+            pos == 0 ? AC.BufferSlice() : AC.BufferSlice(AC.heapregion(inline), 0, pos)
+        d = AC.ArrayData(t, n, [validity, AC._databuffer(offsets), databuf]; nullcount=nc)
+        return AC.Field(name, t; nullable), _constructedvalid(d)
+    end
+    if runok
+        databuf = AC.BufferSlice(AC.heapregion(buffers[runbuf]), runstart, pos)
+        d = AC.ArrayData(t, n, [validity, AC._databuffer(offsets), databuf]; nullcount=nc)
+        return AC.Field(name, t; nullable), _constructedvalid(d)
+    end
+    data = _takevector(pool, UInt8, pos + 32)
+    GC.@preserve payloads buffers data begin
+        out = pointer(data)
+        words = Ptr{UInt64}(pointer(payloads))
+        @inbounds for i = 1:n
+            a = unsafe_load(words, 2i - 1)
+            w = unsafe_load(words, 2i)
+            len = Int(reinterpret(Int32, a % UInt32))
+            len <= 0 && continue
+            if len <= DataStrings.INLINE_MAX
+                # The inline bytes are the payload's last 12; `data` keeps 32
+                # bytes of slack, so whole words are stored.
+                unsafe_store!(Ptr{UInt64}(out), (a >> 32) | (w << 32))
+                unsafe_store!(Ptr{UInt32}(out + 8), (w >> 32) % UInt32)
+            else
+                buf = buffers[reinterpret(Int32, w % UInt32) + 1]
+                off = Int(reinterpret(Int32, (w >> 32) % UInt32))
+                src = pointer(buf) + off
+                if len <= 32 && off + 32 <= length(buf)
+                    for k = 0:8:24
+                        unsafe_store!(
+                            Ptr{UInt64}(out + k),
+                            unsafe_load(Ptr{UInt64}(src + k)),
+                        )
+                    end
+                else
+                    unsafe_copyto!(out, src, len)
+                end
+            end
+            out += len
+        end
+    end
+    databuf = pos == 0 ? AC.BufferSlice() : AC.BufferSlice(AC.heapregion(data), 0, pos)
+    d = AC.ArrayData(t, n, [validity, AC._databuffer(offsets), databuf]; nullcount=nc)
+    return AC.Field(name, t; nullable), _constructedvalid(d)
+end
+
+# The masks of an inline value's first `len` bytes (0 to 12) in the two words
+# `_packedpayloadpart` compares it as, at index `len + 1`.
+const _INLINELOMASKS = ntuple(k -> (UInt64(1) << (8 * min(k - 1, 8))) - UInt64(1), 13)
+const _INLINEHIMASKS = ntuple(k -> (UInt32(1) << (8 * clamp(k - 9, 0, 4))) - UInt32(1), 13)
+
+_memequal(p::Ptr{UInt8}, q::Ptr{UInt8}, n::Int) =
+    ccall(:memcmp, Cint, (Ptr{UInt8}, Ptr{UInt8}, Csize_t), p, q, n) == 0
+
+_stringview(context) = context !== nothing && context.stringview
+_pool(context) = context === nothing ? nothing : context.pool
+_largelists(context) = context !== nothing && context.largelists
+
+"""
+A 32-bit-offset column's data passes the Int32 range at `row` (0 when the row
+is not known, as in nested data) of partition `part` (0 until the partition
+loop records it). The writer cuts its record batches smaller and retries.
+"""
+struct _OffsetOverflow <: Exception
+    column::String
+    part::Int
+    row::Int
+end
+Base.showerror(io::IO, e::_OffsetOverflow) =
+    print(io, "column $(e.column) exceeds the Int32 offset range of one record batch")
+
+"""
+A string of `column` (a child as "a (child b.c)") is not valid UTF-8, at `row`
+(0 when no row refers to it) of part `part` of the values being built. The
+batch and partition loops report it as an `ArgumentError` naming the row of
+the table being written.
+"""
+struct _InvalidUTF8 <: Exception
+    column::String
+    part::Int
+    row::Int
+end
+Base.showerror(io::IO, e::_InvalidUTF8) = print(io, _invalidutf8message(e.column, e.row, 0))
+
+function _invalidutf8message(column::String, row::Int, partition::Int)
+    at = row == 0 ? "" : partition == 0 ? " row $row" : " row $row of partition $partition"
+    return "column $column$at holds a string that is not valid UTF-8; Arrow strings " *
+           "must be UTF-8 (Polars and DuckDB refuse files with others), so write " *
+           "binary data as a Vector{UInt8} column"
+end
+
+"Throw `_InvalidUTF8` for the first string of a built column that is not UTF-8."
+function _checkutf8(name::Symbol, f::AC.Field, d::AC.ArrayData)
+    bad = _badutf8(f, d)
+    bad === nothing && return nothing
+    row, path = bad
+    column = isempty(path) ? String(name) : "$name (child $path)"
+    throw(_InvalidUTF8(column, 1, row))
+end
+
+"""
+The first row of `d` holding a string, at any depth, that is not valid UTF-8,
+and the path of child names to it, or nothing. Every non-null string slot is
+checked, as Arrow's full validation does; row 0 means no row refers to the
+slot (a dictionary value no row uses, say).
+"""
+function _badutf8(f::AC.Field, d::AC.ArrayData)
+    t = d.type
+    if t isa AC.Utf8Type
+        i = _badutf8offsets(d, t.large ? Int64 : Int32)
+        return i == 0 ? nothing : (i, "")
+    elseif t isa AC.ViewType
+        t.utf8 || return nothing
+        i = _badutf8views(d)
+        return i == 0 ? nothing : (i, "")
+    elseif t isa AC.DictionaryType
+        pool = d.dictionary
+        pool === nothing && return nothing
+        bad = _badutf8(AC.dictvaluefield(f, t), pool)
+        bad === nothing && return nothing
+        return (bad[1] == 0 ? 0 : _dictrow(d, t, bad[1]), bad[2])
+    end
+    for (j, (cf, cd)) in enumerate(zip(f.children, d.children))
+        bad = _badutf8(cf, cd)
+        bad === nothing && continue
+        path = isempty(bad[2]) ? cf.name : cf.name * "." * bad[2]
+        return (bad[1] == 0 ? 0 : _parentrow(d, j, bad[1]), path)
+    end
+    return nothing
+end
+
+function _isascii(bytes::Vector{UInt8})
+    acc = UInt64(0)
+    words = length(bytes) >> 3
+    GC.@preserve bytes begin
+        p = Ptr{UInt64}(pointer(bytes))
+        for i = 1:words
+            acc |= unsafe_load(p, i)
+        end
+    end
+    for i = (8words + 1):length(bytes)
+        acc |= @inbounds bytes[i]
+    end
+    return iszero(acc & 0x8080808080808080)
+end
+
+# A utf8 column's first non-null row that is not UTF-8, or 0. ASCII data, or
+# data valid as a whole whose rows all start on a character, is valid; only
+# other data is checked row by row. `T` is the offset type.
+function _badutf8offsets(d::AC.ArrayData, ::Type{T}) where {T}
+    n = Int(d.len)
+    n == 0 && return 0
+    offs = AC.rolebuffer(d, AC.OFFSETS)
+    data = AC.rolebuffer(d, AC.DATA)
+    (d.offset + n + 1) * sizeof(T) <= offs.len || return 0
+    GC.@preserve offs data begin
+        op = Ptr{T}(AC.sliceptr(offs)) + d.offset * sizeof(T)
+        lo = Int(unsafe_load(op, 1))
+        hi = Int(unsafe_load(op, n + 1))
+        0 <= lo < hi <= data.len || return 0
+        bytes = unsafe_wrap(Array, AC.sliceptr(data) + lo, hi - lo)
+        _isascii(bytes) && return 0
+        if isvalid(String, bytes)
+            # A row starts on a character unless its first byte continues one;
+            # a row at the end (empty) starts anywhere.
+            starts = true
+            m = length(bytes)
+            for i = 2:n
+                o = Int(unsafe_load(op, i)) - lo
+                lead = @inbounds bytes[clamp(o + 1, 1, m)]
+                starts &= (o >= m) | (lead & 0xc0 != 0x80)
+            end
+            starts && return 0
+        end
+        for i = 1:n
+            AC.isvalid_at(d, i) || continue
+            a = Int(unsafe_load(op, i)) - lo
+            b = Int(unsafe_load(op, i + 1)) - lo
+            isvalid(String, view(bytes, (a + 1):b)) || return i
+        end
+    end
+    return 0
+end
+
+# A utf8_view column's first non-null row that is not UTF-8, or 0.
+function _badutf8views(d::AC.ArrayData)
+    n = Int(d.len)
+    views = AC.rolebuffer(d, AC.VIEWS)
+    16 * (d.offset + n) <= views.len || return 0
+    GC.@preserve d begin
+        entries = unsafe_wrap(Array, AC.sliceptr(views), views.len)
+        buffers = Vector{UInt8}[
+            unsafe_wrap(Array, AC.sliceptr(b), b.len) for b in @view(d.buffers[3:end])
+        ]
+        longascii = all(_isascii, buffers)
+        for i = 1:n
+            AC.isvalid_at(d, i) || continue
+            base = 16 * (d.offset + i - 1)
+            len = Int(unsafe_load(Ptr{Int32}(pointer(entries, base + 1))))
+            bytes = if len <= AC.VIEW_INLINE_MAX
+                view(entries, (base + 5):(base + 4 + len))
+            else
+                longascii && continue
+                k = Int(unsafe_load(Ptr{Int32}(pointer(entries, base + 9))))
+                at = Int(unsafe_load(Ptr{Int32}(pointer(entries, base + 13))))
+                view(buffers[k + 1], (at + 1):(at + len))
+            end
+            isvalid(String, bytes) || return i
+        end
+    end
+    return 0
+end
+
+# The first row of a dictionary column whose index refers to pool value `k`.
+function _dictrow(d::AC.ArrayData, t::AC.DictionaryType, k::Int)
+    w = AC.primwidth(t.indextype)
+    indices = AC.rolebuffer(d, AC.DATA)
+    for i = 1:Int(d.len)
+        AC.isvalid_at(d, i) || continue
+        AC._load_int(indices, t.indextype, AC._slotbyteoff(d, Int64(i), w)) + 1 == k &&
+            return i
+    end
+    return 0
+end
+
+# The first row of `d` whose values include element `k` of its child `j`.
+function _parentrow(d::AC.ArrayData, j::Int, k::Int)
+    t = d.type
+    for i = 1:Int(d.len)
+        k in _childspan(t, d, j, Int64(i)) && return i
+    end
+    return 0
+end
+
+function _childspan(t::AC.ArrowType, d::AC.ArrayData, j::Int, i::Int64)
+    if t isa Union{AC.ListType,AC.MapType}
+        lo, hi = AC._offsets_at(d, i, t isa AC.ListType && t.large)
+        return (lo + 1):hi
+    elseif t isa AC.ListViewType
+        off, sz = AC._listview_range(t, d, i)
+        return (off + 1):(off + sz)
+    elseif t isa AC.FixedSizeListType
+        base = AC._slotindex0(d, i) * t.listsize
+        return (base + 1):(base + t.listsize)
+    elseif t isa AC.StructType
+        return (d.offset + i):(d.offset + i)
+    elseif t isa AC.UnionType
+        tid = AC.loadat(AC.rolebuffer(d, AC.TYPE_IDS), Int8, AC._slotindex0(d, i))
+        tid == t.typeids[j] || return 1:0
+        t.mode == AC.SparseMode && return (d.offset + i):(d.offset + i)
+        at =
+            AC.loadat(AC.rolebuffer(d, AC.ELEMENT_OFFSETS), Int32, AC._slotbyteoff(d, i, 4))
+        return (at + 1):(at + 1)
+    elseif t isa AC.RunEndEncodedType
+        j == 2 || return 1:0
+        r = AC._ree_runindex(d, i)
+        return r:r
+    end
+    return 1:0
+end
+
+# Duration seconds and year-month interval months of the larger Dates periods.
+_periodseconds(x::Dates.Week) = Base.checked_mul(Dates.value(x), Int64(604_800))
+_periodseconds(x::Dates.Day) = Base.checked_mul(Dates.value(x), Int64(86_400))
+_periodseconds(x::Dates.Hour) = Base.checked_mul(Dates.value(x), Int64(3_600))
+_periodseconds(x::Dates.Minute) = Base.checked_mul(Dates.value(x), Int64(60))
+_periodmonths(x::Dates.Month) = Dates.value(x)
+_periodmonths(x::Dates.Year) = Base.checked_mul(Dates.value(x), Int64(12))
+
+_nbytes(x::AbstractString) = ncodeunits(x)
+_nbytes(x::AbstractVector{UInt8}) = length(x)
+function _copybytes!(
+    data::Vector{UInt8},
+    pos::Int,
+    x::Union{String,SubString{String}},
+    n::Int,
+)
+    GC.@preserve data x unsafe_copyto!(pointer(data, pos + 1), pointer(x), n)
+    return nothing
+end
+# A DataStrings value's bytes are inline in its 16-byte payload (after the
+# 4-byte length) or at `payloadpos` in its buffer.
+_copybytes!(data::Vector{UInt8}, pos::Int, x::DataStrings.DataString, n::Int) =
+    _copypayloadbytes!(data, pos, x, n)
+_copybytes!(data::Vector{UInt8}, pos::Int, x::DataStrings.DataBytes, n::Int) =
+    _copypayloadbytes!(data, pos, x, n)
+function _copypayloadbytes!(data::Vector{UInt8}, pos::Int, x, n::Int)
+    if n <= DataStrings.INLINE_MAX
+        r = Ref(x.p)
+        GC.@preserve r data begin
+            src = Ptr{UInt8}(Base.unsafe_convert(Ptr{DataStrings.StringPayload}, r)) + 4
+            unsafe_copyto!(pointer(data, pos + 1), src, n)
+        end
+    else
+        GC.@preserve x data begin
+            src = pointer(x.data, DataStrings.payloadpos(x.p))
+            unsafe_copyto!(pointer(data, pos + 1), src, n)
+        end
+    end
+    return nothing
+end
+_copybytes!(data::Vector{UInt8}, pos::Int, x::AbstractVector{UInt8}, n::Int) =
+    (copyto!(data, pos + 1, x, firstindex(x), n); nothing)
+function _copybytes!(data::Vector{UInt8}, pos::Int, x::AbstractString, n::Int)
+    for (j, b) in enumerate(codeunits(x))
+        @inbounds data[pos + j] = b
+    end
+    return nothing
+end
+
+"""
+A utf8 or binary column (`t`). One pass measures the values (offsets,
+validity, and the offset-range check), a second copies their bytes into a
+data buffer of the exact size.
+"""
+function _varbytespart(name::String, v::AbstractVector, t::AC.ArrowType)
+    Offset = t.large ? Int64 : Int32
+    return _varbytespart(name, v, t, Offset)
+end
+function _varbytespart(name::String, v::AbstractVector, t, ::Type{Offset}) where {Offset}
+    n = length(v)
+    i0 = firstindex(v) - 1
+    offsets = Vector{Offset}(undef, n + 1)
+    offsets[1] = 0
+    bits = zeros(UInt8, cld(n, 8))
+    pos = 0
+    nc = 0
+    @inbounds for i = 1:n
+        x = v[i0 + i]
+        if x === missing
+            nc += 1
+        else
+            m = _nbytes(x)::Int
+            pos <= typemax(Offset) - m || throw(_OffsetOverflow(name, 0, i))
+            pos += m
+            bits[((i - 1) >> 3) + 1] |= UInt8(1) << ((i - 1) & 7)
+        end
+        offsets[i + 1] = pos
+    end
+    data = Vector{UInt8}(undef, pos)
+    @inbounds for i = 1:n
+        x = v[i0 + i]
+        start = Int(offsets[i])
+        m = Int(offsets[i + 1]) - start
+        # Every data byte is written exactly once, even if a lazy column
+        # yields different values on the second pass.
+        (x === missing ? m == 0 : _nbytes(x) == m) ||
+            throw(ArgumentError("column $name changed while it was being written"))
+        x === missing || _copybytes!(data, start, x, m)
+    end
+    validity =
+        nc == 0 ? AC.BufferSlice() : AC.BufferSlice(AC.heapregion(bits), 0, length(bits))
+    databuf = pos == 0 ? AC.BufferSlice() : AC._databuffer(data)
+    d = AC.ArrayData(t, n, [validity, AC._databuffer(offsets), databuf]; nullcount=nc)
+    return AC.Field(name, t; nullable=Missing <: _eltypeof(v)), _constructedvalid(d)
+end
+
+# Offsets built here never decrease and end at the data length, and the null
+# count is exact: the data passes Core's semantic checks by construction.
+function _constructedvalid(d::AC.ArrayData)
+    @atomic :monotonic d.semachecked = true
+    return d
+end
+
+"Concrete Vector with an exact Union{Missing,T} or T eltype for fromjulia."
+function _plainvector(v::AbstractVector)
+    T = _eltypeof(v)
+    return v isa Vector{T} ? v : _collectas(T, v)
+end
+
+# `eltype` of a vector the caller does not specialize on: Base's `eltype` of an
+# abstract vector type has methods other packages add to (DataFrames does).
+_eltypeof(::AbstractVector{T}) where {T} = T
+
+# A string's UTF-8 bytes. `codeunits` of an `AbstractString` has methods other
+# packages add to (LaTeXStrings does); the bytes of a `String` do not.
+_utf8units(x::AbstractString) = codeunits((x isa String ? x : String(x))::String)
+
+# `collect(T, v)` for an element type known only at run time. Other packages
+# add `collect(::Type{...}, v)` methods (InlineStrings does), and writer code
+# inferred against Base's one method would recompile once they load.
+_collectas(::Type{T}, v::AbstractVector) where {T} = copyto!(Vector{T}(undef, length(v)), v)
+
+_missings_to(::Type{S}, v) where {S} =
+    _eltypeof(v) >: Missing ? Union{Missing,S}[x === missing ? missing : S(x) for x in v] :
+    S[S(x) for x in v]
+
+"Construct temporal ArrayData from nullable Int64 storage values."
+function _temporaldata(t::AC.ArrowType, storage::AbstractVector)
+    _, d0 = _uninferred(AC.fromjulia, "storage", storage)::Tuple{AC.Field,AC.ArrayData}
+    # Narrow to Int32 for any 32-bit temporal descriptor (Date32 fresh,
+    # Time32 retained); every other temporal layout keeps the inferred Int64
+    # buffer.
+    buffers = d0.buffers
+    if AC.primwidth(t) == 4
+        narrow = Vector{Int32}(undef, length(storage)::Int)
+        for (i, x) in enumerate(storage)
+            narrow[i] = x === missing ? Int32(0) : Int32(x)
+        end
+        buffers = AC.BufferSlice[d0.buffers[1], AC._databuffer(narrow)]
+    end
+    return AC._arraydata(
+        t,
+        d0.len,
+        buffers,
+        0,
+        AC.ArrayData[],
+        nothing,
+        d0.owner,
+        AC.nullcount(d0),
+    )
+end
+
+"Construct one fresh temporal part and preserve its validity."
+function _constructtemporalpart(
+    name::String,
+    v::AbstractVector,
+    t::AC.ArrowType,
+    tostorage::F,
+) where {F}
+    S = AC.primwidth(t) == 4 ? Int32 : Int64
+    vals, validity, nc = _nullablevalues(S, v, zero(S), x -> S(tostorage(x)))
+    d = AC.ArrayData(t, length(v), [validity, AC._databuffer(vals)]; nullcount=nc)
+    return AC.Field(name, t; nullable=_eltypeof(v) >: Missing), d
+end
+
+# ArrowTypes write adapter. ArrowCore intentionally stays conversion-free;
+# this layer lowers logical Julia values before it asks Core to build buffers.
+
+"Stable metadata merge; `extra` wins except for protected extension labels."
+function _mergemetapairs(base, extra; protectextension::Bool=false)
+    out = Pair{String,String}[]
+    base === nothing ||
+        append!(out, String(first(kv))::String => String(last(kv))::String for kv in base)
+    extra === nothing && return isempty(out) ? nothing : out
+    for kv in extra
+        key = String(first(kv))::String
+        value = String(last(kv))::String
+        i = findfirst(p -> first(p) == key, out)
+        if protectextension &&
+           (key == _EXTENSION_NAME_KEY || key == _EXTENSION_METADATA_KEY) &&
+           i !== nothing
+            continue
+        end
+        if i === nothing
+            push!(out, key => value)
+        else
+            out[i] = key => value
+        end
+    end
+    return isempty(out) ? nothing : out
+end
+
+"Attach this logical type's extension label without disturbing child labels."
+function _arrowtypeslogicalfield(context, f::AC.Field, T; nullable::Bool=f.nullable)
+    extension = _writerextension!(context, T)
+    extension === nothing && return f
+    metadata = _mergemetapairs(_fieldmetadata(f), extension)
+    return AC.Field(
+        f.name,
+        f.type;
+        nullable=nullable,
+        metadata=metadata,
+        children=collect(AC.Field, f.children),
+    )
+end
+
+_arrowtypesnativetype(T) =
+    T <: Union{
+        Int8,
+        Int16,
+        Int32,
+        Int64,
+        UInt8,
+        UInt16,
+        UInt32,
+        UInt64,
+        Float16,
+        Float32,
+        Float64,
+        Bool,
+        AbstractString,
+        Dates.Date,
+        Dates.DateTime,
+        Dates.Time,
+        Dates.Period,
+        DataDecimals.Decimal,
+        Durations.Duration,
+        Durations.Timestamp,
+        Durations.ZonedTimestamp,
+    } || _zonedwritertype(T)
+
+# The TimeZones extension's write hooks. With the extension absent both
+# answer "not mine", so every column keeps this file's ordinary routes.
+function _zonedwritertype(T)
+    ext = Base.get_extension(@__MODULE__, :ArrowTimeZonesExt)
+    return ext !== nothing && ext.iszonedtype(T)
+end
+
+function _zonednativepart(name::String, v::AbstractVector, T)
+    ext = Base.get_extension(@__MODULE__, :ArrowTimeZonesExt)
+    ext === nothing && return nothing
+    return ext.zonednativepart(name, v, T)
+end
+
+function _arrowtypesneedstype(T, arrowtype, hasarrowname, depth::Int=0)
+    depth < _MAX_WRITER_SCHEMA_DEPTH || throw(
+        ArgumentError(
+            "ArrowTypes storage type exceeds the supported depth " *
+            "$_MAX_WRITER_SCHEMA_DEPTH at $T",
+        ),
+    )
+    T === Union{} && return false
+    T === Missing && return false
+    T === Any && return false
+    if T isa Union
+        members = Base.uniontypes(T)
+        nonnull = count(!=(Missing), members)
+        nullable_struct = Missing in members && any(member -> member <: NamedTuple, members)
+        return nonnull > 1 ||
+               nullable_struct ||
+               any(
+                   member ->
+                       _arrowtypesneedstype(member, arrowtype, hasarrowname, depth + 1),
+                   members,
+               )
+    end
+    NT = Base.nonmissingtype(T)
+    NT !== T && return _arrowtypesneedstype(NT, arrowtype, hasarrowname, depth + 1)
+    arrowtype(T) !== T && return true
+    hasarrowname(T) && return true
+    T <: AbstractDict && return true
+    T <: Tuple && return true
+    if T <: NamedTuple
+        return any(
+            i -> _arrowtypesneedstype(fieldtype(T, i), arrowtype, hasarrowname, depth + 1),
+            1:fieldcount(T),
+        )
+    end
+    if T <: AbstractVector
+        return _arrowtypesneedstype(eltype(T), arrowtype, hasarrowname, depth + 1)
+    end
+    _arrowtypesnativetype(T) && return false
+    # Plain concrete structs are written by field reflection; native facade
+    # values such as Dates must not be routed through ArrowTypes' default
+    # StructKind.
+    return isconcretetype(T) && !isprimitivetype(T)
+end
+
+_arrowtypesneedsvalue(x, context, depth::Int=0) =
+    _walkwritercontainer!(
+        value -> _writerneedstype!(context, typeof(value)),
+        x,
+        context.values,
+        depth,
+    ) === true
+
+function _arrowtypes_needs(v::AbstractVector, context)
+    T = _eltypeof(v)
+    _writerneedstype!(context, T) && return true
+    # Abstract/Any containers do not expose nested logical types. Inspect only
+    # until the first ArrowTypes value is found; concrete columns, and Unions
+    # of leaf types such as Union{Missing,Int64}, take no scan: the check
+    # above already decided every value they can hold.
+    return !isconcretetype(T) &&
+           !_writerleafunion(T) &&
+           any(value -> _arrowtypesneedsvalue(value, context), v)
+end
+
+# A Union of concrete types the value walk does not descend into.
+_writerleafunion(T) =
+    T isa Union && all(Base.uniontypes(T)) do S
+        isconcretetype(S) &&
+        !(S <: Union{Tuple,NamedTuple,Pair,AbstractVector,AbstractDict})
+    end
+
+_arrowtypesconcreteorunion(T) =
+    isconcretetype(T) ||
+    (T isa Union && all(_arrowtypesconcreteorunion, Base.uniontypes(T)))
+
+function _arrowtypesstorageisspecified(context, T::Type, path::Vector{Type}=Type[])
+    Base.@nospecialize T
+    _arrowtypesconcreteorunion(T) && return true
+    _arrowtypesnativetype(T) && return true
+    length(path) < _MAX_WRITER_SCHEMA_DEPTH || throw(
+        ArgumentError(
+            "ArrowTypes storage schema exceeds the supported depth " *
+            "$_MAX_WRITER_SCHEMA_DEPTH at $T",
+        ),
+    )
+    T in path && throw(
+        ArgumentError(
+            "recursive ArrowTypes storage schema: " *
+            _uninferred(join, (string(S) for S in (path..., T)), " -> ")::String,
+        ),
+    )
+    push!(path, T)
+    try
+        T isa Union && return all(
+            member -> _arrowtypesstorageisspecified(context, member, path),
+            Base.uniontypes(T),
+        )
+        (T === Tuple || T === NamedTuple || (T <: Tuple && Base.isvatuple(T))) &&
+            return false
+        T <: Union{NamedTuple,Tuple} && return all(
+            i -> _arrowtypesstorageisspecified(context, fieldtype(T, i), path),
+            1:fieldcount(T),
+        )
+        T <: AbstractVector &&
+            return _arrowtypesstorageisspecified(context, eltype(T), path)
+        T <: AbstractDict &&
+            return _arrowtypesstorageisspecified(context, keytype(T), path) &&
+                   _arrowtypesstorageisspecified(context, valtype(T), path)
+        storage = _writerstoragetype!(context, T)
+        storage === T && return false
+        return _arrowtypesstorageisspecified(context, storage, path)
+    finally
+        pop!(path)
+    end
+end
+
+function _writerpromoteunion(T, S)
+    promoted = promote_type(T, S)
+    return _arrowtypesconcreteorunion(promoted) ? promoted : Union{T,S}
+end
+
+const _WRITER_CONVERSION_ERRORS = Union{MethodError,InexactError,OverflowError,TypeError}
+
+# Base's `convert(Missing, x)` raises a plain error; report a conversion error.
+_writerconvert(::Type{Missing}, value) =
+    value === missing ? missing : throw(MethodError(convert, (Missing, value)))
+
+function _writerconvert(::Type{T}, value) where {T}
+    value isa T && return value
+    if T isa Union
+        for member in Base.uniontypes(T)
+            try
+                return _writerconvert(member, value)
+            catch err
+                err isa _WRITER_CONVERSION_ERRORS || rethrow()
+            end
+        end
+    end
+    return convert(T, value)
+end
+
+_writercolumnname(context, fallback::String) =
+    isempty(context.column) ? fallback : context.column
+
+function _writertoarrow(context, value, writertype::Type, fallback::String, field=nothing)
+    value isa Union{UUIDs.UUID,Int128,UInt128} && return _facadetoarrow(value, field)
+    try
+        return ArrowTypes.toarrow(value)
+    catch err
+        err isa Union{InterruptException,OutOfMemoryError} && rethrow()
+        err isa _WRITER_CONVERSION_ERRORS || rethrow()
+        column = _writercolumnname(context, fallback)
+        throw(
+            ArgumentError(
+                "ArrowTypes.toarrow for writer type $writertype failed for " *
+                "column $column: $(_uninferred(sprint, showerror, err)::String)",
+            ),
+        )
+    end
+end
+
+function _writerconvertlowered(
+    ::Type{T},
+    value,
+    context,
+    writertype::Type,
+    fallback::String,
+) where {T}
+    try
+        return _writerconvert(T, value)
+    catch err
+        err isa Union{InterruptException,OutOfMemoryError} && rethrow()
+        err isa _WRITER_CONVERSION_ERRORS || rethrow()
+        column = _writercolumnname(context, fallback)
+        throw(
+            ArgumentError(
+                "ArrowTypes.toarrow for writer type $writertype produced storage " *
+                "type $(typeof(value)), which cannot be represented as $T for " *
+                "column $column",
+            ),
+        )
+    end
+end
+
+function _writerconvertedcolumn(
+    ::Type{T},
+    values,
+    context,
+    writertype::Type,
+    name::String,
+) where {T}
+    out = Vector{T}(undef, length(values))
+    for i in eachindex(values)
+        out[i] = _writerconvertlowered(T, values[i], context, writertype, name)
+    end
+    return out
+end
+
+# Function barrier for the known-storage lowering loop: the storage type is
+# computed at runtime, so specializing on it here keeps the per-element
+# toarrow/convert path monomorphic instead of boxing every lowered value.
+function _writerloweredcolumn(
+    ::Type{T},
+    v::AbstractVector,
+    context,
+    writertype::Type,
+    name::String,
+    field=nothing,
+) where {T}
+    S = Base.nonmissingtype(T)
+    # Primitive storage is read once by the builder, which lowers each value
+    # as it reads it: no lowered copy of the column.
+    S !== Union{} &&
+        S <: Union{_FixedPrimitive,Bool} &&
+        return _LoweredValues{T}(v) do x
+            lowered = _writertoarrow(context, x, writertype, name, field)
+            return _writerconvertlowered(S, lowered, context, writertype, name)
+        end
+    out = Vector{T}(undef, length(v))
+    for (i, value) in enumerate(v)
+        lowered = _writertoarrow(context, value, writertype, name, field)
+        out[i] = _writerconvertlowered(T, lowered, context, writertype, name)
+    end
+    return out
+end
+
+function _arrowtypesmappedcolumn(name::String, v::AbstractVector, declared, context)
+    S = _eltypeof(v)
+    logical = Base.nonmissingtype(S)
+    storage = Missing <: S ? Union{Missing,declared} : declared
+    # Buffer builders index from 1; a non-one-based vector must go through
+    # the copy path.
+    S === storage && _arrowtypesconcreteorunion(S) && firstindex(v) == 1 && return v
+
+    # An empty logical column has no runtime evidence. A recursively
+    # materializable declared storage shape is still authoritative; unsized
+    # Tuple and other inference-only declarations fall back to Arrow Null, as
+    # ArrowTypes.ToArrow does.
+    isempty(v) &&
+        return _arrowtypesstorageisspecified(context, declared) ? storage[] : Missing[]
+
+    if _arrowtypesconcreteorunion(storage) ||
+       _arrowtypesstorageisspecified(context, declared)
+        return _writerloweredcolumn(storage, v, context, logical, name)
+    end
+
+    lowered = Any[]
+    observed = Type[]
+    seen = Base.IdSet{Type}()
+    sawmissing = false
+    for value in v
+        mapped = _writertoarrow(context, value, logical, name)
+        push!(lowered, mapped)
+        if value === missing
+            sawmissing = true
+            continue
+        end
+        _pushobserved!(observed, seen, typeof(mapped), name)
+    end
+    if isempty(observed)
+        # A concrete logical declaration keeps ArrowTypes.ToArrow's
+        # all-missing fallback type. Abstract inference-only storage has no
+        # shape evidence, so the column is written as Arrow Null (what
+        # ToArrow returns: Missing[]).
+        fallbacktype =
+            _arrowtypesconcreteorunion(S) ?
+            _eltypeof(_uninferred(ArrowTypes.ToArrow, v)::AbstractVector) : Missing
+        return _writerconvertedcolumn(fallbacktype, lowered, context, logical, name)
+    end
+    resulttype = reduce(_writerpromoteunion, observed)
+    sawmissing && (resulttype = Union{Missing,resulttype})
+    return _writerconvertedcolumn(resulttype, lowered, context, logical, name)
+end
+
+function _constructarrowtypespart(name::String, v::AbstractVector; context=nothing)
+    logical = Base.nonmissingtype(_eltypeof(v))
+    # `Base.nonmissingtype(Missing) === Union{}`. Handle a pure-null child
+    # before trait dispatch: bottom is a subtype of every container type and
+    # would otherwise enter an unrelated ArrowKind branch.
+    _eltypeof(v) === Missing && return _constructnativepart(name, v; context)
+    logical === Union{} && return _constructnativepart(name, v; context)
+    context === nothing && (context = _WriterContext())
+    return _withwriterschema(context, logical) do
+        # `v`'s type is known at run time; see `_uninferred`.
+        _uninferred(_constructarrowtypespart_impl, name, v, logical; context)
+    end
+end
+
+function _constructarrowtypespart_impl(name::String, v::AbstractVector, logical; context)
+    # VersionNumber's legacy reflected representation contains variable-length
+    # tuples, so Arrow 3.0 writes String extension storage instead. ArrowTypes'
+    # one-argument JuliaType registration and the VersionNumber(String)
+    # constructor read it back. Arrow 2.x readers cannot: they index the
+    # column with the Struct layout ArrowTypes declares for VersionNumber.
+    if logical === VersionNumber
+        mapped =
+            _eltypeof(v) >: Missing ?
+            Union{Missing,String}[x === missing ? missing : string(x) for x in v] :
+            String[string(x) for x in v]
+        f, d = _constructnativepart(name, mapped; context)
+        return _arrowtypeslogicalfield(context, f, logical), d
+    end
+    declared = _writerstoragetype!(context, logical)
+    if Missing <: _eltypeof(v) &&
+       !(declared isa Union) &&
+       _writerkind!(context, declared) isa ArrowTypes.NullKind
+        throw(
+            ArgumentError(
+                "nullable logical column $name maps its non-missing values to Arrow " *
+                "Null storage, so outer missing values cannot be distinguished; " *
+                "use DictEncode to preserve the two states",
+            ),
+        )
+    end
+    _checkstoragemissing(logical, declared)
+    if logical isa Union && declared === logical
+        # A Julia Union writes one Arrow child per member, except members that
+        # all write one field (several string types, two structs stored as
+        # Int32 without a label): they write one column of it.
+        members = Base.uniontypes(logical)
+        merged = if all(isconcretetype, members)
+            try
+                fields =
+                    AC.Field[first(_constructpart(name, M[]; context)) for M in members]
+                if all(
+                    f -> _conformancemismatch(fields[1], f; exact=true) === nothing,
+                    fields,
+                )
+                    f = fields[1]
+                    f = AC.Field(
+                        f.name,
+                        f.type;
+                        nullable=Missing <: _eltypeof(v),
+                        metadata=_fieldmetadata(f),
+                        children=f.children,
+                    )
+                    _constructpart(f, v; context)
+                end
+            catch err
+                # A member whose empty column has no type to infer, or rows the
+                # one field's builder does not take (plain structs), write as
+                # a union.
+                err isa ArgumentError || rethrow()
+                nothing
+            end
+        end
+        merged === nothing || return merged
+        f, d = _arrowtypesunioncolumn(name, v; context)
+        return _arrowtypeslogicalfield(context, f, logical), d
+    end
+    # Abstract storage must be inferred from observed values. A recursively
+    # materializable declaration remains schema authority for empty columns,
+    # including every declared Union branch nested in a composite.
+    mapped = _arrowtypesmappedcolumn(name, v, declared, context)
+    f, d = _arrowtypesstoragecolumn(name, mapped, context)
+    # A logical type stored as Arrow Null is not nullable unless the column
+    # itself admits missing; otherwise the label's own values would read back
+    # as missing.
+    nullable = f.type isa AC.NullType && !(Missing <: _eltypeof(v)) ? false : f.nullable
+    return _arrowtypeslogicalfield(context, f, logical; nullable=nullable), d
+end
+
+# Missing marks a null slot; as a value of a storage Union it could not be told
+# from one.
+function _checkstoragemissing(logical, declared)
+    declared isa Union &&
+        Missing <: declared &&
+        throw(
+            ArgumentError(
+                "ArrowTypes.ArrowType($logical) is $declared, with Missing as a Union " *
+                "member, which Arrow.jl does not write; declare the storage without " *
+                "Missing and write the column with missing values",
+            ),
+        )
+    return nothing
+end
+
+"A column of lowered storage values, built by the layout its storage type's kind names."
+function _arrowtypesstoragecolumn(name::String, v::AbstractVector, context)
+    _eltypeof(v) === Missing && return _constructnativepart(name, v; context)
+    S = Base.nonmissingtype(_eltypeof(v))
+    S === Union{} && return _constructnativepart(name, v; context)
+    S isa Union && return _uninferred(_arrowtypesunioncolumn, name, v; context)
+    _arrowtypesnativetype(S) && return _constructnativepart(name, v; context)
+    kind = S <: NamedTuple ? ArrowTypes.StructKind() : _writerkind!(context, S)
+    if kind isa ArrowTypes.NullKind
+        nulls = S === Nothing ? fill(missing, length(v)) : v
+        return _constructnativepart(name, nulls; context)
+    elseif kind isa ArrowTypes.FixedSizeListKind
+        N = ArrowTypes.getsize(kind)
+        ArrowTypes.gettype(kind) === UInt8 && return _fixedbinarypart(name, v, N)
+        return _uninferred(_fixedlistpart, name, v, context, N)
+    elseif kind isa ArrowTypes.MapKind
+        S <: AbstractDict || throw(
+            ArgumentError(
+                "ArrowTypes MapKind column $name must lower to AbstractDict rows",
+            ),
+        )
+        return _uninferred(_mappart, name, v, context)
+    elseif kind isa ArrowTypes.ListKind
+        S <: Union{AbstractString,AbstractVector{UInt8}} &&
+            return _constructnativepart(name, v; context)
+        S <: AbstractVector || throw(
+            ArgumentError(
+                "column $(_errname(context, name)) holds $S values, which are not " *
+                "vectors; an Arrow list holds a vector per row (vec(x) flattens an array)",
+            ),
+        )
+        return _uninferred(_listpart, name, v, context)
+    elseif kind isa ArrowTypes.StructKind
+        _arrowtypesstorageisspecified(context, S) || throw(
+            ArgumentError(
+                "ArrowTypes StructKind column $name lowered to an underspecified type " *
+                "$S; give every struct field a writable storage type",
+            ),
+        )
+        return _uninferred(_structpart, name, v, context)
+    elseif kind isa Union{ArrowTypes.PrimitiveKind,ArrowTypes.BoolKind}
+        return _constructnativepart(name, v; context)
+    end
+    throw(
+        ArgumentError(
+            "unsupported ArrowTypes storage kind $(typeof(kind)) for column $name",
+        ),
+    )
+end
+
+# Arrow Union child limit; shares the ArrowTypes storage-Union limit.
+const _MAX_WRITER_UNION_BRANCHES = _MAX_ARROWTYPE_UNION_BRANCHES
+const _MAX_INFERRED_WRITER_TYPES = 8
+
+_writertypevariants(T::Type) =
+    T === Union{} ? Type[] : T isa Union ? Type[Base.uniontypes(T)...] : Type[T]
+
+function _checkedwritervariants(owner::String, T::Type; allowempty::Bool=false)
+    variants = _writertypevariants(T)
+    length(variants) <= _MAX_WRITER_UNION_BRANCHES || throw(
+        ArgumentError("$owner has more than $_MAX_WRITER_UNION_BRANCHES Union branches"),
+    )
+    allowempty || !isempty(variants) || throw(ArgumentError("$owner has no Union branches"))
+    return variants
+end
+
+function _writeruniontype(types)
+    uniontype = Union{}
+    for T in types
+        uniontype = Union{uniontype,T}
+    end
+    return uniontype
+end
+
+"Construct a fresh dense Arrow Union from one concrete Julia Union element type."
+function _arrowtypesunioncolumn(name::String, v::AbstractVector; context)
+    variants = _checkedwritervariants("Arrow Union column $name", _eltypeof(v))
+
+    childvalues = Any[T[] for T in variants]
+    typeids = Vector{Int8}(undef, length(v))
+    offsets = Vector{Int32}(undef, length(v))
+    for (i, x) in enumerate(v)
+        pos = findfirst(T -> x isa T, variants)
+        pos === nothing && throw(
+            ArgumentError(
+                "Arrow Union column $name contains $(typeof(x)), which is not in " *
+                "its declared element type $(_eltypeof(v))",
+            ),
+        )
+        child = childvalues[pos]
+        length(child) <= typemax(Int32) ||
+            throw(ArgumentError("Arrow Union column $name exceeds the Int32 offset range"))
+        typeids[i] = Int8(pos - 1)
+        offsets[i] = Int32(length(child))
+        push!(child, x)
+    end
+
+    childfields = AC.Field[]
+    childdata = AC.ArrayData[]
+    for i in eachindex(variants)
+        # An abstract string member writes its values as Strings.
+        values =
+            variants[i] === AbstractString ? _missings_to(String, childvalues[i]) :
+            childvalues[i]
+        field, data = _constructpart(string(i - 1), values; context)
+        push!(childfields, field)
+        push!(childdata, data)
+    end
+    ids = Int8.(0:(length(variants) - 1))
+    t = AC.UnionType(AC.DenseMode, ids)
+    field = AC.Field(name, t; nullable=Missing in variants, children=childfields)
+    data = AC.ArrayData(
+        t,
+        length(v),
+        [AC._databuffer(typeids), AC._databuffer(offsets)];
+        children=childdata,
+        nullcount=0,
+    )
+    return field, data
+end
+
+"""
+Field `k` of each row of a retained struct column: a typed read's row is a
+`NamedTuple`, a materialized one an ordered `Pair` vector; a missing row reads
+as missing.
+"""
+struct _RowFields{V<:AbstractVector} <: AbstractVector{Any}
+    rows::V
+    k::Int
+end
+Base.size(c::_RowFields) = (length(c.rows),)
+function Base.getindex(c::_RowFields, i::Int)
+    x = c.rows[firstindex(c.rows) + i - 1]
+    x === missing && return missing
+    # Inferring a NamedTuple field's exact type makes Julia 1.10 with code
+    # coverage fail ("fatal error in type inference (type bound)").
+    x isa NamedTuple && return _uninferred(getfield, x, c.k)
+    return last(x[firstindex(x) + c.k - 1])
+end
+
+mutable struct _WriterContext
+    arrowtypes::_ArrowTypesContext
+    needs::IdDict{Type,Bool}
+    kinds::IdDict{Type,Any}
+    extensions::IdDict{Type,Any}
+    schema::Vector{Type}
+    values::Base.IdSet{Any}
+    # True while the values being rebuilt are already in their storage domain
+    # (see `_constructlowered`); false for facade-materialized public rows.
+    lowered::Bool
+    column::String
+    # Fresh strings and bytes write as utf8/binary views instead of offsets.
+    stringview::Bool
+    # Fresh strings, bytes, and lists declare 64-bit offsets.
+    largelists::Bool
+    # Where a writer's rebuilt buffers come from (`_BufferPool`), or nothing.
+    pool::Any
+end
+
+function _WriterContext(
+    column::AbstractString="";
+    stringview::Bool=false,
+    largelists::Bool=false,
+    pool=nothing,
+)
+    arrowtypes = _ArrowTypesContext(; warn=false)
+    return _WriterContext(
+        arrowtypes,
+        IdDict{Type,Bool}(),
+        IdDict{Type,Any}(),
+        IdDict{Type,Any}(),
+        Type[],
+        Base.IdSet{Any}(),
+        false,
+        String(column),
+        stringview,
+        largelists,
+        pool,
+    )
+end
+
+const _MAX_WRITER_SCHEMA_DEPTH = 64
+
+function _withwriterschema(f, context::_WriterContext, T::Type)
+    Base.@nospecialize T
+    if T in context.schema
+        path =
+            _uninferred(join, (string(S) for S in (context.schema..., T)), " -> ")::String
+        throw(ArgumentError("recursive ArrowTypes storage schema: $path"))
+    end
+    length(context.schema) < _MAX_WRITER_SCHEMA_DEPTH || throw(
+        ArgumentError(
+            "ArrowTypes storage schema exceeds the supported depth " *
+            "$_MAX_WRITER_SCHEMA_DEPTH at $T",
+        ),
+    )
+    push!(context.schema, T)
+    try
+        return f()
+    finally
+        pop!(context.schema)
+    end
+end
+
+function _writerstoragetype!(context::_WriterContext, T::Type)
+    Base.@nospecialize T
+    return _arrowtypesstoragetype!(context.arrowtypes, T)
+end
+
+function _writerneedstype!(context::_WriterContext, T::Type)
+    Base.@nospecialize T
+    haskey(context.needs, T) && return context.needs[T]
+    return context.needs[T] = _arrowtypesneedstype(
+        T,
+        nested -> _writerstoragetype!(context, nested),
+        nested -> _writerextension!(context, nested) !== nothing,
+        0,
+    )
+end
+
+function _writerkind!(context::_WriterContext, T::Type)
+    Base.@nospecialize T
+    haskey(context.kinds, T) && return context.kinds[T]
+    return context.kinds[T] = ArrowTypes.ArrowKind(T)
+end
+
+function _writerextension!(context::_WriterContext, T::Type)
+    Base.@nospecialize T
+    haskey(context.extensions, T) && return context.extensions[T]
+    return context.extensions[T] = _writerextensionlabel(T)
+end
+
+function _writerextensionlabel(T::Type)
+    Base.@nospecialize T
+    # A Union has the label its members share, if they all have one: a label
+    # that only matches the Union as a whole (tuple types' JuliaLang.Tuple)
+    # belongs to none of the children it writes as.
+    U = Base.nonmissingtype(T)
+    if U isa Union
+        labels = Any[_writerextensionlabel(M) for M in Base.uniontypes(U)]
+        return allequal(labels) ? first(labels) : nothing
+    end
+    name = _facadearrowname(T)
+    name === nothing || return Pair{String,String}[
+        _EXTENSION_NAME_KEY => name,
+        _EXTENSION_METADATA_KEY => "",
+    ]
+    ArrowTypes.hasarrowname(T) || return nothing
+    # Asserted: the label methods are inferred for any `T`, and a `String` of an
+    # unknown value would convert through methods other packages add.
+    return Pair{String,String}[
+        _EXTENSION_NAME_KEY => String(ArrowTypes.arrowname(T))::String,
+        _EXTENSION_METADATA_KEY => String(ArrowTypes.arrowmetadata(T))::String,
+    ]
+end
+
+function _checkabstractlabel(f::AC.Field, target, T::Type, context::_WriterContext)
+    isconcretetype(target) && return nothing
+    label = _writerextension!(context, T)
+    label === nothing && return nothing
+    retained = _arrowtypesextension(f)
+    (last(label[1]), last(label[2])) == retained || throw(
+        ArgumentError(
+            "registered writer subtype $T declares extension $(repr(label)), which " *
+            "cannot replace abstract retained target $target with extension " *
+            "$(repr(retained))",
+        ),
+    )
+    return nothing
+end
+
+"""
+Narrow one unresolved abstract declaration from whole-column runtime evidence.
+Returns nothing when the declaration cannot be narrowed from runtime evidence.
+"""
+function _narrowabstractcolumn(name::String, v::AbstractVector, context::_WriterContext)
+    logical = Base.nonmissingtype(_eltypeof(v))
+    logical in (Union{}, Any) && return nothing
+    (isconcretetype(logical) || logical isa Union) && return nothing
+    _writerstoragetype!(context, logical) === logical || return nothing
+    _writerextension!(context, logical) === nothing || return nothing
+    # Abstract row types of a plain nested layout (NTuples of nullable values,
+    # `AbstractVector{Int}`) write as that layout without runtime narrowing.
+    _nestedkind(context, logical) === nothing || return nothing
+
+    observed = Type[]
+    seen = Base.IdSet{Type}()
+    nullable = Missing <: _eltypeof(v)
+    for value in v
+        value === missing && continue
+        value isa logical || throw(
+            ArgumentError(
+                "column $name contains $(typeof(value)), which is outside its " *
+                "declared abstract element type $logical",
+            ),
+        )
+        _pushobserved!(observed, seen, typeof(value), name)
+    end
+    isempty(observed) && return nothing
+    needsruntime = any(
+        T -> _writerneedstype!(context, T) || _writerextension!(context, T) !== nothing,
+        observed,
+    )
+    if !needsruntime && _singletypefamily(logical)
+        length(observed) == 1 || return nothing
+        storagetype = nullable ? Union{Missing,only(observed)} : only(observed)
+        return _collectas(storagetype, v)
+    end
+    if !needsruntime && _abstractnonnative(logical)
+        # `Real[1, 2.5]`: one runtime type writes as that type, several as a
+        # dense Union of them.
+        storagetype = _writeruniontype(observed)
+        nullable && (storagetype = Union{Missing,storagetype})
+        return _collectas(storagetype, v)
+    end
+    if !needsruntime
+        # Rows of an abstract NamedTuple column (some fields missing in some
+        # rows, say) share one concrete row type once widened field by field.
+        logical <: NamedTuple || return nothing
+        rowtype = _widenednamedtuple(observed)
+        rowtype === nothing && return nothing
+        nullable && (rowtype = Union{Missing,rowtype})
+        return _collectas(rowtype, v)
+    end
+    storagetype = _writeruniontype(observed)
+    nullable && (storagetype = Union{Missing,storagetype})
+    return _collectas(storagetype, v)
+end
+
+"The field-wise Union of same-named NamedTuple row types, or nothing."
+function _widenednamedtuple(observed)
+    names = fieldnames(first(observed))
+    all(T -> T <: NamedTuple && fieldnames(T) === names, observed) || return nothing
+    types = _uninferred(
+        ntuple,
+        i -> Union{(fieldtype(T, i) for T in observed)...},
+        length(names),
+    )::Tuple
+    return NamedTuple{names,Tuple{types...}}
+end
+
+# ---- registered rewrites: lower a labelled column once ----------------------
+
+"Append runtime type `T` to `types` once; more than 8 is an error naming the column."
+function _pushobserved!(types::Vector{Type}, seen::Base.IdSet{Type}, T::Type, name::String)
+    T in seen && return nothing
+    length(types) < _MAX_INFERRED_WRITER_TYPES || throw(
+        ArgumentError(
+            "column $name holds values of more than $_MAX_INFERRED_WRITER_TYPES types " *
+            "($(_uninferred(join, types, ", ")::String), $T, ...); give it a concrete " *
+            "element type",
+        ),
+    )
+    push!(seen, T)
+    push!(types, T)
+    return nothing
+end
+
+"""
+Whether a column's values lower to storage before `f`'s builder runs: a
+labelled field's do, and so do values with mappings of their own, except
+under a union or an encoding, whose children lower their own values.
+"""
+_lowersvalues(f::AC.Field, target, v, context) =
+    target !== nothing ||
+    !(f.type isa Union{AC.UnionType,AC.RunEndEncodedType,AC.DictionaryType}) &&
+    _mappedvalues(v, context)
+
+"""
+Whether `v`'s values lower through an `ArrowTypes.toarrow` mapping of their
+own: the element type's, or a runtime type's in an abstract column.
+"""
+function _mappedvalues(v::AbstractVector, context::_WriterContext)
+    T = Base.nonmissingtype(_eltypeof(v))
+    T === Union{} && return false
+    # A type stored as a null (`Nothing`, whose storage is `Missing`) is not
+    # lowered: only its label tells its values from missing ones.
+    mapped(S) =
+        S !== VersionNumber &&
+        !(S <: Union{Int128,UInt128}) &&
+        !(_writerstoragetype!(context, S) in (S, Missing, Nothing))
+    isconcretetype(T) && return mapped(T)
+    T isa Union &&
+        all(isconcretetype, Base.uniontypes(T)) &&
+        return any(mapped, Base.uniontypes(T))
+    return any(x -> x !== missing && mapped(typeof(x)), v)
+end
+
+"""
+The values of a column under the retained field `f` lowered once to their
+storage: `ArrowTypes.toarrow` on each value, converted to the storage type
+`f`'s target declares (`Missing` kept), or, when that storage is abstract or
+`f` has no target, to the promoted type of the values' lowered types. A
+labelled child inside a lowered value keeps its logical value, which lowers
+when that child builds.
+"""
+function _lowercolumn(f::AC.Field, target, v::AbstractVector, context::_WriterContext)
+    name = f.name
+    target === nothing && return _inferlowered(f, nothing, v, context)
+    if target === VersionNumber
+        S = any(ismissing, v) ? Union{Missing,String} : String
+        return S[x === missing ? missing : string(x) for x in v]
+    end
+    declared = _writerstoragetype!(context, target)
+    _checkstoragemissing(target, declared)
+    _arrowtypesconcreteorunion(declared) ||
+        _arrowtypesstorageisspecified(context, declared) ||
+        return _inferlowered(f, target, v, context)
+    if !isconcretetype(target)
+        seen = Base.IdSet{Type}()
+        for x in v
+            x === missing && continue
+            T = typeof(x)
+            T in seen && continue
+            push!(seen, T)
+            _checkabstractlabel(f, target, T, context)
+        end
+    end
+    storage = any(x -> x === missing, v) ? Union{Missing,declared} : declared
+    return _writerloweredcolumn(storage, v, context, target, name, f)
+end
+
+"`values` lowered by `lower` one at a time as they are read; missing stays missing."
+struct _LoweredValues{T,V<:AbstractVector,F} <: AbstractVector{T}
+    lower::F
+    values::V
+end
+_LoweredValues{T}(lower::F, values::V) where {T,V,F} = _LoweredValues{T,V,F}(lower, values)
+Base.size(l::_LoweredValues) = (length(l.values),)
+Base.@propagate_inbounds function Base.getindex(l::_LoweredValues{T}, i::Int) where {T}
+    x = l.values[firstindex(l.values) + i - 1]
+    return (x === missing ? missing : l.lower(x))::T
+end
+
+# Every value of a column under a labelled field is its target's; a concrete
+# element type that is not the target says the column was replaced.
+function _checktarget(f::AC.Field, target, v::AbstractVector)
+    T = Base.nonmissingtype(_eltypeof(v))
+    (T === Union{} || T <: target) && return nothing
+    i =
+        isconcretetype(T) ? firstindex(v) :
+        findfirst(x -> x !== missing && !(x isa target), v)
+    i === nothing && return nothing
+    S = isconcretetype(T) ? T : typeof(v[i])
+    throw(
+        ArgumentError(
+            "column $(f.name) holds $S values, but its retained ArrowTypes target is " *
+            "$target",
+        ),
+    )
+end
+
+"""
+`v` lowered value by value through each value's own mapping, as a column of
+the promoted type of the lowered types (a Union of them when they do not
+promote to one concrete type). Under an abstract target, each runtime type
+must carry the target's label.
+"""
+function _inferlowered(f::AC.Field, target, v::AbstractVector, context::_WriterContext)
+    name = f.name
+    values = Vector{Any}(undef, length(v))
+    observed = Type[]
+    seen = Base.IdSet{Type}()
+    runtimes = Base.IdSet{Type}()
+    hasmissing = false
+    for (i, x) in enumerate(v)
+        if x === missing
+            values[i] = missing
+            hasmissing = true
+            continue
+        end
+        T = typeof(x)
+        if !(T in runtimes)
+            push!(runtimes, T)
+            target === nothing || _checkabstractlabel(f, target, T, context)
+        end
+        mapped = T === VersionNumber ? string(x) : _writertoarrow(context, x, T, name, f)
+        # Without a label, a type stored as a null (`Nothing`) would read back as
+        # missing values: its values stay themselves, for the field's builder to
+        # refuse.
+        mapped isa Union{Missing,Nothing} &&
+            target === nothing &&
+            _writerstoragetype!(context, T) in (Missing, Nothing) &&
+            (mapped = x)
+        values[i] = mapped
+        _pushobserved!(observed, seen, typeof(mapped), name)
+    end
+    isempty(observed) && return fill(missing, length(v))
+    storagetype = reduce(_writerpromoteunion, observed)
+    hasmissing && (storagetype = Union{Missing,storagetype})
+    return _writerconvertedcolumn(
+        storagetype,
+        values,
+        context,
+        something(target, Any),
+        name,
+    )
+end
+
+"""
+Build `f` without its label over `storage`, values in its storage domain
+(`context.lowered`), and give the result `f`'s label and nullability back.
+"""
+function _constructlowered(f::AC.Field, storage::AbstractVector, context::_WriterContext)
+    lowered = context.lowered
+    context.lowered = true
+    built, data = try
+        _constructpart(_withoutownextension(f), storage; context)
+    finally
+        context.lowered = lowered
+    end
+    return _retainedfield(f; children=collect(AC.Field, built.children)), data
+end
+
+function _writerhiddenbytes(f::AC.Field, nbytes::Integer, what::String)
+    0 <= nbytes <= typemax(Int) || throw(
+        ArgumentError(
+            "hidden $what for retained field $(f.name) needs an unsupported " *
+            "$nbytes-byte buffer",
+        ),
+    )
+    nbytes == 0 && return AC.BufferSlice()
+    return AC._databuffer(zeros(UInt8, Int(nbytes)))
+end
+
+function _writerhiddenmul(f::AC.Field, left::Integer, right::Integer, what::String)
+    try
+        return Base.checked_mul(Int64(left), Int64(right))
+    catch err
+        err isa OverflowError || rethrow()
+        throw(
+            ArgumentError(
+                "hidden $what for retained field $(f.name) exceeds the supported " *
+                "length range",
+            ),
+        )
+    end
+end
+
+# Zeroed buffers for `n` slots of `f`'s layout, all null when `f` is nullable.
+function _writerhiddenbuffers(f::AC.Field, n::Int)
+    spec = AC.layoutspec_of(f.type)
+    buffers = AC.BufferSlice[]
+    for role in spec.buffers
+        nbytes =
+            role == AC.VALIDITY ? (f.nullable ? cld(n, 8) : 0) :
+            role == AC.DATA ?
+            (
+                spec.fixedwidth == -1 ? cld(n, 8) :
+                _writerhiddenmul(f, n, spec.fixedwidth, "data")
+            ) :
+            role == AC.OFFSETS ? _writerhiddenmul(f, n + 1, spec.offsetwidth, "offset") :
+            role == AC.ELEMENT_OFFSETS || role == AC.SIZES ?
+            _writerhiddenmul(f, n, spec.offsetwidth, "element-offset") :
+            role == AC.VIEWS ? _writerhiddenmul(f, n, 16, "view") :
+            throw(
+                ArgumentError(
+                    "hidden construction for retained field $(f.name) needs a " *
+                    "layout-specific $(role) buffer",
+                ),
+            )
+        push!(buffers, _writerhiddenbytes(f, nbytes, "$role"))
+    end
+    return buffers, f.nullable ? n : 0
+end
+
+"""
+`n` slots of retained field `f` that nothing reads, from zeroed buffers and no
+values: nulls where `f` is nullable, zero placeholders where it is not (an
+all-missing column of a later table, a child of null rows only).
+"""
+function _constructhiddenpart(f::AC.Field, n::Int, context::_WriterContext)
+    n >= 0 || throw(ArgumentError("negative hidden length for retained field $(f.name)"))
+    t = f.type
+    t isa AC.NullType &&
+        return _retainedfield(f), AC.ArrayData(t, n, AC.BufferSlice[]; nullcount=n)
+    fields = AC.Field[]
+    datas = AC.ArrayData[]
+    function child!(c, m)
+        cf, cd = _constructhiddenpart(c, m, context)
+        push!(fields, cf)
+        push!(datas, cd)
+        return nothing
+    end
+    dictionary = nothing
+    if t isa AC.DictionaryType
+        # A non-nullable dictionary's valid indices point at one pool entry.
+        poollength = n == 0 || f.nullable ? 0 : 1
+        _, dictionary = _constructhiddenpart(AC.dictvaluefield(f, t), poollength, context)
+        append!(fields, f.children)
+    elseif t isa Union{AC.ListType,AC.ListViewType,AC.MapType}
+        child!(only(f.children), 0)
+    elseif t isa AC.FixedSizeListType
+        child!(only(f.children), Int(_writerhiddenmul(f, n, t.listsize, "child")))
+    elseif t isa AC.StructType
+        foreach(c -> child!(c, n), f.children)
+    elseif t isa AC.RunEndEncodedType
+        # One run of one value.
+        RT = AC.juliatype(f.children[1].type)
+        n <= typemax(RT) || throw(
+            ArgumentError("column $(f.name) length exceeds its retained run-end type"),
+        )
+        rf, rd = _constructpart(f.children[1], n == 0 ? RT[] : RT[RT(n)]; context)
+        push!(fields, rf)
+        push!(datas, rd)
+        child!(f.children[2], min(n, 1))
+        data = AC.ArrayData(t, n, AC.BufferSlice[]; children=datas, nullcount=0)
+        return _retainedfield(f; children=fields), data
+    elseif t isa AC.UnionType
+        # Every slot takes slot 0 of the child that holds nulls, else (slots
+        # nothing reads) of the first child.
+        k = something(_unionnullchild(f), 1)
+        sparse = t.mode == AC.SparseMode
+        for (j, c) in enumerate(f.children)
+            child!(c, sparse ? n : j == k ? min(n, 1) : 0)
+        end
+        typeids = n == 0 ? AC.BufferSlice() : AC._databuffer(fill(t.typeids[k], n))
+        offsets = n == 0 ? AC.BufferSlice() : AC._databuffer(zeros(Int32, n))
+        buffers = sparse ? AC.BufferSlice[typeids] : AC.BufferSlice[typeids, offsets]
+        data = AC.ArrayData(t, n, buffers; children=datas, nullcount=0)
+        return _retainedfield(f; children=fields), data
+    end
+    buffers, nullcount = _writerhiddenbuffers(f, n)
+    data = AC.ArrayData(t, n, buffers; children=datas, dictionary, nullcount)
+    return _retainedfield(f; children=fields), data
+end
+
+# Registered mappings exchange ArrowTypes-domain temporals (`_arrowtypesscalar`):
+# micro/nanosecond timestamps as raw Int64 and second/millisecond timestamps as
+# zone-free DateTime. Unmarked fresh composites bring public values to the same
+# seam, so both domains lower here; anything else has no exact storage.
+function _arrowtypestemporalstorage(t::AC.ArrowType, value)
+    ok, storage = _facadetostorage(t, value)
+    ok && return storage
+    t isa AC.TimestampType || return nothing
+    t.unit in (AC.MICROSECOND, AC.NANOSECOND) && value isa Int64 && return value
+    return value isa Dates.DateTime ? _timestampstorage(t.unit, value) : nothing
+end
+
+"A fixed_size_binary(N) column from `NTuple{N,UInt8}` rows."
+function _fixedbinarypart(name::String, v::AbstractVector, N::Int)
+    T = NTuple{N,UInt8}
+    t = AC.FixedSizeBinaryType(N)
+    field = AC.Field(name, t; nullable=Missing <: _eltypeof(v))
+    if _eltypeof(v) === T
+        data = something(_fixedbuffer(v), AC._databuffer(collect(T, v)))
+        return field, AC.ArrayData(t, length(v), [AC.BufferSlice(), data]; nullcount=0)
+    end
+    rows, validity, nc = _nullablevalues(T, v, ntuple(_ -> 0x00, N))
+    return field, AC.ArrayData(t, length(v), [validity, AC._databuffer(rows)]; nullcount=nc)
+end
+
+"Registered public-domain value Field and Julia target for a retained dictionary."
+function _registereddictionaryfield(context::_WriterContext, f::AC.Field)
+    t = f.type::AC.DictionaryType
+    _, target, _ = _arrowtypestarget(context.arrowtypes, f)
+    target === nothing && return nothing, nothing
+    valuefield = _arrowtypesdictvaluefield(f, t; retainmetadata=true)
+    return valuefield, target
+end
+
+"Recursive Field equality: name, type, nullability, ordered metadata, and children."
+_fieldcontractequal(a::AC.Field, b::AC.Field) =
+    _conformancemismatch(a, b; exact=true) === nothing
+
+"""
+Assemble a fresh Int32-indexed dictionary Field and its first batch from
+already-built pool data.
+"""
+# The narrowest signed index type for `n` categories (indices 0 to n - 1).
+_dictindextype(n::Integer) =
+    n <= 128 ? AC.IntType(8, true) :
+    n <= 32_768 ? AC.IntType(16, true) :
+    n - 1 <= typemax(Int32) ? AC.IntType(32, true) : AC.IntType(64, true)
+
+# Whether a column's categories are ordered: a read dictionary column's flag,
+# a CategoricalArray's (the CategoricalArrays extension), else false.
+_isordered(::AbstractVector) = false
+_isordered(x::SubArray) = _isordered(parent(x))
+_isordered(x::DictEncode) = _isordered(x.data)
+_isordered(x::DictEncoded) = x.ordered
+_isordered(x::ChainedVector{T,<:DictEncoded}) where {T} =
+    !isempty(x.arrays) && all(_isordered, x.arrays)
+
+function _newdictfromdata(
+    name::String,
+    valuefield::AC.Field,
+    valuedata::AC.ArrayData,
+    indices::AbstractVector;
+    nullable::Bool,
+    indextype::AC.IntType=AC.IntType(32, true),
+    ordered::Bool=false,
+)
+    t = AC.DictionaryType(indextype, valuefield.type, ordered)
+    field = AC.Field(
+        name,
+        t;
+        nullable,
+        metadata=_fieldmetadata(valuefield),
+        children=collect(AC.Field, valuefield.children),
+    )
+    return field, _dictbatch(field, indices, valuedata)
+end
+
+# --- retained-schema rewrite (facade Table/Stream round-trips) --------------
+
+"Storage integers for a column of public values under a RETAINED temporal descriptor."
+function _retainedstorage(
+    t::Union{AC.DateType,AC.TimestampType,AC.TimeType,AC.DurationType},
+    v::AbstractVector,
+    name::String,
+)
+    return _retainedstorage(_facadetoken(t), t, v, name)
+end
+
+@noinline function _retainedstorage(
+    token::Val{K},
+    t::Union{AC.DateType,AC.TimestampType,AC.TimeType,AC.DurationType},
+    v::AbstractVector,
+    name::String,
+) where {K}
+    out = Union{Missing,Int64}[]
+    sizehint!(out, length(v))
+    for x in v
+        if x === missing
+            push!(out, missing)
+        else
+            sv = _exactfacadevalue(token, x)
+            sv === nothing && throw(
+                ArgumentError(
+                    "column $name holds $(typeof(x)) values that do not match " *
+                    "its retained Arrow type $(repr(t)); the column was " *
+                    "replaced with incompatible data",
+                ),
+            )
+            push!(out, Int64(sv))
+        end
+    end
+    return out
+end
+
+# The same for lowered values, in the ArrowTypes domain too: raw integers for
+# microsecond and nanosecond timestamps, `DateTime`s for the coarser ones.
+function _loweredstorage(t::AC.ArrowType, v::AbstractVector, name::String)
+    out = Union{Missing,Int64}[]
+    sizehint!(out, length(v))
+    for x in v
+        if x === missing
+            push!(out, missing)
+        else
+            sv = _arrowtypestemporalstorage(t, x)
+            sv === nothing && throw(
+                ArgumentError(
+                    "column $name holds the value $(repr(x)), which cannot be " *
+                    "represented exactly by its retained Arrow type $(repr(t))",
+                ),
+            )
+            push!(out, Int64(sv))
+        end
+    end
+    return out
+end
+
+# The reader takes arrow.bool8 as Bool only on int8 storage; on other
+# storage the label is kept and the values are written as they read.
+_isbool8(f::AC.Field) =
+    f.type == AC.IntType(8, true) &&
+    _fieldmetavalue(f, _EXTENSION_NAME_KEY) == "arrow.bool8"
+_bool8storage(v::AbstractVector) =
+    Missing <: _eltypeof(v) ? Union{Missing,Int8}[x isa Bool ? Int8(x) : x for x in v] :
+    Int8[x isa Bool ? Int8(x) : x for x in v]
+
+function _retainedfield(f::AC.Field; children=collect(AC.Field, f.children))
+    return AC.Field(
+        f.name,
+        f.type;
+        nullable=f.nullable,
+        metadata=_fieldmetadata(f),
+        children=children,
+    )
+end
+
+function _retainedvalidity(f::AC.Field, v::AbstractVector)
+    present = Bool[x !== missing for x in v]
+    f.nullable || all(present) || throw(_nonnullableerror(f.name))
+    return present
+end
+
+# The writer's utf8/binary builders, after checking the values against the
+# retained field: strings for utf8, byte vectors for binary.
+function _retainedvarbytes(f::AC.Field, v::AbstractVector, pool=nothing)
+    t = f.type::Union{AC.Utf8Type,AC.BinaryType}
+    utf8 = t isa AC.Utf8Type
+    Offset = t.large ? Int64 : Int32
+    _, d =
+        if v isa Union{_PayloadColumn,_PayloadRows} &&
+           _payloadparent(v) isa (utf8 ? DataStrings.StringVector : DataStrings.BytesVector)
+            _packedpayloadpart(
+                f.name,
+                _payloadentries(v),
+                _payloadparent(v).buffers,
+                t,
+                Offset,
+                Missing <: _eltypeof(v),
+                pool,
+            )
+        else
+            V = utf8 ? AbstractString : AbstractVector{UInt8}
+            Base.nonmissingtype(_eltypeof(v)) <: V ||
+                all(x -> x === missing || x isa V, v) ||
+                throw(
+                    ArgumentError(
+                        "column $(f.name) must contain " *
+                        (utf8 ? "string" : "byte-vector") *
+                        " values",
+                    ),
+                )
+            _varbytespart(f.name, v, t, Offset)
+        end
+    AC.nullcount(d) == 0 ||
+        f.nullable ||
+        throw(
+            ArgumentError(
+                "column $(f.name) holds missing values but its retained field is non-nullable",
+            ),
+        )
+    return _retainedfield(f), d
+end
+
+function _retainedview(f::AC.Field, v::AbstractVector)
+    t = f.type::AC.ViewType
+    present = _retainedvalidity(f, v)
+    payloads = Vector{DataStrings.StringPayload}(undef, length(v))
+    data = UInt8[]
+    for (i, x) in enumerate(v)
+        if x === missing
+            # An empty view: the validity bit marks the null, and the slot
+            # stays valid when a parent hides this child's validity.
+            payloads[i] = DataStrings.StringPayload(UInt64(0), UInt64(0))
+            continue
+        end
+        bytes = if t.utf8
+            x isa AbstractString ||
+                throw(ArgumentError("column $(f.name) must contain string values"))
+            _utf8units(x)
+        else
+            x isa AbstractVector{UInt8} ||
+                throw(ArgumentError("column $(f.name) must contain byte-vector values"))
+            x
+        end
+        n = length(bytes)
+        if n <= DataStrings.INLINE_MAX
+            payloads[i] = DataStrings.inline_payload(bytes, 1, n)
+        else
+            length(data) <= typemax(Int32) - n || throw(
+                ArgumentError("column $(f.name) view data exceeds the Int32 offset range"),
+            )
+            off = length(data)
+            append!(data, bytes)
+            payloads[i] = DataStrings.view_payload(data, off + 1, n, 0, off)
+        end
+    end
+    buffers = AC.BufferSlice[AC._bitmapbuffer(present), AC._databuffer(payloads)]
+    isempty(data) || push!(buffers, AC._databuffer(data))
+    d = AC.ArrayData(t, length(v), buffers; nullcount=count(!, present))
+    return _retainedfield(f), d
+end
+
+function _retainedfixedbytes(f::AC.Field, v::AbstractVector)
+    t = f.type::AC.FixedSizeBinaryType
+    if Base.nonmissingtype(_eltypeof(v)) === NTuple{t.nbytes,UInt8}
+        _, d = _fixedbinarypart(f.name, v, t.nbytes)
+        AC.nullcount(d) > 0 &&
+            !f.nullable &&
+            throw(
+                ArgumentError(
+                    "column $(f.name) holds missing values but its retained field is non-nullable",
+                ),
+            )
+        return _retainedfield(f), d
+    end
+    present = _retainedvalidity(f, v)
+    data = zeros(UInt8, Base.checked_mul(length(v), t.nbytes))
+    for (i, x) in enumerate(v)
+        x === missing && continue
+        x isa Union{AbstractVector{UInt8},NTuple{<:Any,UInt8}} ||
+            throw(ArgumentError("column $(f.name) must contain byte-vector values"))
+        length(x) == t.nbytes || throw(
+            ArgumentError(
+                "column $(f.name) fixed-size value $i has $(length(x)) bytes; " *
+                "expected $(t.nbytes)",
+            ),
+        )
+        for k = 1:(t.nbytes)
+            data[(i - 1) * t.nbytes + k] = x[k]
+        end
+    end
+    d = AC.ArrayData(
+        t,
+        length(v),
+        [AC._bitmapbuffer(present), AC._databuffer(data)];
+        nullcount=count(!, present),
+    )
+    return _retainedfield(f), d
+end
+
+"Values (`fill` at missing slots), validity buffer, and null count of a column."
+function _nullablevalues(::Type{S}, v::AbstractVector, fill::S, f::F=identity) where {S,F}
+    n = length(v)
+    i0 = firstindex(v) - 1
+    vals = Vector{S}(undef, n)
+    bits = Vector{UInt8}(undef, cld(n, 8))
+    valid = 0
+    # Each validity byte is built in a register from 8 values, branch-free;
+    # whole bytes take a fixed 8-step loop the compiler unrolls.
+    @inbounds for b in eachindex(bits)
+        base = (b - 1) << 3
+        byte = 0x00
+        if base + 8 <= n
+            for j = 0:7
+                x = v[i0 + base + j + 1]
+                present = x !== missing
+                vals[base + j + 1] = present ? f(x) : fill
+                byte |= UInt8(present) << (j % UInt)
+            end
+        else
+            for j = 0:(n - base - 1)
+                x = v[i0 + base + j + 1]
+                present = x !== missing
+                vals[base + j + 1] = present ? f(x) : fill
+                byte |= UInt8(present) << (j % UInt)
+            end
+        end
+        bits[b] = byte
+        valid += count_ones(byte)
+    end
+    nc = n - valid
+    validity =
+        nc == 0 ? AC.BufferSlice() : AC.BufferSlice(AC.heapregion(bits), 0, length(bits))
+    return vals, validity, nc
+end
+
+# A `Decimal{P,S,T}` is its storage integer, so a column of them already is
+# the Arrow coefficient buffer: a `Vector` is wrapped without copying and any
+# other vector is collected once. Values write as stored, as Arrow C++ does;
+# the precision check is `validate_full`'s.
+function _decimaldata(f::AC.Field, v::AbstractVector, ::Type{D}) where {D}
+    t = f.type
+    if _eltypeof(v) === D
+        data = something(_fixedbuffer(v), AC._databuffer(collect(D, v)))
+        return AC.ArrayData(t, length(v), [AC.BufferSlice(), data]; nullcount=0)
+    end
+    vals, validity, nc = _nullablevalues(D, v, zero(D))
+    nc > 0 &&
+        !f.nullable &&
+        throw(
+            ArgumentError(
+                "column $(f.name) holds missing values but its retained field is non-nullable",
+            ),
+        )
+    return AC.ArrayData(t, length(v), [validity, AC._databuffer(vals)]; nullcount=nc)
+end
+
+# `v`'s decimals as `H`s, whose storage is `T`.
+_widendecimals(::Type{H}, ::Type{T}, v) where {H,T} =
+    map(x -> x === missing ? missing : reinterpret(H, T(DataDecimals.unscaled(x))), v)
+
+function _retaineddecimal(f::AC.Field, v::AbstractVector)
+    t = f.type::AC.DecimalType
+    D = Base.nonmissingtype(_eltypeof(v))
+    if _shareddecimal(t)
+        H = _decimalhost(t)
+        D === H && return _retainedfield(f), _decimaldata(f, v, D)
+        # Another storage width at the field's scale (`dec"1.25"` stores an
+        # Int32): widen every coefficient in one pass.
+        if D <: DataDecimals.Decimal && isconcretetype(D) && D.parameters[2] == t.scale
+            w = _widendecimals(H, _decimalstorage(t), v)
+            return _retainedfield(f), _decimaldata(f, w, H)
+        end
+    end
+    v = [x isa DataDecimals.AbstractDecimal ? _shareddecimalraw(t, x) : x for x in v]
+    present = _retainedvalidity(f, v)
+    if t.bits == 32 || t.bits == 64
+        T = t.bits == 32 ? Int32 : Int64
+        values = Vector{T}(undef, length(v))
+        for (i, x) in enumerate(v)
+            x === missing ||
+                x isa T ||
+                throw(
+                    ArgumentError(
+                        "column $(f.name) must contain $T decimal storage values",
+                    ),
+                )
+            values[i] = x === missing ? zero(T) : x
+        end
+        databuf = AC._databuffer(values)
+    else
+        width = AC.primwidth(t)
+        values = zeros(UInt8, Base.checked_mul(length(v), width))
+        for (i, x) in enumerate(v)
+            x === missing && continue
+            x isa AbstractVector{UInt8} || throw(
+                ArgumentError("column $(f.name) must contain byte-vector decimal values"),
+            )
+            length(x) == width || throw(
+                ArgumentError(
+                    "column $(f.name) decimal value $i has $(length(x)) bytes; " *
+                    "expected $width",
+                ),
+            )
+            copyto!(values, (i - 1) * width + 1, x, 1, width)
+        end
+        databuf = AC._databuffer(values)
+    end
+    d = AC.ArrayData(
+        t,
+        length(v),
+        [AC._bitmapbuffer(present), databuf];
+        nullcount=count(!, present),
+    )
+    return _retainedfield(f), d
+end
+
+function _retainedinterval(f::AC.Field, v::AbstractVector)
+    t = f.type::AC.IntervalType
+    v = [x isa _IntervalValue ? _sharedintervalraw(t, x) : x for x in v]
+    present = _retainedvalidity(f, v)
+    if t.unit == AC.YEAR_MONTH
+        values = Int32[
+            x === missing ? Int32(0) :
+            x isa Int32 ? x :
+            throw(ArgumentError("column $(f.name) must contain Int32 intervals")) for
+            x in v
+        ]
+    elseif t.unit == AC.DAY_TIME
+        T = NamedTuple{(:days, :millis),Tuple{Int32,Int32}}
+        values = T[
+            x === missing ? T((0, 0)) :
+            x isa T ? x :
+            throw(ArgumentError("column $(f.name) must contain $T intervals")) for
+            x in v
+        ]
+    else
+        T = NamedTuple{(:months, :days, :nanos),Tuple{Int32,Int32,Int64}}
+        values = T[
+            x === missing ? T((0, 0, 0)) :
+            x isa T ? x :
+            throw(ArgumentError("column $(f.name) must contain $T intervals")) for
+            x in v
+        ]
+    end
+    d = AC.ArrayData(
+        t,
+        length(v),
+        [AC._bitmapbuffer(present), AC._databuffer(values)];
+        nullcount=count(!, present),
+    )
+    return _retainedfield(f), d
+end
+
+function _validateretainedstructrows(f::AC.Field, rows::AbstractVector)
+    nchildren = length(f.children)
+    for row in rows
+        row === missing && continue
+        if row isa NamedTuple
+            # A typed read's row: the field names must be the children's.
+            (
+                length(row) == nchildren &&
+                all(j -> String(keys(row)[j]) == f.children[j].name, 1:nchildren)
+            ) || throw(
+                ArgumentError(
+                    "column $(f.name) retained struct row has fields $(keys(row)); " *
+                    "expected $(Tuple(c.name for c in f.children))",
+                ),
+            )
+            continue
+        end
+        row isa AbstractVector || throw(
+            ArgumentError(
+                "column $(f.name) retained struct rows must be ordered Pair vectors",
+            ),
+        )
+        length(row) == nchildren || throw(
+            ArgumentError(
+                "column $(f.name) retained struct row has $(length(row)) fields; " *
+                "expected $nchildren",
+            ),
+        )
+        firstrowindex = firstindex(row)
+        for j = 1:nchildren
+            kv = row[firstrowindex + j - 1]
+            kv isa Pair || throw(
+                ArgumentError("column $(f.name) retained struct rows must contain Pairs"),
+            )
+            first(kv) == f.children[j].name || throw(
+                ArgumentError(
+                    "column $(f.name) retained struct child $j is named " *
+                    "$(repr(first(kv))); expected $(repr(f.children[j].name))",
+                ),
+            )
+        end
+    end
+    return nothing
+end
+
+function _writermapkeyisless(f::AC.Field, a, b)
+    try
+        result = isless(a, b)
+        result isa Bool || throw(
+            ArgumentError("Map key comparison for field $(f.name) did not return Bool"),
+        )
+        return result
+    catch err
+        err isa Union{InterruptException,OutOfMemoryError} && rethrow()
+        err isa MethodError || rethrow()
+        throw(
+            ArgumentError(
+                "Map field $(f.name) declares sorted keys, but keys of types " *
+                "$(typeof(a)) and $(typeof(b)) cannot be ordered",
+            ),
+        )
+    end
+end
+
+function _validatemapphysicalkeys(
+    name::String,
+    keyfield::AC.Field,
+    keydata::AC.ArrayData,
+    offsets,
+)
+    for row = 1:(length(offsets) - 1)
+        seen = Set{Any}()
+        for index = (Int(offsets[row]) + 1):Int(offsets[row + 1])
+            key = _storedkey(keyfield, keydata, Int64(index))
+            key in seen && throw(
+                ArgumentError(
+                    "column $name row $row has duplicate physical Map key storage",
+                ),
+            )
+            push!(seen, key)
+        end
+    end
+    return nothing
+end
+
+function _retainedree(f::AC.Field, v::AbstractVector, context::_WriterContext)
+    t = f.type::AC.RunEndEncodedType
+    length(f.children) == 2 ||
+        throw(ArgumentError("column $(f.name) retained REE descriptor needs two children"))
+    runfield, valuefield = f.children
+    runtype = runfield.type
+    runtype isa AC.IntType ||
+        throw(ArgumentError("column $(f.name) retained REE run ends must be integers"))
+    RT = AC.juliatype(runtype)
+    length(v) <= typemax(RT) ||
+        throw(ArgumentError("column $(f.name) length exceeds its retained run-end type"))
+    if v isa RunEndEncoded
+        # A run-end column read from Arrow keeps its runs: those over its rows,
+        # each cut to them.
+        lo = searchsortedfirst(v.runends, v.offset + 1)
+        hi = searchsortedfirst(v.runends, v.offset + v.len)
+        runends = RT[RT(min(v.runends[r], v.offset + v.len) - v.offset) for r = lo:hi]
+        runvalues = v.len == 0 ? v.values[1:0] : v.values[lo:hi]
+    else
+        runends = RT[]
+        runvalues = Any[]
+        for (i, x) in enumerate(v)
+            # Logical `isequal` may intentionally coarsen a custom type. Only
+            # the non-overridable `===` relation is safe for run coalescing.
+            if isempty(runvalues) || x !== last(runvalues)
+                push!(runvalues, x)
+                push!(runends, RT(i))
+            else
+                runends[end] = RT(i)
+            end
+        end
+    end
+    rebuiltvaluefield, valuedata = _constructpart(valuefield, runvalues; context)
+    # Neighbouring runs whose values are stored alike are one run.
+    selected = Int[]
+    ends = RT[]
+    previous = nothing
+    for i = 1:(valuedata.len)
+        key = _storedkey(rebuiltvaluefield, valuedata, Int64(i))
+        if i > 1 && isequal(key, previous)
+            ends[end] = runends[i]
+        else
+            push!(selected, i)
+            push!(ends, runends[i])
+        end
+        previous = key
+    end
+    if length(selected) < valuedata.len
+        valuedata = _takerows(rebuiltvaluefield, valuedata, selected)
+        runends = ends
+    end
+    rebuiltrunfield, runenddata = _constructpart(runfield, runends; context)
+    d = AC.ArrayData(
+        t,
+        length(v),
+        AC.BufferSlice[];
+        children=AC.ArrayData[runenddata, valuedata],
+        nullcount=0,
+    )
+    return _retainedfield(f; children=AC.Field[rebuiltrunfield, rebuiltvaluefield]), d
+end
+
+"Construct one part under a retained Field: descriptor, nullability, metadata."
+Base.@nospecializeinfer _constructpart(
+    f::AC.Field,
+    @nospecialize(v::AbstractVector);
+    context::_WriterContext=_WriterContext(),
+) = _uninferred(_retainedpartof, f, v, context)::Tuple{AC.Field,AC.ArrayData}
+
+Base.@nospecializeinfer function _retainedpartof(
+    f::AC.Field,
+    @nospecialize(v::AbstractVector),
+    context::_WriterContext,
+)
+    # No value to build: an empty column is its field's empty data.
+    isempty(v) && return _constructhiddenpart(f, 0, context)
+    # Values of an abstract element type (a flattened list's, a struct field's)
+    # narrow to the types they hold.
+    _arrowtypesconcreteorunion(_eltypeof(v)) || (v = map(identity, v))
+    # Values with no type of their own (an all-missing child of `Any` values)
+    # are the field's nulls, whatever its layout.
+    _holdsnull(f) &&
+        _eltypeof(v) === Missing &&
+        return _constructhiddenpart(f, length(v), context)
+    _, target, _ = _arrowtypestarget(context.arrowtypes, f)
+    if _lowersvalues(f, target, v, context)
+        target === nothing || _checktarget(f, target, v)
+        # Lowered and built without its label, a labelled union or Null field
+        # would take missing values that only an unlabelled one keeps (and
+        # `nothing` lowers to `missing`).
+        target !== nothing &&
+            f.type isa Union{AC.UnionType,AC.NullType} &&
+            !_holdsnull(f) &&
+            any(ismissing, v) &&
+            throw(_nonullerror(f))
+        # No value to lower: an all-missing column is its field's nulls.
+        _holdsnull(f) &&
+            all(ismissing, v) &&
+            return _constructhiddenpart(f, length(v), context)
+        return _constructlowered(f, _lowercolumn(f, target, v, context), context)
+    end
+    return _constructretainedpart(f, v, context)
+end
+
+# Writer-side element types a retained descriptor's builder converts exactly,
+# beyond its public type: a written `DateTime` (or another
+# date-time) column under a timestamp, any `AbstractString` under a string.
+_retainedwritertype(::AC.TimestampType, ::Type{T}) where {T} = T <: Dates.AbstractDateTime
+_retainedwritertype(::AC.Utf8Type, ::Type{T}) where {T} = T <: AbstractString
+_retainedwritertype(t::AC.ViewType, ::Type{T}) where {T} =
+    t.utf8 ? T <: AbstractString : T <: AbstractVector{UInt8}
+_retainedwritertype(::AC.BinaryType, ::Type{T}) where {T} = T <: AbstractVector{UInt8}
+_retainedwritertype(t::AC.FixedSizeBinaryType, ::Type{T}) where {T} =
+    T <: NTuple{t.nbytes,UInt8} || T <: AbstractVector{UInt8}
+_retainedwritertype(::AC.ArrowType, ::Type) = false
+
+function _checkretainedidentity(f::AC.Field, t::AC.ArrowType, v::AbstractVector)
+    # Identity FIRST, for every retained field with a known facade type:
+    # a replaced column is rejected on its declared element type before any
+    # value is read.
+    Fp = _facadebasetype(t)
+    if Fp !== Any
+        NT = Base.nonmissingtype(_eltypeof(v))
+        NT <: Fp ||
+            NT === Union{} ||
+            _retainedwritertype(t, NT) ||
+            throw(
+                ArgumentError(
+                    "column $(f.name) holds $(NT) values, but its retained Arrow " *
+                    "type $(repr(t)) materializes as $(Fp); the column was " *
+                    "replaced with incompatible data",
+                ),
+            )
+        _eltypeof(v) >: Missing &&
+            !f.nullable &&
+            throw(
+                ArgumentError(
+                    "column $(f.name) may hold missing values but its retained " *
+                    "field is non-nullable",
+                ),
+            )
+    end
+    return Fp
+end
+
+# The builder of a retained layout other than Null, Union, and the primitive
+# types, or nothing.
+_retainedbuilder(t::AC.ArrowType) =
+    t isa Union{AC.DateType,AC.TimestampType,AC.TimeType,AC.DurationType} ?
+    _retainedtemporal :
+    t isa Union{AC.Utf8Type,AC.BinaryType} ? _retainedvarbytes :
+    t isa AC.ViewType ? _retainedview :
+    t isa AC.FixedSizeBinaryType ? _retainedfixedbytes :
+    t isa AC.DecimalType ? _retaineddecimal :
+    t isa AC.IntervalType ? _retainedinterval :
+    t isa Union{AC.ListType,AC.ListViewType} ? _listpart :
+    t isa AC.FixedSizeListType ? _fixedlistpart :
+    t isa AC.StructType ? _structpart :
+    t isa AC.MapType ? _mappart : t isa AC.RunEndEncodedType ? _retainedree : nothing
+
+function _retainedtemporal(f::AC.Field, v::AbstractVector, context::_WriterContext)
+    t = f.type
+    context.lowered && return _rebuildtemporal(f, _loweredstorage(t, v, f.name))
+    _checkretainedidentity(f, t, v)
+    return _rebuildtemporal(f, _retainedstorage(t, v, f.name))
+end
+_retainedvarbytes(f::AC.Field, v::AbstractVector, context::_WriterContext) =
+    _retainedvarbytes(f, v, context.pool)
+_retainedview(f::AC.Field, v::AbstractVector, ::_WriterContext) = _retainedview(f, v)
+_retainedfixedbytes(f::AC.Field, v::AbstractVector, ::_WriterContext) =
+    _retainedfixedbytes(f, v)
+_retaineddecimal(f::AC.Field, v::AbstractVector, ::_WriterContext) = _retaineddecimal(f, v)
+_retainedinterval(f::AC.Field, v::AbstractVector, ::_WriterContext) =
+    _retainedinterval(f, v)
+
+"One part under a retained field: the identity check, then the type's builder."
+function _constructretainedpart(f::AC.Field, v::AbstractVector, context::_WriterContext)
+    t = f.type
+    t isa AC.DictionaryType && throw(
+        ArgumentError(
+            "nested retained dictionary field $(f.name) cannot be reconstructed " *
+            "after facade materialization because its pool is unavailable",
+        ),
+    )
+    if t isa AC.NullType
+        # `nothing` is Null storage only where a label lowered a value to it.
+        all(x -> x === missing || (x === nothing && context.lowered), v) || throw(
+            ArgumentError(
+                "column $(f.name) no longer matches its retained Arrow NullType; " *
+                "give it a Missing element type",
+            ),
+        )
+        d = AC.ArrayData(t, length(v), AC.BufferSlice[]; nullcount=length(v))
+        return AC.Field(f.name, t; nullable=f.nullable, metadata=_fieldmetadata(f)), d
+    end
+    t isa Union{AC.DateType,AC.TimestampType,AC.TimeType,AC.DurationType} ||
+        _checkretainedidentity(f, t, v)
+    # Each layout's builder compiles for the columns that reach it, not for
+    # every column type this method sees (see `_uninferred`).
+    builder = _retainedbuilder(t)
+    builder === nothing ||
+        return _uninferred(builder, f, v, context)::Tuple{AC.Field,AC.ArrayData}
+    if t isa AC.UnionType
+        built = _uninferred(_constructfacadeunion, f, v, context)
+        built === nothing || return built
+        throw(
+            ArgumentError(
+                "column $(f.name) is an Arrow union, and some of its values fit none or " *
+                "several of the union's children (two children of one type, say), so " *
+                "which child each value belongs to is unknown; write the values as a " *
+                "fresh column instead (Arrow.write(path, DataFrame(table)) infers the " *
+                "column's type from them) or drop the column",
+            ),
+        )
+    end
+    # Build the column naturally, then impose the retained descriptor: types
+    # must match and nullability comes from the retained field. Missing values
+    # under a non-nullable field mean the column was replaced.
+    fn, dn = _constructpart(f.name, v; context)
+    # Polars' and Arrow 2.x's 128-bit Int type, which pyarrow cannot read,
+    # rewrites as a fresh Int128 column writes: fixed-size binary plus the
+    # JuliaLang.(U)Int128 label.
+    wide = t isa AC.IntType && t.bits == 128 && fn.type isa AC.FixedSizeBinaryType
+    wide ||
+        AC.typeequal(fn.type, t) ||
+        throw(
+            ArgumentError(
+                "column $(f.name) no longer matches its retained Arrow type " *
+                "$(repr(t)); it now maps to $(repr(fn.type))",
+            ),
+        )
+    fn.nullable &&
+        !f.nullable &&
+        AC.nullcount(dn) > 0 &&
+        throw(
+            ArgumentError(
+                "column $(f.name) holds missing values but its retained field is " *
+                "non-nullable",
+            ),
+        )
+    metadata = _fieldmetadata(f)
+    if wide
+        metadata = Pair{String,String}[
+            p for p in something(metadata, Pair{String,String}[]) if
+            !startswith(first(p), "ARROW:extension:")
+        ]
+        append!(metadata, something(_fieldmetadata(fn), Pair{String,String}[]))
+    end
+    rebuilt = AC.Field(
+        f.name,
+        fn.type;
+        nullable=f.nullable,
+        metadata=metadata,
+        children=collect(AC.Field, fn.children),
+    )
+    return rebuilt, dn
+end
+
+function _rebuildtemporal(f::AC.Field, storage)
+    t = f.type
+    nmissing = count(x -> x === missing, storage)
+    nmissing > 0 &&
+        !f.nullable &&
+        throw(
+            ArgumentError(
+                "column $(f.name) holds missing values but its retained field is " *
+                "non-nullable",
+            ),
+        )
+    fld = AC.Field(f.name, t; nullable=f.nullable, metadata=_fieldmetadata(f))
+    return fld, _temporaldata(t, storage)
+end
+
+"""
+A dictionary pool hint whose first `prefix` categories are kept exactly (a
+pool already written or retained from an Arrow source); the categories after
+them are candidates, deduplicated by storage value like a column's own.
+"""
+struct _PoolHint{V<:AbstractVector}
+    values::V
+    prefix::Int
+end
+_hintvalues(hint::_PoolHint) = hint.values
+_hintvalues(hint::AbstractVector) = hint
+_hintprefix(hint::_PoolHint) = hint.prefix
+_hintprefix(hint::AbstractVector) = length(hint)
+
+# Dictionary category identity of a stored value: its type and value, a
+# float's by its bits (NaN payloads, and 0.0 and -0.0, are distinct
+# categories).
+_poolkey(x::AbstractFloat) = (typeof(x), reinterpret(Unsigned, x))
+_poolkey(x) = (typeof(x), x)
+
+# A candidate category before its pool is built: the value itself (`===`,
+# which no `isequal` method widens), or the contents of an array of plain
+# values (a list row). Building the pool then merges categories stored alike.
+struct _Same
+    x::Any
+end
+Base.isequal(a::_Same, b::_Same) = a.x === b.x
+Base.hash(a::_Same, h::UInt) = hash(objectid(a.x), h)
+_candidatekey(x) =
+    x isa Array && eltype(x) <: Union{Missing,Base.BitInteger,Base.IEEEFloat,Bool,String} ?
+    _poolkey(x) : _Same(x)
+
+"The category (`_poolkey`) of value `i` of a built column, with its union child."
+function _storedkey(f::AC.Field, d::AC.ArrayData, i::Int64)
+    d.type isa AC.UnionType || return _poolkey(AC.getvalue(f, d, i))
+    cf, cd, ci = AC._union_child(f, d, i)
+    return (findfirst(c -> c === cf, f.children), _storedkey(cf, cd, ci))
+end
+
+"""
+The first position of each distinct stored category of a built pool
+(`selected`) and every position's 0-based index among them (`remap`). The
+first `prefix` categories (a pool already written or retained) are all kept,
+in order.
+"""
+function _compactpool(f::AC.Field, d::AC.ArrayData, prefix::Int)
+    selected = Int[]
+    remap = Vector{Int64}(undef, d.len)
+    seen = Dict{Any,Int64}()
+    for i = 1:(d.len)
+        key = _storedkey(f, d, Int64(i))
+        index = i <= prefix ? Int64(-1) : get(seen, key, Int64(-1))
+        if index < 0
+            index = Int64(length(selected))
+            push!(selected, i)
+            haskey(seen, key) || (seen[key] = index)
+        end
+        remap[i] = index
+    end
+    return selected, remap
+end
+
+"Rows `rows` of built column `d`, as one column."
+_takerows(f::AC.Field, d::AC.ArrayData, rows) = _dictionaryconcat(
+    f,
+    _DictionaryRange[_DictionaryRange(d, Int64(i - 1), Int64(1)) for i in rows],
+    Limits(),
+    nothing,
+)
+
+"""
+An element type that holds both `T` and `S` values: `T` when it already
+does, else their common supertype, with `missing` if either has it.
+"""
+function _widenedtype(T::Type, S::Type)
+    S <: T && return T
+    W = typejoin(Base.nonmissingtype(T), Base.nonmissingtype(S))
+    return Missing <: T || Missing <: S ? Union{Missing,W} : W
+end
+
+"One value pool: keep a retained prefix exactly and append new categories."
+function _dictionarypool(v::AbstractVector, retainedpool; writetype=nothing)
+    if retainedpool === nothing
+        T = writetype === nothing ? Base.nonmissingtype(_eltypeof(v)) : writetype
+        T === Union{} && throw(
+            ArgumentError(
+                "cannot infer a dictionary value type from empty or all-missing columns",
+            ),
+        )
+        pool = T[]
+    else
+        # New categories may be other types than the retained ones (writer
+        # values after a public pool read back, DataStrings after Strings):
+        # widen the value type instead of converting.
+        pool = _collectas(
+            _widenedtype(_eltypeof(retainedpool), Base.nonmissingtype(_eltypeof(v))),
+            retainedpool,
+        )
+    end
+    # Candidates dedupe by `_candidatekey`, so the pool holds about one value
+    # per category, not one per row.
+    seen = Dict{Any,Nothing}()
+    for x in pool
+        x === missing || (seen[_candidatekey(x)] = nothing)
+    end
+    _addcategories!(pool, seen, v)
+    return pool
+end
+
+# Function barrier: `pool` and each part of `vals` are only known at run time.
+function _addcategories!(pool, seen, v)
+    for x in v
+        x === missing && continue
+        key = _candidatekey(x)
+        if !haskey(seen, key)
+            push!(pool, x)
+            seen[key] = nothing
+        end
+    end
+    return nothing
+end
+
+"First pool position for each non-null value; duplicate categories stay intact."
+function _dictionarylookup(pool)
+    lookup = Dict{Any,Int64}()
+    for (i, x) in enumerate(pool)
+        x === missing && continue
+        key = _candidatekey(x)
+        haskey(lookup, key) || (lookup[key] = Int64(i - 1))
+    end
+    return lookup
+end
+
+function _dictionaryindices(v, lookup, missingindex=nothing)
+    return Union{Missing,Int64}[
+        x === missing ? (missingindex === nothing ? missing : missingindex) :
+        lookup[_candidatekey(x)] for x in v
+    ]
+end
+
+function _remapdictionaryindices(indices, remap::Vector{Int64})
+    return Union{Missing,Int64}[
+        index === missing ? missing : remap[Int(index) + 1] for index in indices
+    ]
+end
+
+"""
+The 0-based codes of a dictionary column read from Arrow (or a range of its
+rows) when its pool is the first `prefix` categories of `hint`, else nothing.
+"""
+function _dictcodes(v, hint, prefix::Int)
+    hint === nothing && return nothing
+    parentcol, rows = v isa SubArray ? (parent(v), only(parentindices(v))) : (v, nothing)
+    parentcol isa DictEncoded && (rows === nothing || rows isa UnitRange{Int}) ||
+        return nothing
+    pool = parentcol.pool
+    length(pool) <= prefix && all(i -> isequal(pool[i], hint[i]), eachindex(pool)) ||
+        return nothing
+    return rows === nothing ? parentcol.indices : view(parentcol.indices, rows)
+end
+
+"One shared-pool dictionary batch: identical pool OBJECT across batches."
+function _dictbatch(fld::AC.Field, indices::AbstractVector, pool_d::AC.ArrayData)
+    t = fld.type::AC.DictionaryType
+    present = [x !== missing for x in indices]
+    # The index type is a run-time property of the field.
+    inds = _uninferred(_dictindexbuffer, AC.juliatype(t.indextype), indices)::AC.BufferSlice
+    nc = count(!, present)
+    d = AC.ArrayData(
+        t,
+        length(indices),
+        [AC._bitmapbuffer(present), inds];
+        dictionary=pool_d,
+        nullcount=nc,
+    )
+    return d
+end
+
+_dictindexbuffer(::Type{IT}, indices) where {IT} =
+    AC._databuffer(IT[x === missing ? zero(IT) : IT(x) for x in indices])
+
+"Field + first-batch data for a dictionary column under a RETAINED type."
+function _retaineddictfromdata(
+    rf::AC.Field,
+    valuefield::AC.Field,
+    valuedata::AC.ArrayData,
+    poollength::Int,
+    firstidx::AbstractVector,
+    name::String,
+)
+    t = rf.type::AC.DictionaryType
+    AC.typeequal(valuefield.type, t.valuetype) || throw(
+        ArgumentError(
+            "column $name pool maps to $(summary(valuefield.type)) but the retained " *
+            "dictionary value type is $(summary(t.valuetype))",
+        ),
+    )
+    IT = AC.juliatype(t.indextype)
+    poollength - 1 <= typemax(IT) || throw(
+        ArgumentError(
+            "column $name pool of $poollength values exceeds the retained " *
+            "$(summary(t.indextype)) index range",
+        ),
+    )
+    field = AC.Field(
+        name,
+        t;
+        nullable=rf.nullable,
+        metadata=_fieldmetadata(rf),
+        children=collect(AC.Field, valuefield.children),
+    )
+    return field, _dictbatch(field, firstidx, valuedata)
+end
+
+_withfieldmetadata(f::AC.Field, ::Nothing) = f
+function _withfieldmetadata(f::AC.Field, metadata::Vector{Pair{String,String}})
+    # Explicit application metadata augments retained/extension metadata.
+    # A generated ArrowTypes label is authoritative for the values that were
+    # lowered; accepting a conflicting explicit label would make them decode
+    # as a different logical type.
+    merged = _mergemetapairs(_fieldmetadata(f), metadata; protectextension=true)
+    return AC.Field(
+        f.name,
+        f.type;
+        nullable=f.nullable,
+        metadata=merged,
+        children=collect(AC.Field, f.children),
+    )
+end
+
+# A column with a DataAPI ref pool (a PooledArray or CategoricalArray, say) is
+# written dictionary-encoded, as Arrow 2.x did: its pool, in pool order and
+# with unused entries, starts the Arrow dictionary. `refpools=false` writes
+# such a column as its values instead (a later table's column whose schema
+# field is not a dictionary).
+_hasrefpool(x::AbstractVector) =
+    DataAPI.refpool(x) !== nothing &&
+    DataAPI.refarray(x) !== x &&
+    Base.nonmissingtype(_eltypeof(x)) !== Union{}
+_hasrefpool(::Any) = false
+
+# Whether a column holds UUIDs (an abstract one, only UUIDs and missing
+# values), which a pooled column or `dictencode` writes unencoded: pyarrow
+# cannot read a dictionary of arrow.uuid values.
+function _uuidvalues(x::AbstractVector)
+    T = Base.nonmissingtype(_eltypeof(x))
+    T === UUIDs.UUID && return true
+    isconcretetype(T) && return false
+    # The scan compiles for the column's own type (see `_uninferred`).
+    return _uninferred(_onlyuuids, x)::Bool
+end
+_uuidvalues(::Any) = false
+_onlyuuids(x) =
+    all(y -> y === missing || y isa UUIDs.UUID, x) && any(y -> y isa UUIDs.UUID, x)
+
+"""
+The values and category pool of a ref-pool column. Pool values that are
+wrappers without an ArrowTypes.jl mapping (CategoricalArrays' values) unwrap
+through `DataAPI.unwrap`; a mapped element type keeps its values so its
+ArrowTypes.jl lowering applies.
+"""
+function _refpoolvalues(x::AbstractVector)
+    T = Base.nonmissingtype(_eltypeof(x))
+    mapped = ArrowTypes.ArrowType(T) !== T || ArrowTypes.arrowname(T) !== Symbol()
+    pool = DataAPI.refpool(x)
+    unwrap =
+        !mapped &&
+        _uninferred(any, v -> v !== missing && DataAPI.unwrap(v) !== v, pool)::Bool
+    values = unwrap ? [DataAPI.unwrap(v) for v in x] : x
+    hint = Base.nonmissingtype(_eltypeof(values))[]
+    # Iterate: CategoricalArrays' ref pool is indexed from zero.
+    for v in pool
+        v === missing || push!(hint, unwrap ? DataAPI.unwrap(v) : v)
+    end
+    return values, hint
+end
+
+"""
+Construct one logical column of a record batch.
+
+This is the sole column-policy seam used by the write facade. It owns fresh
+inference, retained reconstruction, ArrowTypes lowering, dictionary pooling,
+field metadata, and the check that strings are UTF-8 (`_InvalidUTF8`).
+
+`retained` is the Field a rewrite must reproduce; `poolhint` carries the
+retained dictionary-pool snapshot (or nothing), enforced below; `metadata` is
+explicit application metadata merged onto the final Field.
+"""
+function _constructcolumn(name::Symbol, v::AbstractVector; kwargs...)
+    try
+        field, data = _constructcolumnparts(name, v; kwargs...)
+        _checkutf8(name, field, data)
+        return field, data
+    catch err
+        prefix = "fromjulia: unsupported element type "
+        msg = err isa ArgumentError ? err.msg : nothing
+        msg isa String && startswith(msg, prefix) || rethrow()
+        T = _reflectedstructtype(v)
+        T === nothing && throw(
+            ArgumentError(
+                "column $name holds $(chopprefix(msg::String, prefix)) values, which have " *
+                "no Arrow type; convert them first, or define ArrowTypes.ArrowType and " *
+                "ArrowTypes.toarrow for their type",
+            ),
+        )
+        throw(
+            ArgumentError(
+                "column $name holds $T values, which have no ArrowTypes.jl mapping, so " *
+                "Arrow writes their fields as a Struct; a field failed with " *
+                "\"$msg\". Define ArrowTypes.ArrowType and ArrowTypes.toarrow " *
+                "for $T, or convert the column first (DataAPI.unwrap.(column) for " *
+                "wrapped values such as CategoricalValue)",
+            ),
+        )
+    end
+end
+
+# The element type of a column written by reflecting a plain struct's fields
+# (ArrowTypes.jl's default StructKind mapping), or nothing.
+function _reflectedstructtype(v)
+    T = Base.nonmissingtype(_eltypeof(v))
+    isconcretetype(T) && isstructtype(T) && !(T <: Union{NamedTuple,Tuple}) ||
+        return nothing
+    ArrowTypes.ArrowType(T) === T && ArrowTypes.arrowname(T) === Symbol() || return nothing
+    return ArrowTypes.ArrowKind(T) isa ArrowTypes.StructKind ? T : nothing
+end
+
+function _constructcolumnparts(
+    name::Symbol,
+    v::AbstractVector;
+    retained::Union{Nothing,AC.Field}=nothing,
+    poolhint=nothing,
+    metadata::Union{Nothing,Vector{Pair{String,String}}}=nothing,
+    refpools::Bool=true,
+    stringview::Bool=false,
+    largelists::Bool=false,
+    growable::Bool=false,
+    pool=nothing,
+)
+    if retained !== nothing && _isbool8(retained)
+        # arrow.bool8 reads as Bool; its storage is Int8 0 or 1.
+        _, int8data = _constructcolumnparts(
+            name,
+            _uninferred(_bool8storage, v);
+            retained=_withoutownextension(retained),
+            metadata,
+        )
+        return _withfieldmetadata(_retainedfield(retained), metadata), int8data
+    end
+    fieldname = String(name)
+    dictintent =
+        (retained !== nothing && retained.type isa AC.DictionaryType) ||
+        v isa DictEncode ||
+        (refpools && retained === nothing && _hasrefpool(v) && !_uuidvalues(v))
+    # A dictionary's pool outlives its batch, so it never takes reused buffers.
+    context =
+        _WriterContext(fieldname; stringview, largelists, pool=dictintent ? nothing : pool)
+    # A ref-pool column written as its values still unwraps them.
+    !dictintent && _hasrefpool(v) && (v = first(_uninferred(_refpoolvalues, v)::Tuple))
+    # Built by calls this function does not infer (see `_uninferred`).
+    field, data =
+        dictintent ?
+        _uninferred(
+            _dictcolumnparts,
+            name,
+            fieldname,
+            v,
+            poolhint,
+            retained,
+            growable,
+            context,
+        )::Tuple{AC.Field,AC.ArrayData} :
+        _uninferred(
+            _plaincolumnparts,
+            name,
+            fieldname,
+            v,
+            retained,
+            context,
+        )::Tuple{AC.Field,AC.ArrayData}
+    return _withfieldmetadata(field, metadata), data
+end
+
+"A dictionary column of `_constructcolumnparts`: its field and data."
+function _dictcolumnparts(name, fieldname, part, poolhint, retained, growable, context)
+    values = part isa DictEncode ? (part::DictEncode).data : part
+    if _hasrefpool(values)
+        values, hint = _uninferred(_refpoolvalues, values)::Tuple
+        poolhint === nothing && (poolhint = hint)
+    end
+    retainedvaluefield = nothing
+    retainedtarget = nothing
+    if retained !== nothing
+        retainedvaluefield, retainedtarget = _registereddictionaryfield(context, retained)
+        retainedtype = retained.type::AC.DictionaryType
+        retainedvaluefield === nothing &&
+            retainedtype.valuetype isa AC.NullType &&
+            retained.nullable &&
+            _arrowtypesextension(retained) !== nothing &&
+            throw(
+                ArgumentError(
+                    "column $name has a nullable retained Dictionary<Null> with " *
+                    "an unregistered extension; materialization cannot " *
+                    "distinguish a valid null-pool index from an outer null index",
+                ),
+            )
+        # Table materialization already lifts retained pool snapshots
+        # through the dictionary value Field. They stay in the same
+        # public domain as row values until the merged pool is lowered
+        # exactly once through `_constructpart` on that value Field below.
+    end
+
+    # The hint's first categories (a pool already written or retained from an
+    # Arrow source) are kept exactly; the categories after them dedupe.
+    retainedprefix = poolhint === nothing ? 0 : _hintprefix(poolhint)
+    poolhint === nothing || (poolhint = _hintvalues(poolhint))
+    # A dictionary column read from Arrow whose pool starts the hint keeps its
+    # indices; others index their values into the pool.
+    codes = _dictcodes(values, poolhint, retainedprefix)
+    if retained !== nothing
+        (retained.type::AC.DictionaryType).valuetype isa AC.UnionType &&
+            retainedvaluefield === nothing &&
+            throw(
+                ArgumentError(
+                    "column $name has a retained UnionType whose child type ids " *
+                    "cannot be recovered from materialized facade values",
+                ),
+            )
+        T = Base.nonmissingtype(_eltypeof(values))
+        if retainedvaluefield === nothing
+            publictype = _facadebasetype(retained.type)
+            # Any string writes to a utf8 pool.
+            publictype === String && (publictype = AbstractString)
+            publictype !== Any &&
+                !(T <: publictype) &&
+                !_retainedwritertype((retained.type::AC.DictionaryType).valuetype, T) &&
+                T !== Union{} &&
+                throw(
+                    ArgumentError(
+                        "column $name holds $T values, but its retained " *
+                        "dictionary materializes as $publictype; the column " *
+                        "was replaced with incompatible data",
+                    ),
+                )
+        else
+            islogical =
+                T <: retainedtarget ||
+                (T === Any && all(x -> x === missing || x isa retainedtarget, values))
+            islogical || throw(
+                ArgumentError(
+                    "column $name holds $T values, but its retained " *
+                    "dictionary materializes as $retainedtarget; the column " *
+                    "was replaced with incompatible data",
+                ),
+            )
+        end
+        # A non-nullable dictionary can materialize missing through a
+        # valid index into a null pool entry. The retained pool keeps
+        # that distinct from a missing index.
+        !retained.nullable &&
+            any(ismissing, something(codes, values)) &&
+            (codes !== nothing || poolhint === nothing || !any(ismissing, poolhint)) &&
+            throw(
+                ArgumentError(
+                    "column $name may hold missing values but its retained " *
+                    "dictionary field is non-nullable",
+                ),
+            )
+        (retained.type::AC.DictionaryType).ordered &&
+            poolhint === nothing &&
+            throw(
+                ArgumentError(
+                    "column $name has an ordered retained dictionary, but " *
+                    "its original category pool is unavailable",
+                ),
+            )
+    end
+
+    if codes === nothing
+        pool = _dictionarypool(values, poolhint)
+        lookup = _dictionarylookup(pool)
+        missingindex =
+            retained !== nothing && !retained.nullable ? findfirst(ismissing, pool) :
+            nothing
+        missingindex === nothing || (missingindex = Int64(missingindex - 1))
+        candidateindices = _dictionaryindices(values, lookup, missingindex)
+    else
+        pool = poolhint
+        candidateindices = codes
+    end
+    candidatevaluefield, candidatevaluedata = if retained === nothing
+        f, d = _constructpart(fieldname, pool; context)
+        # A dictionary field's extension label is, to pyarrow, the label of the
+        # dictionary type itself, which arrow.uuid's storage rules out: pyarrow
+        # 25 refuses such a file, its own output included.
+        _fieldmetavalue(f, _EXTENSION_NAME_KEY) == _UUID_EXTENSION && throw(
+            ArgumentError(
+                "column $name holds UUIDs, which Arrow.jl does not dictionary-encode: " *
+                "pyarrow cannot read a dictionary of arrow.uuid values. Write the " *
+                "column without Arrow.DictEncode",
+            ),
+        )
+        f, d
+    else
+        retainedtype = retained.type::AC.DictionaryType
+        constructionfield =
+            retainedvaluefield === nothing ? AC.dictvaluefield(retained, retainedtype) :
+            retainedvaluefield
+        _constructpart(constructionfield, pool; context)
+    end
+    # Candidates stored alike are one category.
+    valuefield = candidatevaluefield
+    selected, remap = _compactpool(valuefield, candidatevaluedata, retainedprefix)
+    valuedata =
+        length(selected) == candidatevaluedata.len ? candidatevaluedata :
+        _takerows(valuefield, candidatevaluedata, selected)
+    indices =
+        length(selected) == length(remap) ? candidateindices :
+        _remapdictionaryindices(candidateindices, remap)
+    # `indices`' type is known at run time; see `_uninferred`.
+    retained === nothing && return _uninferred(
+        _newdictfromdata,
+        fieldname,
+        valuefield,
+        valuedata,
+        indices;
+        nullable=Missing <: _eltypeof(values),
+        # The narrowest index type the categories need; a pool that later
+        # tables may extend takes at least Int32, as pyarrow writes.
+        indextype=_dictindextype(growable ? max(valuedata.len, 1 << 16) : valuedata.len),
+        # ArrowCategoricalArraysExt adds an `_isordered` method.
+        ordered=_uninferred(_isordered, part)::Bool,
+    )::Tuple{AC.Field,AC.ArrayData}
+    return _uninferred(
+        _retaineddictfromdata,
+        retained,
+        valuefield,
+        valuedata,
+        Int(valuedata.len),
+        indices,
+        fieldname,
+    )::Tuple{AC.Field,AC.ArrayData}
+end
+
+"A non-dictionary column of `_constructcolumnparts`: its field and data."
+function _plaincolumnparts(name, fieldname, part, retained, context)
+    narrowed =
+        retained === nothing ? _narrowabstractcolumn(fieldname, part, context) : nothing
+    try
+        # A successful narrowing pass already saw every value; replanning
+        # from part of them can split one declared nullable Tuple child into
+        # incompatible Int and Null Fields.
+        retained === nothing || return _constructpart(retained, part; context)
+        return _constructpart(
+            fieldname,
+            something(narrowed, part);
+            context,
+            narrowabstract=(narrowed === nothing),
+        )
+    catch err
+        (err isa _OffsetOverflow && err.part == 0) || rethrow()
+        e = err::_OffsetOverflow
+        # The overflow row is a row of this column only at its top level.
+        throw(_OffsetOverflow(e.column, 1, e.column == fieldname ? e.row : 0))
+    end
+end
diff --git a/src/columns.jl b/src/columns.jl
new file mode 100644
index 00000000..2fd855c0
--- /dev/null
+++ b/src/columns.jl
@@ -0,0 +1,2592 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# Read-side columns for flat layouts: zero-copy views over decoded Arrow
+# buffers, DataStrings string columns, and dictionary vectors.
+#
+# A view wraps its buffers as unowned Julia vectors (so loops vectorize like
+# `Vector` loops) and holds the decoded `ArrayData`, whose buffer slices keep
+# the backing memory (a memory map, the input bytes, or a decompressed
+# buffer) reachable. Every access preserves the view, so memory a view can
+# read is memory that is alive. Views check no release flag: the facade never
+# unmaps a source eagerly (see `release!(::Table)`).
+# =============================================================================
+
+"""
+    Arrow.ArrowVector{T} <: AbstractVector{T}
+
+Supertype of the read-only columns `Arrow.Table` and `Arrow.Stream` return
+for flat, list, map, and struct layouts. A flat column reads its Arrow buffers in
+place (a memory-mapped file, the input bytes, or a decompressed buffer) and
+keeps that memory alive while the column is reachable, independent of its
+table. `copy(column)` returns an owned, mutable vector: a `Vector`, or a
+`PooledArray` for a dictionary-encoded column.
+"""
+abstract type ArrowVector{T} <: AbstractVector{T} end
+
+Base.IndexStyle(::Type{<:ArrowVector}) = IndexLinear()
+
+@noinline _readonlycolumn() = error(
+    "Arrow columns are read-only views of the data they were read from; " *
+    "copy(column), copy(table), or DataFrame(table) returns a mutable copy",
+)
+Base.setindex!(::ArrowVector, v, ::Int) = _readonlycolumn()
+# `push!` and `append!` resize first.
+Base.resize!(::ArrowVector, ::Integer) = _readonlycolumn()
+# Containers that know only a column's type (a `ChainedVector` whose batches
+# are all empty) allocate through this; a new vector is a mutable `Array`.
+Base.similar(::Type{<:ArrowVector{T}}, dims::Dims) where {T} = Array{T}(undef, dims)
+
+# --- buffer wrapping ------------------------------------------------------------
+
+"""
+A read-only vector of `S` values in memory that need not be aligned for `S`,
+read with unaligned loads. Arrow IPC buffers are aligned to 8 bytes (pyarrow
+writes no more), so 16- and 32-byte values (`Int128`, 128- and 256-bit
+decimals) start at a 16-byte boundary only half of the time. `owner` keeps
+the memory alive.
+"""
+struct _UnalignedVector{S} <: AbstractVector{S}
+    ptr::Ptr{S}
+    len::Int
+    owner::Any
+end
+Base.size(v::_UnalignedVector) = (v.len,)
+Base.IndexStyle(::Type{<:_UnalignedVector}) = IndexLinear()
+Base.@propagate_inbounds function Base.getindex(v::_UnalignedVector, i::Int)
+    @boundscheck checkbounds(v, i)
+    owner = v.owner
+    # `unsafe_load` loads with alignment 1.
+    return GC.@preserve owner unsafe_load(v.ptr, i)
+end
+function Base.copyto!(
+    dest::Vector{S},
+    doffs::Integer,
+    src::_UnalignedVector{S},
+    soffs::Integer,
+    n::Integer,
+) where {S}
+    n == 0 && return dest
+    (
+        n > 0 &&
+        checkbounds(Bool, dest, doffs:(doffs + n - 1)) &&
+        checkbounds(Bool, src, soffs:(soffs + n - 1))
+    ) || throw(BoundsError(dest, doffs:(doffs + n - 1)))
+    owner = src.owner
+    GC.@preserve dest owner unsafe_copyto!(
+        Ptr{UInt8}(pointer(dest, doffs)),
+        Ptr{UInt8}(src.ptr + (soffs - 1) * sizeof(S)),
+        n * sizeof(S),
+    )
+    return dest
+end
+
+Base.copy(v::_UnalignedVector{S}) where {S} =
+    copyto!(Vector{S}(undef, v.len), 1, v, 1, v.len)
+
+# How a column stores its `S` values: in place with unaligned loads when `S`
+# needs more than the 8-byte alignment Arrow buffers have, else a `Vector`.
+_buffertype(::Type{S}) where {S} =
+    Base.datatype_alignment(S) > 8 ? _UnalignedVector{S} : Vector{S}
+
+# An unowned vector over `n` elements of `S` starting `offset` elements into
+# `b` (a `_buffertype(S)`). Callers keep `b`'s region reachable for as long
+# as the vector is used. A start misaligned for `S` (possible only for
+# foreign or hand-built buffers) gets an owned, aligned `Vector` copy.
+function _wrapbuffer(
+    ::Type{S},
+    b::AC.BufferSlice,
+    offset::Int64,
+    n::Int64,
+    budget=nothing,
+) where {S}
+    isbitstype(S) || throw(ArgumentError("a wrapped buffer needs an isbits element type"))
+    unaligned = _buffertype(S) === _UnalignedVector{S}
+    n == 0 && return unaligned ? _UnalignedVector{S}(Ptr{S}(C_NULL), 0, nothing) : S[]
+    w = Int64(sizeof(S))
+    src = AC.subslice(b, AC.checked_mul(offset, w), AC.checked_mul(n, w))
+    p = AC.sliceptr(src)
+    unaligned && return _UnalignedVector{S}(Ptr{S}(p), Int(n), src)
+    if UInt(p) % Base.datatype_alignment(S) != 0
+        _chargeexact!(budget, S, n, "aligned buffer copy")
+        out = Vector{S}(undef, Int(n))
+        GC.@preserve out src begin
+            # `S` is known at run time; see `_uninferred`.
+            unsafe_copyto!(Ptr{UInt8}(_uninferred(pointer, out)::Ptr), p, Int(src.len))
+        end
+        return out
+    end
+    return unsafe_wrap(Array, Ptr{S}(p), Int(n))
+end
+
+# The validity bitmap bytes covering `d`'s slots and the bit position of slot
+# 1 in them; an empty vector when no slot is null.
+function _validitybits(d::AC.ArrayData)
+    v = AC.validitybuffer(d)
+    (AC.isempty_buffer(v) || AC.nullcount(d) == 0 || d.len == 0) && return UInt8[], 0
+    first = d.offset >> 3
+    nbytes = ((d.offset + d.len - 1) >> 3) - first + 1
+    return _wrapbuffer(UInt8, v, first, nbytes), Int(d.offset & 7)
+end
+
+@inline function _bitset(bits::Vector{UInt8}, bitoffset::Int, i::Int)
+    k = bitoffset + i - 1
+    return @inbounds((bits[(k >> 3) + 1] >> (k & 7)) & 0x01) == 0x01
+end
+
+@inline _isnullslot(validity::Vector{UInt8}, bitoffset::Int, i::Int) =
+    !isempty(validity) && !_bitset(validity, bitoffset, i)
+
+# --- storage conversions --------------------------------------------------------
+
+# `C` in `Primitive{T,S,C}` names how one stored `S` becomes a `T`;
+# `Nothing` means the layouts are identical.
+@inline _fromstorage(::Type{Nothing}, x) = x
+struct _DaysToDate end
+@inline _fromstorage(::Type{_DaysToDate}, x::Int32) =
+    Dates.Date(Dates.UTD(Int64(x) + _EPOCH_DAYS))
+struct _MillisToDateTime end
+@inline _fromstorage(::Type{_MillisToDateTime}, x::Int64) =
+    Dates.DateTime(Dates.UTM(x + Dates.UNIXEPOCH))
+"Time of day stored in ticks of `N` nanoseconds (range-checked when built)."
+struct _TimeOfDay{N} end
+@inline _fromstorage(::Type{_TimeOfDay{N}}, x) where {N} =
+    Dates.Time(Dates.Nanosecond(Int64(x) * N))
+struct _YearMonth end
+@inline _fromstorage(::Type{_YearMonth}, x::Int32) = Durations.Duration(x, 0, 0)
+struct _DayTime end
+@inline _fromstorage(::Type{_DayTime}, x::NTuple{2,Int32}) =
+    Durations.Duration(0, x[1], Int64(x[2]) * 1_000_000)
+"Stored bytes as a byte vector (the raw read of a decimal no `Decimal` type holds)."
+struct _StoredBytes end
+@inline _fromstorage(::Type{_StoredBytes}, x::NTuple{N,UInt8}) where {N} = collect(x)
+
+# The element type each conversion produces.
+_storagetarget(::Type{_DaysToDate}) = Dates.Date
+_storagetarget(::Type{_MillisToDateTime}) = Dates.DateTime
+_storagetarget(::Type{<:_TimeOfDay}) = Dates.Time
+_storagetarget(::Type{_YearMonth}) = Durations.Duration
+_storagetarget(::Type{_DayTime}) = Durations.Duration
+_storagetarget(::Type{_StoredBytes}) = Vector{UInt8}
+
+# --- fixed width ------------------------------------------------------------------
+
+"""
+    Arrow.Primitive{T,S,C,D} <: Arrow.ArrowVector{T}
+
+A fixed-width column: element `i` is the `i`th stored `S` value converted to
+`T` (the same bits when the layouts match), or `missing` where the validity
+bitmap marks a null. `D` is how the `S` values are held: a `Vector{S}`, or
+for 16- and 32-byte values, a view of their buffer read with unaligned loads.
+"""
+struct Primitive{T,S,C,D<:AbstractVector{S}} <: ArrowVector{T}
+    data::D
+    validity::Vector{UInt8}
+    bitoffset::Int
+    owner::Any
+end
+Primitive{T,S,C}(data::D, validity, bitoffset, owner) where {T,S,C,D<:AbstractVector{S}} =
+    Primitive{T,S,C,D}(data, validity, bitoffset, owner)
+
+Base.size(v::Primitive) = size(v.data)
+
+Base.@propagate_inbounds function Base.getindex(v::Primitive{T,S,C}, i::Int) where {T,S,C}
+    @boundscheck checkbounds(v, i)
+    x = GC.@preserve v @inbounds(v.data[i])
+    if Missing <: T
+        null = GC.@preserve v _isnullslot(v.validity, v.bitoffset, i)
+        null && return missing
+    end
+    return _fromstorage(C, x)
+end
+
+function _primitive(
+    ::Type{T},
+    ::Type{S},
+    ::Type{C},
+    d::AC.ArrayData,
+    budget=nothing,
+) where {T,S,C}
+    data = _wrapbuffer(S, AC.rolebuffer(d, AC.DATA), d.offset, d.len, budget)
+    validity, bitoffset = _validitybits(d)
+    return Primitive{T,S,C}(data, validity, bitoffset, d)
+end
+
+# One pass over the buffer, and its validity bitmap where some slot is null:
+# the stored values are the values.
+function Base.copyto!(
+    dest::Vector{T},
+    doffs::Integer,
+    src::Primitive{T,S,Nothing},
+    soffs::Integer,
+    n::Integer,
+) where {T,S}
+    n == 0 && return dest
+    (
+        n > 0 &&
+        checkbounds(Bool, dest, doffs:(doffs + n - 1)) &&
+        checkbounds(Bool, src, soffs:(soffs + n - 1))
+    ) || throw(BoundsError(dest, doffs:(doffs + n - 1)))
+    GC.@preserve src begin
+        data, bits, off = src.data, src.validity, src.bitoffset
+        if isempty(bits)
+            copyto!(dest, doffs, data, soffs, n)
+        else
+            # Validity is present only when some slot is null, so `T` has `Missing`.
+            @inbounds for i = 0:(n - 1)
+                dest[doffs + i] = _bitset(bits, off, soffs + i) ? data[soffs + i] : missing
+            end
+        end
+    end
+    return dest
+end
+
+Base.copy(v::Primitive{T,S,Nothing}) where {T,S} =
+    copyto!(Vector{T}(undef, length(v)), 1, v, 1, length(v))
+
+# Base's generic `map`, `filter`, and `collect` do not vectorize through the
+# per-access preserve. A view whose values are its stored layout (no nulls
+# can occur in a non-`Missing` element type) runs them on its buffer.
+Base.map(f, v::Primitive{T,T,Nothing}) where {T} = GC.@preserve v map(f, v.data)
+Base.filter(f, v::Primitive{T,T,Nothing}) where {T} = GC.@preserve v filter(f, v.data)
+Base.collect(v::Primitive{T,T,Nothing}) where {T} = GC.@preserve v copy(v.data)
+
+# Reductions over a view with no nulls run on its buffer, so they vectorize
+# as they do over a `Vector`.
+const _BufferPrimitive = Primitive{T,S,Nothing} where {T,S}
+function Base.mapreduce(f, op, A::_BufferPrimitive; kw...)
+    isempty(A.validity) && return GC.@preserve A mapreduce(f, op, A.data; kw...)
+    return invoke(mapreduce, Tuple{Any,Any,AbstractArray}, f, op, A; kw...)
+end
+function Base.mapreduce(f, op, itr::Base.SkipMissing{<:_BufferPrimitive})
+    A = itr.x
+    isempty(A.validity) && return GC.@preserve A mapreduce(f, op, A.data)
+    _maskablesum(f, op, A) && return GC.@preserve A _maskedsum(A)
+    return invoke(mapreduce, Tuple{Any,Any,Base.SkipMissing{<:AbstractArray}}, f, op, itr)
+end
+function Base.mapreduce(
+    f,
+    op,
+    itr::Base.SkipMissing{<:ChainedVector{T,<:_BufferPrimitive}},
+) where {T}
+    chunks = itr.x.arrays
+    if !isempty(chunks) &&
+       (all(c -> isempty(c.validity), chunks) || all(c -> _maskablesum(f, op, c), chunks))
+        return reduce(op, (mapreduce(f, op, skipmissing(c)) for c in chunks))
+    end
+    return invoke(mapreduce, Tuple{Any,Any,Base.SkipMissing{<:AbstractArray}}, f, op, itr)
+end
+
+# `sum(skipmissing(col))` over numbers with nulls: a branch-free pairwise sum
+# in which null slots add the neutral element (`-0.0` keeps the sign of an
+# all-`-0.0` float sum).
+_maskablesum(f, op, ::Primitive) = false
+_maskablesum(
+    ::typeof(identity),
+    ::Union{typeof(+),typeof(Base.add_sum)},
+    ::Primitive{T,<:Union{Base.BitInteger,Base.IEEEFloat},Nothing},
+) where {T} = true
+
+function _maskedsum(A::Primitive{T,S}) where {T,S}
+    R = typeof(Base.add_sum(zero(S), zero(S)))
+    neutral = S <: AbstractFloat ? -zero(R) : zero(R)
+    isempty(A.data) && return neutral
+    return _maskedsum(A.data, A.validity, A.bitoffset, 1, length(A.data), neutral)
+end
+function _maskedsum(
+    data::AbstractVector,
+    bits::Vector{UInt8},
+    off::Int,
+    lo::Int,
+    hi::Int,
+    neutral::R,
+) where {R}
+    if hi - lo < 1024
+        s = neutral
+        @inbounds @simd for i = lo:hi
+            k = off + i - 1
+            valid = (bits[(k >> 3) + 1] >> (k & 7)) & 0x01 == 0x01
+            s += ifelse(valid, R(data[i]), neutral)
+        end
+        return s
+    end
+    mid = (lo + hi) >>> 1
+    return _maskedsum(data, bits, off, lo, mid, neutral) +
+           _maskedsum(data, bits, off, mid + 1, hi, neutral)
+end
+
+# --- booleans ---------------------------------------------------------------------
+
+"""
+    Arrow.BoolVector{T} <: Arrow.ArrowVector{T}
+
+A boolean column read from its bit-packed values and validity bitmaps.
+"""
+struct BoolVector{T} <: ArrowVector{T}
+    values::Vector{UInt8}
+    valueoffset::Int
+    validity::Vector{UInt8}
+    bitoffset::Int
+    len::Int
+    owner::Any
+end
+
+Base.size(v::BoolVector) = (v.len,)
+
+Base.@propagate_inbounds function Base.getindex(v::BoolVector{T}, i::Int) where {T}
+    @boundscheck checkbounds(v, i)
+    if Missing <: T
+        null = GC.@preserve v _isnullslot(v.validity, v.bitoffset, i)
+        null && return missing
+    end
+    return GC.@preserve v _bitset(v.values, v.valueoffset, i)
+end
+
+function _boolvector(::Type{T}, d::AC.ArrayData) where {T}
+    validity, bitoffset = _validitybits(d)
+    d.len == 0 && return BoolVector{T}(UInt8[], 0, validity, bitoffset, 0, d)
+    first = d.offset >> 3
+    nbytes = ((d.offset + d.len - 1) >> 3) - first + 1
+    values = _wrapbuffer(UInt8, AC.rolebuffer(d, AC.DATA), first, nbytes)
+    return BoolVector{T}(values, Int(d.offset & 7), validity, bitoffset, Int(d.len), d)
+end
+
+# Non-null counts come from the validity bitmap.
+Base.count(
+    ::ComposedFunction{typeof(!),typeof(ismissing)},
+    A::Union{Primitive,BoolVector},
+) = length(A) - _nullslots(A)
+function _nullslots(A::Union{Primitive,BoolVector})
+    n = length(A)
+    (isempty(A.validity) || n == 0) && return 0
+    bits, off = A.validity, A.bitoffset
+    stop = off + n - 1
+    last = stop >> 3 + 1
+    valid = 0
+    GC.@preserve A begin
+        @inbounds @simd for k = 1:last
+            valid += count_ones(bits[k])
+        end
+        # Drop the bits before slot 1 and after slot n.
+        valid -= count_ones(bits[1] & ~(0xff << off))
+        valid -= count_ones(bits[last] & ~(0xff >> (7 - (stop & 7))))
+    end
+    return n - valid
+end
+
+# --- run-end encoding -------------------------------------------------------------
+
+"""
+    Arrow.RunEndEncoded{T,V} <: Arrow.ArrowVector{T}
+
+A run-end encoded column: element `i` is the value of the run that covers
+it, found by binary search over the run ends.
+"""
+struct RunEndEncoded{T,V<:AbstractVector} <: ArrowVector{T}
+    runends::Vector{Int64}
+    values::V
+    offset::Int
+    len::Int
+end
+
+Base.size(v::RunEndEncoded) = (v.len,)
+
+Base.@propagate_inbounds function Base.getindex(v::RunEndEncoded{T}, i::Int) where {T}
+    @boundscheck checkbounds(v, i)
+    # Validation proved the run ends ascending and covering every slot.
+    run = searchsortedfirst(v.runends, v.offset + i)
+    return @inbounds(v.values[run])::T
+end
+
+# --- dictionary encoding ----------------------------------------------------------
+
+"""
+    Arrow.DictEncoded{T} <: Arrow.ArrowVector{T}
+
+A dictionary-encoded column: each row is an index into a pool of values.
+`DataAPI.refarray`, `DataAPI.refpool`, and `DataAPI.levels` (in dictionary order)
+expose the encoding without decoding it, and `copy` returns a `PooledArray`. With
+CategoricalArrays loaded, `isordered` tells whether the dictionary is ordered.
+"""
+struct DictEncoded{T,R,P<:AbstractVector,I<:AbstractVector} <: ArrowVector{T}
+    indices::I
+    pool::P
+    ordered::Bool
+end
+
+Base.size(v::DictEncoded) = size(v.indices)
+
+Base.@propagate_inbounds function Base.getindex(v::DictEncoded{T}, i::Int) where {T}
+    @boundscheck checkbounds(v, i)
+    code = @inbounds v.indices[i]
+    code === missing && return missing
+    # Validation proved every valid index in [0, length(pool)).
+    return @inbounds(v.pool[Int(code) + 1])::T
+end
+
+"""
+The `DataAPI.refarray` of a dictionary column: the one-based pool position
+of each value, with 0 for a null slot.
+"""
+struct DictRefs{R,I<:AbstractVector} <: AbstractVector{R}
+    indices::I
+end
+Base.size(v::DictRefs) = size(v.indices)
+Base.IndexStyle(::Type{<:DictRefs}) = IndexLinear()
+Base.@propagate_inbounds function Base.getindex(v::DictRefs{R}, i::Int) where {R}
+    code = v.indices[i]
+    return code === missing ? zero(R) : R(code) + one(R)
+end
+
+"""
+The `DataAPI.refpool` of a dictionary column whose codes can be null: index
+0 holds `missing`, then the pool values in order.
+"""
+struct DictRefPool{T,P<:AbstractVector} <: AbstractVector{T}
+    pool::P
+end
+Base.size(v::DictRefPool) = (length(v.pool) + 1,)
+Base.axes(v::DictRefPool) = (Base.IdentityUnitRange(0:length(v.pool)),)
+Base.IndexStyle(::Type{<:DictRefPool}) = IndexLinear()
+Base.@propagate_inbounds Base.getindex(v::DictRefPool{T}, i::Int) where {T} =
+    i == 0 ? missing : convert(T, v.pool[i])
+
+# Codes widen by one step so `code + 1` never overflows.
+_reftype(::Type{R}) where {R<:Union{Int8,UInt8,Int16,UInt16}} = Int32
+_reftype(::Type{R}) where {R<:Union{Int32,UInt32,Int64,UInt64}} = Int64
+
+DataAPI.refarray(v::DictEncoded{T,R}) where {T,R} =
+    DictRefs{_reftype(R),typeof(v.indices)}(v.indices)
+DataAPI.refpool(v::DictEncoded{T}) where {T} =
+    Missing <: T ? DictRefPool{T,typeof(v.pool)}(v.pool) : v.pool
+DataAPI.levels(v::DictEncoded) = unique(skipmissing(v.pool))
+
+# Chunks that share one pool keep a column-wide encoding.
+_sharedpool(x::ChainedVector{T,<:DictEncoded}) where {T} =
+    all(c -> c.pool === x.arrays[1].pool, x.arrays)
+# Categories in dictionary order, as one batch's are: those of later batches'
+# dictionaries (deltas, replacements) follow the first's.
+function DataAPI.levels(x::ChainedVector{T,<:DictEncoded}) where {T}
+    isempty(x.arrays) && return Base.nonmissingtype(T)[]
+    _sharedpool(x) && return DataAPI.levels(x.arrays[1])
+    return unique!(reduce(vcat, [DataAPI.levels(c) for c in x.arrays]))
+end
+DataAPI.refarray(x::ChainedVector{T,<:DictEncoded}) where {T} =
+    isempty(x.arrays) || !_sharedpool(x) ? x :
+    ChainedVector([DataAPI.refarray(c) for c in x.arrays])
+DataAPI.refpool(x::ChainedVector{T,<:DictEncoded}) where {T} =
+    isempty(x.arrays) || !_sharedpool(x) ? nothing : DataAPI.refpool(x.arrays[1])
+
+Base.copy(v::DictEncoded{T}) where {T} = _pooledcopy(T, (v,))
+# The batches of a column copy into one `PooledArray`, whether they share a
+# pool, extend it (delta dictionaries), or replace it.
+Base.copy(c::ChainedVector{T,<:DictEncoded}) where {T} = _pooledcopy(T, c.arrays)
+# Rows of a dictionary column, as of a `PooledArray`, keep the encoding: any
+# vector of integer indices or a `Bool` mask.
+function Base.getindex(v::DictEncoded{T}, rows::AbstractVector{<:Integer}) where {T}
+    @boundscheck checkbounds(v, rows)
+    return _pooledcopy(T, (v,), to_indices(v, (rows,))[1])
+end
+Base.getindex(c::ChainedVector{<:Any,<:DictEncoded}, rows::AbstractVector{<:Integer}) =
+    _dictrows(c, rows)
+# As specific as SentinelArrays' methods for these index vectors, so not ambiguous.
+Base.getindex(c::ChainedVector{<:Any,<:DictEncoded}, rows::AbstractVector{Int}) =
+    _dictrows(c, rows)
+Base.getindex(c::ChainedVector{<:Any,<:DictEncoded}, rows::UnitRange{Int}) =
+    _dictrows(c, rows)
+Base.getindex(
+    c::ChainedVector{<:Any,<:DictEncoded},
+    rows::AbstractVector{<:ChainedVectorIndex},
+) = _dictrows(c, Int[Int(i) for i in rows])
+function _dictrows(c::ChainedVector{T}, rows) where {T}
+    checkbounds(c, rows)
+    return _pooledcopy(T, c.arrays, to_indices(c, (rows,))[1])
+end
+
+"""
+Rows `rows` (all of them by default) of the dictionary column whose batches
+are `chunks`, as a `PooledArray`. A batch's pool joins the result's when its
+first row is copied (a copy of a column with no rows takes its batch's
+pool): its distinct values, in pool order; duplicate and null entries remap,
+so the PooledArray's invariants hold.
+"""
+function _pooledcopy(::Type{T}, chunks, rows=nothing) where {T}
+    R = _ownedtype(T)
+    invpool = Dict{R,UInt32}()
+    pool = R[]
+    ref(value) = get!(invpool, value) do
+        push!(pool, value)
+        UInt32(length(pool))
+    end
+    remaps = IdDict{Any,Vector{UInt32}}()
+    remapof(v) = get!(() -> UInt32[ref(_ownedpoolvalue(x)) for x in v.pool], remaps, v.pool)
+    ends = cumsum(Int[length(v) for v in chunks])
+    n = rows === nothing ? (isempty(ends) ? 0 : ends[end]) : length(rows)
+    refs = Vector{UInt32}(undef, n)
+    c = 1
+    remap = UInt32[]
+    lastpool = nothing
+    for (k, i) in enumerate(rows === nothing ? (1:n) : rows)
+        # Ascending rows advance through the batches; others search.
+        if !(c <= length(ends) && (c == 1 ? 0 : ends[c - 1]) < i <= ends[c])
+            c = searchsortedfirst(ends, i)
+        end
+        v = chunks[c]
+        if v.pool !== lastpool
+            remap = remapof(v)
+            lastpool = v.pool
+        end
+        code = @inbounds v.indices[i - (c == 1 ? 0 : ends[c - 1])]
+        refs[k] = code === missing ? ref(missing) : @inbounds remap[Int(code) + 1]
+    end
+    # A copy of an empty batch keeps its pool (a chained column has none empty).
+    rows === nothing && n == 0 && foreach(remapof, chunks)
+    return PooledArrays.PooledArray(PooledArrays.RefArray(refs), invpool, pool)
+end
+
+# --- strings and binary -----------------------------------------------------------
+
+const _StringPayload = DataStrings.StringPayload
+
+# Byte runs at most this long fit DataStrings' Int32 view words.
+const _MAX_VIEW_BUFFER = Int64(typemax(Int32))
+
+# Rows per chunk when a string column builds on several tasks.
+const _STRING_CHUNK_ROWS = 1 << 16
+
+_isstringlayout(t::AC.ArrowType) =
+    t isa Union{AC.Utf8Type,AC.BinaryType,AC.ViewType} || _widebinary(t)
+
+"""
+Rows `first:last` of string batch `d`, whose output slots follow index `at`.
+An offsets layout (`utf8`/`binary`, normal or large) copies the rows' bytes
+into data buffer `buf` (0-based), where byte `a` of the batch's data buffer
+sits at position `a - lo`. For a view layout `buf` is the batch's first data
+buffer, and a chunk with `variadic > 0` copies that buffer of the batch
+instead of encoding rows.
+"""
+struct _StringChunk
+    d::AC.ArrayData
+    at::Int
+    first::Int
+    last::Int
+    buf::Int
+    lo::Int64
+    variadic::Int
+    copybytes::Bool   # false: buffer `buf` already holds the batch's bytes (`_adoptbytes`)
+end
+
+"""
+A string or binary column under construction: the payloads and data buffers
+of a `StringVector`/`BytesVector` of type `V`, or the values of a
+`Vector{String}` (`V === String`). `_stringbuild` plans and charges it,
+`_allocate!` allocates it; its chunks are independent, so several tasks can
+fill them (`_buildchunk!`); `_finishbuild` returns the column.
+"""
+mutable struct _StringBuild{V,O}
+    n::Int                           # values
+    out::O                           # payloads or values, `n` long once allocated
+    buffers::Vector{Vector{UInt8}}   # data buffers: kept bytes, or copies once allocated
+    sizes::Vector{Int64}             # the bytes `_allocate!` gives buffer k (-1: kept)
+    bases::Vector{Int64}             # where a kept buffer's batch bytes start in it
+    chunks::Vector{_StringChunk}
+end
+
+function _allocate!(b::_StringBuild{V,O}) where {V,O}
+    b.out = O(undef, b.n)
+    for (k, len) in enumerate(b.sizes)
+        len >= 0 && (b.buffers[k] = Vector{UInt8}(undef, Int(len)))
+    end
+    return b
+end
+
+# Call `f` with the `n + 1` offsets of offsets-layout batch `d`. A fixed-size
+# binary batch's value `i` starts `(offset + i - 1) * width` bytes into its
+# data buffer.
+function _withoffsets(f, d::AC.ArrayData, budget=nothing)
+    t = d.type
+    n = Int64(d.len)
+    if t isa AC.FixedSizeBinaryType
+        w = Int64(t.nbytes)
+        o = Int64(d.offset)
+        return f((o * w):w:((o + n) * w))
+    end
+    offs = AC.rolebuffer(d, AC.OFFSETS)
+    return t.large ? f(_wrapbuffer(Int64, offs, d.offset, n + 1, budget)) :
+           f(_wrapbuffer(Int32, offs, d.offset, n + 1, budget))
+end
+
+function _rowchunks!(
+    chunks,
+    d,
+    at::Int,
+    first::Int,
+    last::Int,
+    buf::Int,
+    lo::Int64,
+    rows::Int,
+    copybytes::Bool=true,
+)
+    a = first
+    while a <= last
+        b = last - a >= rows ? a + rows - 1 : last
+        push!(chunks, _StringChunk(d, at, a, b, buf, lo, 0, copybytes))
+        a = b + 1
+    end
+    return chunks
+end
+
+# The bytes behind slice `b` that a column can reference instead of copying,
+# and where `b` starts in them: the decompressed buffer this read owns, or,
+# with `source`, the source's own bytes (a mapped file, a byte vector, a
+# fetched range) while `b` starts within the Int32 offsets a DataStrings view
+# addresses. A `DataString` holds its buffer, so a value taken from such a
+# column keeps the source bytes alive; `String(x)` copies it out.
+function _adoptbytes(b::AC.BufferSlice, source::Bool)
+    r = b.region
+    r === nothing && return nothing
+    root = r.root
+    root isa _Decompressed && b.offset == 0 && return root.bytes, Int64(0)
+    source || return nothing
+    # From Julia 1.11 a byte vector's region roots its `Memory`; the column
+    # gets a vector of its own over that memory.
+    @static if VERSION >= v"1.11"
+        if root isa Memory{UInt8}
+            base = Int64(r.ptr - pointer(root)) + b.offset
+            base <= _MAX_VIEW_BUFFER || return nothing
+            return Base.wrap(Array, root, length(root)), base
+        end
+    end
+    root isa Vector{UInt8} && b.offset <= _MAX_VIEW_BUFFER && return root, b.offset
+    return nothing
+end
+
+# Cut offsets batch `d` into runs of rows whose bytes span at most 2 GiB, one
+# data buffer each, and the runs into chunks.
+function _offsetruns!(
+    chunks,
+    buffers,
+    sizes,
+    bases,
+    d,
+    offsets::AbstractVector{O},
+    at::Int,
+    budget,
+    rows::Int,
+    source::Bool,
+) where {O}
+    n = Int(d.len)
+    # Bytes the column can reference in place need no copy.
+    adopted = _adoptbytes(AC.rolebuffer(d, AC.DATA), source)
+    if adopted !== nothing
+        own, base = adopted
+        if base + Int64(offsets[n + 1]) <= _MAX_VIEW_BUFFER
+            push!(buffers, own)
+            push!(sizes, -1)
+            push!(bases, base)
+            return _rowchunks!(chunks, d, at, 1, n, length(buffers) - 1, -base, rows, false)
+        end
+    end
+    i = 1
+    while i <= n
+        lo = Int64(offsets[i])
+        j = i
+        if Int64(offsets[n + 1]) - lo <= _MAX_VIEW_BUFFER
+            j = n + 1
+        else
+            while j <= n && Int64(offsets[j + 1]) - lo <= _MAX_VIEW_BUFFER
+                j += 1
+            end
+        end
+        j == i && throw(
+            ArgumentError(
+                "a string longer than 2 GiB does not fit a DataString; " *
+                "read the column with stringtype=String",
+            ),
+        )
+        hi = Int64(offsets[j])
+        _chargeexact!(budget, UInt8, hi - lo, "string column data")
+        push!(buffers, UInt8[])
+        push!(sizes, hi - lo)
+        push!(bases, 0)
+        _rowchunks!(chunks, d, at, i, j - 1, length(buffers) - 1, lo, rows)
+        i = j
+    end
+    return chunks
+end
+
+# The bytes the values of string batch `d` reference: its data span, or its
+# variadic buffers.
+_stringbytes(d::AC.ArrayData) =
+    d.type isa AC.ViewType ?
+    sum(k -> d.buffers[k].len, 3:length(d.buffers); init=Int64(0)) :
+    d.len == 0 ? Int64(0) : _withoffsets(o -> Int64(o[end]) - Int64(o[1]), d)
+
+"""
+Plan the column of string or binary batches `datas` with element type `T`:
+charge its output and data buffers (`_allocate!` allocates them), and cut its
+rows into chunks of at most `rows`. A data buffer is the bytes the batch
+already has in memory, referenced in place (`_adoptbytes`; with `source`, the
+source's own bytes too), or else one copy of a run of the referenced bytes;
+a run stays under 2 GiB so view offsets fit DataStrings' Int32 words.
+"""
+function _stringbuild(
+    ::Type{T},
+    datas,
+    budget,
+    rows::Int=typemax(Int);
+    source::Bool=true,
+) where {T}
+    B = Base.nonmissingtype(T)
+    n = sum(d -> Int(d.len), datas; init=0)
+    chunks = _StringChunk[]
+    buffers = Vector{UInt8}[]
+    sizes = Int64[]
+    bases = Int64[]
+    at = 0
+    if B === String
+        _chargeexact!(budget, T, n, "string column")
+        bytes = Int64(0)
+        for d in datas
+            _rowchunks!(chunks, d, at, 1, Int(d.len), 0, Int64(0), rows)
+            bytes = AC.checked_add(bytes, _stringbytes(d))
+            at += Int(d.len)
+        end
+        # One String object per value: its bytes plus a header and rounding.
+        budget === nothing || _charge!(
+            budget,
+            AC.checked_add(AC.checked_mul(Int64(n), Int64(32)), bytes),
+            "string values",
+        )
+        return _StringBuild{String,Vector{T}}(n, T[], buffers, sizes, bases, chunks)
+    end
+    V =
+        B === DataStrings.DataString ? DataStrings.StringVector{T} :
+        DataStrings.BytesVector{T}
+    _chargeexact!(budget, _StringPayload, n, "string column payloads")
+    for d in datas
+        m = Int(d.len)
+        if d.type isa AC.ViewType
+            bufbase = length(buffers)   # the batch's buffer 3 is column buffer `bufbase`
+            for k = 3:length(d.buffers)
+                len = d.buffers[k].len
+                adopted = _adoptbytes(d.buffers[k], source)
+                if adopted !== nothing && adopted[2] + len <= _MAX_VIEW_BUFFER
+                    push!(buffers, adopted[1])
+                    push!(sizes, -1)
+                    push!(bases, adopted[2])
+                    continue
+                end
+                _chargeexact!(budget, UInt8, len, "string column data")
+                push!(buffers, UInt8[])
+                push!(sizes, len)
+                push!(bases, 0)
+                push!(chunks, _StringChunk(d, at, 1, 0, bufbase, Int64(0), k, true))
+            end
+            _rowchunks!(chunks, d, at, 1, m, bufbase, Int64(0), rows)
+        elseif m > 0
+            _withoffsets(
+                o -> _offsetruns!(
+                    chunks,
+                    buffers,
+                    sizes,
+                    bases,
+                    d,
+                    o,
+                    at,
+                    budget,
+                    rows,
+                    source,
+                ),
+                d,
+                budget,
+            )
+        end
+        at += m
+    end
+    return _StringBuild{V,Vector{_StringPayload}}(
+        n,
+        _StringPayload[],
+        buffers,
+        sizes,
+        bases,
+        chunks,
+    )
+end
+
+_finishbuild(b::_StringBuild{String}) = b.out
+_finishbuild(b::_StringBuild{V}) where {V} = V(b.out, b.buffers, Val(:trusted))
+
+"""
+A string or binary column of a whole-table read that builds when it is first
+taken from its table (`_force`): the read charges its allowance up front, and
+the payloads are built and the bytes copied on first access, on up to
+`ntasks` tasks. One task builds; tasks that ask meanwhile wait for it. The
+table hands out only the built column, so loops run over a `StringVector`
+(`BytesVector`, `Vector{String}`) as for an eager read.
+"""
+mutable struct _PendingStrings{T} <: AbstractVector{T}
+    const build::_StringBuild
+    const ntasks::Int
+    const lock::ReentrantLock
+    @atomic column::Union{Nothing,AbstractVector}
+end
+_PendingStrings{T}(b::_StringBuild, ntasks::Int) where {T} =
+    _PendingStrings{T}(b, ntasks, ReentrantLock(), nothing)
+
+Base.size(p::_PendingStrings) = (p.build.n,)
+Base.getindex(p::_PendingStrings, i::Int) = _force(p)[i]
+
+# A table column as it is handed out: a pending string column, built.
+_force(c::AbstractVector) = c isa _PendingStrings ? _forcestrings(c) : c
+function _forcestrings(p::_PendingStrings)
+    c = @atomic :acquire p.column
+    c === nothing || return c
+    return @lock p.lock begin
+        c = @atomic :acquire p.column
+        if c === nothing
+            b = _allocate!(p.build)
+            # `b`'s type is known at run time; see `_uninferred`.
+            build! = (k, _) -> (_buildchunk!(b, k); nothing)
+            _uninferred(_foreach, build!, length(b.chunks), p.ntasks)
+            c = _finishbuild(b)
+            @atomic :release p.column = c
+            # The chunks hold the batches' offsets, decompressed ones included.
+            empty!(b.chunks)
+        end
+        c
+    end
+end
+
+"Fill chunk `k` of a string column under construction."
+function _buildchunk!(
+    b::_StringBuild{V,Vector{_StringPayload}},
+    k::Int,
+) where {V<:AbstractVector}
+    c = b.chunks[k]
+    d = c.d
+    if d.type isa AC.ViewType
+        c.variadic > 0 &&
+            return _copyvariadic!(b.buffers[c.buf + c.variadic - 2], d, c.variadic)
+        return _viewrows!(b.out, d, c, b.bases)
+    end
+    buf = b.buffers[c.buf + 1]
+    return _withoffsets(o -> _offsetrows!(b.out, buf, d, o, c), d)
+end
+function _buildchunk!(b::_StringBuild{String}, k::Int)
+    c = b.chunks[k]
+    d = c.d
+    d.type isa AC.ViewType && return _viewstrings!(b.out, d, c)
+    return _withoffsets(o -> _offsetstrings!(b.out, d, o, c), d)
+end
+
+function _copyvariadic!(dst::Vector{UInt8}, d::AC.ArrayData, k::Int)
+    src = d.buffers[k]
+    GC.@preserve dst d unsafe_copyto!(pointer(dst), AC.sliceptr(src), length(dst))
+    return nothing
+end
+
+# Copy a chunk's bytes into its data buffer and encode its payloads.
+function _offsetrows!(
+    payloads,
+    buf::Vector{UInt8},
+    d::AC.ArrayData,
+    offsets::AbstractVector{O},
+    c,
+) where {O}
+    a = Int64(offsets[c.first])
+    z = Int64(offsets[c.last + 1])
+    # The chunk reads each of these bytes once (see `_willneed`).
+    GC.@preserve d offsets begin
+        z > a && _willneed(AC.sliceptr(AC.rolebuffer(d, AC.DATA)) + a, Int(z - a))
+        offsets isa Vector && _willneed(
+            Ptr{UInt8}(pointer(offsets, c.first)),
+            (c.last - c.first + 2) * sizeof(O),
+        )
+    end
+    if c.copybytes && z > a
+        src = AC.subslice(AC.rolebuffer(d, AC.DATA), a, z - a)
+        GC.@preserve buf d unsafe_copyto!(
+            pointer(buf, Int(a - c.lo) + 1),
+            AC.sliceptr(src),
+            Int(z - a),
+        )
+    end
+    validity, bitoffset = _validitybits(d)
+    GC.@preserve d _encodepayloads!(
+        payloads,
+        c.at,
+        buf,
+        offsets,
+        c.lo,
+        c.first,
+        c.last,
+        Int(z - c.lo),
+        validity,
+        bitoffset,
+        c.buf,
+    )
+    return nothing
+end
+
+@inline _load8(p::Ptr{UInt8}, i::Int) = ltoh(unsafe_load(Ptr{UInt64}(p + i)))
+
+# The payload of the `len` bytes at `p + start`, which may read 12 bytes from
+# `start` on: the length and up to four content bytes, then either the next
+# eight content bytes (inline, zero-padded) or the buffer index and offset.
+@inline function _payload(p::Ptr{UInt8}, start::Int, len::UInt64, viewword::UInt64)
+    w0 = _load8(p, start)
+    w1 = _load8(p, start + 4)
+    n4 = min(len, UInt64(4))
+    a = (len % UInt32) | ((w0 & ((UInt64(1) << (8 * n4)) - UInt64(1))) << 32)
+    n8 = min(max(len, UInt64(4)) - UInt64(4), UInt64(8))
+    inline = n8 == 8 ? w1 : w1 & ((UInt64(1) << (8 * n8)) - UInt64(1))
+    view = viewword | (UInt64(start % UInt32) << 32)
+    return _StringPayload(a, len <= DataStrings.INLINE_MAX ? inline : view)
+end
+
+"""
+Encode rows `first:last` of an offsets-based string batch as payloads over
+`buf`, the copy of the batch's bytes from offset `lo` on, reading only its
+first `limit` bytes. Rows whose 12-byte window ends within `limit` encode
+branch-free; the rows after them (inline, since their bytes end by `limit`)
+byte by byte.
+"""
+function _encodepayloads!(
+    payloads::Vector{_StringPayload},
+    at::Int,
+    buf::Vector{UInt8},
+    offsets::AbstractVector{O},
+    lo::Int64,
+    first::Int,
+    last::Int,
+    limit::Int,
+    validity::Vector{UInt8},
+    bitoffset::Int,
+    bufidx::Int=0,
+) where {O}
+    viewword = UInt64(bufidx % UInt32)
+    # Offsets ascend, so the rows with a whole window form a prefix.
+    fast = last
+    while fast >= first && Int64(offsets[fast]) - lo > limit - 12
+        fast -= 1
+    end
+    GC.@preserve buf begin
+        p = pointer(buf)
+        if isempty(validity)
+            @inbounds for k = first:fast
+                o = Int64(offsets[k])
+                payloads[at + k] =
+                    _payload(p, Int(o - lo), (Int64(offsets[k + 1]) - o) % UInt64, viewword)
+            end
+        else
+            @inbounds for k = first:fast
+                o = Int64(offsets[k])
+                x = _payload(p, Int(o - lo), (Int64(offsets[k + 1]) - o) % UInt64, viewword)
+                payloads[at + k] =
+                    _bitset(validity, bitoffset, k) ? x : DataStrings.PAYLOAD_MISSING
+            end
+        end
+        @inbounds for k = (fast + 1):last
+            start = Int(Int64(offsets[k]) - lo)
+            len = Int(Int64(offsets[k + 1]) - Int64(offsets[k]))
+            x = DataStrings.inline_payload(buf, start + 1, len)
+            payloads[at + k] =
+                _isnullslot(validity, bitoffset, k) ? DataStrings.PAYLOAD_MISSING : x
+        end
+    end
+    return payloads
+end
+
+# Zero the bytes after an inline payload's content, as DataStrings requires.
+@inline function _canonicalinline(p::_StringPayload)
+    len = Int(DataStrings.payloadlength(p))
+    len > DataStrings.INLINE_MAX && return p
+    a = len >= 4 ? p.a : p.a & ((UInt64(1) << (32 + 8 * len)) - 1)
+    nb = max(len - 4, 0)
+    b = nb >= 8 ? p.b : p.b & ((UInt64(1) << (8 * nb)) - 1)
+    return _StringPayload(a, b)
+end
+
+# The rows of a `utf8_view`/`binary_view` chunk: the view entries copied as
+# payloads (the layouts are identical), re-pointed at the batch's buffers
+# within the column's list, and at where each buffer's bytes start (`bases`).
+function _viewrows!(
+    payloads::Vector{_StringPayload},
+    d::AC.ArrayData,
+    c::_StringChunk,
+    bases::Vector{Int64},
+)
+    views = _wrapbuffer(_StringPayload, AC.rolebuffer(d, AC.VIEWS), d.offset, Int64(d.len))
+    validity, bitoffset = _validitybits(d)
+    GC.@preserve d for k = c.first:c.last
+        if _isnullslot(validity, bitoffset, k)
+            payloads[c.at + k] = DataStrings.PAYLOAD_MISSING
+            continue
+        end
+        p = _canonicalinline(views[k])
+        if DataStrings.payloadlength(p) > DataStrings.INLINE_MAX
+            idx = DataStrings.payloadbufidx(p) + c.buf
+            off = Int64(DataStrings.payloadoffset(p)) + bases[idx + 1]
+            p = _StringPayload(p.a, UInt64(idx % UInt32) | (UInt64(off % UInt32) << 32))
+        end
+        payloads[c.at + k] = p
+    end
+    return nothing
+end
+
+const _StringColumn = Union{DataStrings.StringVector,DataStrings.BytesVector}
+
+"""
+The string column `V` of `payloads`, owning its bytes. A payload is inline,
+missing, or the length and first four bytes of a value whose bytes
+`bytes(i)` points at; those values' bytes are copied, in column order, into
+one data buffer (several, each under 2 GiB, for more bytes) that the
+payloads are re-pointed into.
+"""
+function _ownstrings(::Type{V}, payloads::Vector{_StringPayload}, bytes) where {V}
+    sizes = Int64[]
+    total = Int64(0)
+    for p in payloads
+        len = Int64(DataStrings.payloadlength(p))
+        len > DataStrings.INLINE_MAX || continue
+        if total + len > _MAX_VIEW_BUFFER
+            push!(sizes, total)
+            total = Int64(0)
+        end
+        total += len
+    end
+    push!(sizes, total)
+    data = Vector{UInt8}[Vector{UInt8}(undef, Int(size)) for size in sizes]
+    k = 1
+    pos = Int64(0)
+    @inbounds for i in eachindex(payloads)
+        p = payloads[i]
+        len = Int64(DataStrings.payloadlength(p))
+        len > DataStrings.INLINE_MAX || continue
+        if pos + len > sizes[k]
+            k += 1
+            pos = Int64(0)
+        end
+        dst = data[k]
+        GC.@preserve dst unsafe_copyto!(pointer(dst, Int(pos) + 1), bytes(i), Int(len))
+        payloads[i] =
+            _StringPayload(p.a, UInt64((k - 1) % UInt32) | (UInt64(pos % UInt32) << 32))
+        pos += len
+    end
+    return V(payloads, data, Val(:trusted))
+end
+
+# Where a view payload's bytes start in string column `v`.
+_viewptr(v::_StringColumn, p::_StringPayload) =
+    pointer(v.buffers[DataStrings.payloadbufidx(p) + 1], DataStrings.payloadpos(p))
+
+"""
+A copy of a string or binary column that owns its bytes: the same values over
+data buffers holding just the bytes they reference. A column read over a
+mapped file, a byte vector, or a fetched range references those bytes in
+place, so this is what detaches a copy from them.
+"""
+_compactstrings(v::_StringColumn) = _rowsof(v, eachindex(v))
+
+# Rows `rows` of a column. A string column's rows own just their bytes, so a
+# filtered read does not keep the rest of the batch's bytes alive.
+_rowsof(v::AbstractVector, rows) = v[rows]
+function _rowsof(v::V, rows) where {V<:_StringColumn}
+    payloads = v.payloads
+    return GC.@preserve v _ownstrings(
+        V,
+        payloads[rows],
+        i -> _viewptr(v, payloads[rows[i]]),
+    )
+end
+# A dictionary column's rows keep its pool.
+function _rowsof(v::DictEncoded{T,R,P}, rows) where {T,R,P}
+    indices = v.indices[rows]
+    return DictEncoded{T,R,P,typeof(indices)}(indices, v.pool, v.ordered)
+end
+
+# The payload of the `len` bytes at `p`: inline when they fit, else their
+# length and first four bytes (`_ownstrings` adds where they are stored).
+@inline function _rowpayload(p::Ptr{UInt8}, len::Int)
+    a = UInt64(len % UInt32)
+    len > DataStrings.INLINE_MAX &&
+        return _StringPayload(a | (UInt64(ltoh(unsafe_load(Ptr{UInt32}(p)))) << 32), 0)
+    b = zero(UInt64)
+    for i = 1:min(len, 4)
+        a |= UInt64(unsafe_load(p, i)) << (32 + 8 * (i - 1))
+    end
+    for i = 5:len
+        b |= UInt64(unsafe_load(p, i)) << (8 * (i - 5))
+    end
+    return _StringPayload(a, b)
+end
+
+"""
+Rows `rows` of string or binary batch `d` as a column of element type `T`
+that owns its bytes: a `StringVector` or `BytesVector` whose data buffer
+holds just those values' bytes, or `String`s.
+"""
+function _rowsof(::Type{T}, d::AC.ArrayData, rows) where {T}
+    validity, bitoffset = _validitybits(d)
+    isnull(i) = _isnullslot(validity, bitoffset, i)
+    if d.type isa AC.ViewType
+        views =
+            _wrapbuffer(_StringPayload, AC.rolebuffer(d, AC.VIEWS), d.offset, Int64(d.len))
+        viewvalue(i) =
+            let p = views[i], len = Int(DataStrings.payloadlength(p))
+                len <= DataStrings.INLINE_MAX &&
+                    return Ptr{UInt8}(pointer(views, i)) + 4, len
+                data = d.buffers[DataStrings.payloadbufidx(p) + 3]
+                return AC.sliceptr(AC.subslice(data, DataStrings.payloadoffset(p), len)),
+                len
+            end
+        return GC.@preserve d views _gatherstrings(T, rows, isnull, viewvalue)
+    end
+    return _withoffsets(d) do offsets
+        base = AC.sliceptr(AC.rolebuffer(d, AC.DATA))
+        function offsetvalue(i)
+            o = Int64(offsets[i])
+            len = Int64(offsets[i + 1]) - o
+            len <= _MAX_VIEW_BUFFER || throw(
+                ArgumentError(
+                    "a string longer than 2 GiB does not fit a DataString; " *
+                    "read the column with stringtype=String",
+                ),
+            )
+            return base + o, Int(len)
+        end
+        return GC.@preserve d _gatherstrings(T, rows, isnull, offsetvalue)
+    end
+end
+
+# The values `value(i)` (a pointer and a length) of rows `rows`, or `missing`
+# where `isnull(i)`, as an owned column of element type `T`.
+function _gatherstrings(::Type{T}, rows, isnull, value) where {T}
+    B = Base.nonmissingtype(T)
+    if B === String
+        out = Vector{T}(undef, length(rows))
+        for (k, i) in enumerate(rows)
+            out[k] = isnull(i) ? missing : unsafe_string(value(i)...)
+        end
+        return out
+    end
+    V =
+        B === DataStrings.DataString ? DataStrings.StringVector{T} :
+        DataStrings.BytesVector{T}
+    payloads = Vector{_StringPayload}(undef, length(rows))
+    for (k, i) in enumerate(rows)
+        payloads[k] = isnull(i) ? DataStrings.PAYLOAD_MISSING : _rowpayload(value(i)...)
+    end
+    return _ownstrings(V, payloads, k -> first(value(rows[k])))
+end
+
+# The string columns `parts`, one per batch, joined into one of element type
+# `T` over all their buffers: a part's view payloads re-point into the joined
+# buffer list.
+function _joinstrings(::Type{T}, parts) where {T}
+    V =
+        Base.nonmissingtype(T) === DataStrings.DataString ? DataStrings.StringVector{T} :
+        DataStrings.BytesVector{T}
+    buffers = Vector{UInt8}[]
+    out = Vector{_StringPayload}(undef, sum(length, parts; init=0))
+    at = 0
+    for part in parts
+        base = length(buffers)
+        append!(buffers, part.buffers)
+        _repoint!(out, at, part.payloads, base)
+        at += length(part)
+    end
+    return V(out, buffers, Val(:trusted))
+end
+
+# Copy `payloads` into `out` after index `at`, view payloads re-pointed `base`
+# buffers further into the joined buffer list.
+function _repoint!(out, at::Int, payloads::Vector{_StringPayload}, base::Int)
+    @inbounds for i in eachindex(payloads)
+        p = payloads[i]
+        if base > 0 && DataStrings.payloadlength(p) > DataStrings.INLINE_MAX
+            p = _StringPayload(
+                p.a,
+                UInt64((DataStrings.payloadbufidx(p) + base) % UInt32) |
+                (p.b & 0xffffffff00000000),
+            )
+        end
+        out[at + i] = p
+    end
+    return out
+end
+
+# A dictionary pool value owning its bytes: a `DataString` or `DataBytes` view
+# into the pool column's buffer, which may be the source's bytes, gets its own.
+_ownedpoolvalue(x) = _ownedvalue(x)
+function _ownedpoolvalue(x::Union{DataStrings.DataString,DataStrings.DataBytes})
+    len = Int(DataStrings.payloadlength(x.p))
+    len <= DataStrings.INLINE_MAX && return x
+    data = Vector{UInt8}(undef, len)
+    GC.@preserve x data unsafe_copyto!(
+        pointer(data),
+        pointer(x.data, DataStrings.payloadpos(x.p)),
+        len,
+    )
+    return typeof(x)(_StringPayload(x.p.a, UInt64(0)), data)
+end
+
+# `String`s of an offsets-based chunk, read from the batch's data.
+function _offsetstrings!(
+    out,
+    d::AC.ArrayData,
+    offsets::AbstractVector{O},
+    c::_StringChunk,
+) where {O}
+    a = Int64(offsets[c.first])
+    z = Int64(offsets[c.last + 1])
+    src = AC.subslice(AC.rolebuffer(d, AC.DATA), a, z - a)
+    validity, bitoffset = _validitybits(d)
+    GC.@preserve d begin
+        p = AC.sliceptr(src) - a
+        for k = c.first:c.last
+            o = Int64(offsets[k])
+            out[c.at + k] =
+                _isnullslot(validity, bitoffset, k) ? missing :
+                unsafe_string(p + o, Int(Int64(offsets[k + 1]) - o))
+        end
+    end
+    return nothing
+end
+
+# `String`s of a view chunk: inline bytes from the payload, others from the
+# batch's variadic buffers.
+function _viewstrings!(out, d::AC.ArrayData, c::_StringChunk)
+    views = _wrapbuffer(_StringPayload, AC.rolebuffer(d, AC.VIEWS), d.offset, Int64(d.len))
+    validity, bitoffset = _validitybits(d)
+    scratch = Vector{UInt8}(undef, 16)
+    GC.@preserve d scratch for k = c.first:c.last
+        if _isnullslot(validity, bitoffset, k)
+            out[c.at + k] = missing
+            continue
+        end
+        p = views[k]
+        len = Int(DataStrings.payloadlength(p))
+        out[c.at + k] = if len <= DataStrings.INLINE_MAX
+            q = pointer(scratch)
+            unsafe_store!(Ptr{UInt64}(q), htol((p.a >> 32) | (p.b << 32)))
+            unsafe_store!(Ptr{UInt64}(q + 8), htol(p.b >> 32))
+            unsafe_string(q, len)
+        else
+            data = d.buffers[DataStrings.payloadbufidx(p) + 3]
+            unsafe_string(
+                AC.sliceptr(AC.subslice(data, DataStrings.payloadoffset(p), len)),
+                len,
+            )
+        end
+    end
+    return nothing
+end
+
+# --- multi-batch columns -----------------------------------------------------------
+
+# Broadcasting over a column of several batches runs batch by batch, each
+# over its own view (as fast as over a `Vector`), instead of locating the
+# batch of every element.
+struct _ChainedStyle <: Broadcast.AbstractArrayStyle{1} end
+_ChainedStyle(::Val{1}) = _ChainedStyle()
+_ChainedStyle(::Val{N}) where {N} = Broadcast.DefaultArrayStyle{N}()
+Base.BroadcastStyle(::Type{<:ChainedVector{<:Any,<:ArrowVector}}) = _ChainedStyle()
+Base.similar(::Broadcast.Broadcasted{_ChainedStyle}, ::Type{T}, dims) where {T} =
+    similar(Array{T}, dims)
+Base.similar(::Broadcast.Broadcasted{_ChainedStyle}, ::Type{Bool}, dims) =
+    similar(BitArray, dims)
+
+function Base.copyto!(dest::AbstractVector, bc::Broadcast.Broadcasted{_ChainedStyle})
+    axes(dest) == axes(bc) || Broadcast.throwdm(axes(dest), axes(bc))
+    c = _drivingchain(bc)
+    c === nothing && return copyto!(dest, convert(Broadcast.Broadcasted{Nothing}, bc))
+    for r in _batchranges(c)
+        part = Broadcast.instantiate(_batchargs(bc, r))
+        if dest isa BitVector
+            # Bits pack fastest into a BitVector of their own.
+            bits = copyto!(BitVector(undef, length(r)), part)
+            copyto!(dest, first(r), bits, 1, length(r))
+        else
+            copyto!(view(dest, r), part)
+        end
+    end
+    return dest
+end
+
+# Without a concrete element type, Base narrows the result to the values it
+# computes (`x .+ 1` over a nullable column with no nulls gives a
+# `Vector{Int}`): each batch narrows on its own, and the batches join under
+# the same widening (`promote_typejoin`).
+function Base.copy(bc::Broadcast.Broadcasted{_ChainedStyle})
+    c = _drivingchain(bc)
+    c === nothing && return copy(_elementwise(bc))
+    E = Broadcast.combine_eltypes(bc.f, bc.args)
+    isconcretetype(E) && return copyto!(similar(bc, E), bc)
+    ranges = _batchranges(c)
+    parts = [copy(Broadcast.instantiate(_batchargs(bc, r))) for r in ranges]
+    isempty(parts) && return copy(_elementwise(bc))
+    T = mapreduce(eltype, Base.promote_typejoin, parts)
+    dest = similar(bc, T)
+    for (r, part) in zip(ranges, parts)
+        copyto!(dest, first(r), part, 1, length(part))
+    end
+    return dest
+end
+
+_elementwise(bc::Broadcast.Broadcasted) =
+    Broadcast.Broadcasted{Broadcast.DefaultArrayStyle{1}}(bc.f, bc.args, bc.axes)
+
+# The column the broadcast is cut by (its first multi-batch view argument), or
+# `nothing` when some argument cannot be cut into rows (a tuple, an array of
+# other dimensions).
+_drivingchain(bc::Broadcast.Broadcasted) =
+    all(_cuttable, bc.args) ? _firstchain(bc) : nothing
+
+# The row ranges of `c`'s batches, empty batches left out.
+function _batchranges(c::ChainedVector)
+    ranges = UnitRange{Int}[]
+    lo = 1
+    for a in c.arrays
+        n = length(a)
+        n > 0 && push!(ranges, lo:(lo + n - 1))
+        lo += n
+    end
+    return ranges
+end
+
+# Arguments a broadcast can be cut into rows by: vectors, scalars, and
+# broadcasts of them (not tuples or other arrays).
+_cuttable(a::Broadcast.Broadcasted) = all(_cuttable, a.args)
+_cuttable(a::AbstractVector) = axes(a, 1) isa Base.OneTo
+_cuttable(a) = axes(a) == ()
+
+_firstchain(a::ChainedVector{<:Any,<:ArrowVector}) = a
+function _firstchain(a::Broadcast.Broadcasted)
+    for x in a.args
+        c = _firstchain(x)
+        c === nothing || return c
+    end
+    return nothing
+end
+_firstchain(a) = nothing
+
+# `bc` restricted to rows `r`: a column whose batch is exactly `r` gives that
+# batch, other vectors a view, and scalars and length-1 vectors stay whole.
+_batchargs(bc::Broadcast.Broadcasted, r) =
+    Broadcast.Broadcasted(bc.f, map(a -> _batcharg(a, r), bc.args))
+_batcharg(a::Broadcast.Broadcasted, r) = _batchargs(a, r)
+function _batcharg(a::ChainedVector{<:Any,<:ArrowVector}, r)
+    k = searchsortedfirst(a.inds, last(r))
+    k <= length(a.inds) &&
+        a.inds[k] == last(r) &&
+        (k == 1 ? 0 : a.inds[k - 1]) == first(r) - 1 &&
+        return a.arrays[k]
+    return view(a, r)
+end
+_batcharg(a::AbstractVector, r) = length(a) == 1 ? a : view(a, r)
+_batcharg(a, r) = a
+
+# --- column assembly --------------------------------------------------------------
+
+# Shared decimals read as `DataDecimals.Decimal{P,S,T}`, which has the storage
+# layout of every Arrow decimal width.
+_isbulkdecimal(f::AC.Field) = f.type isa AC.DecimalType && _shareddecimal(f.type)
+"One batch of a decimal column, read as stored."
+_decimalcolumn(f::AC.Field, d::AC.ArrayData, budget=nothing) =
+    _viewcolumn(f, AC.ArrayData[d], _ViewContext(DataStrings.DataString, budget))
+
+# One read's view settings, its allocation budget, and its cache of
+# dictionary pools (built once per pool snapshot; columns building on several
+# tasks share it under the lock).
+struct _ViewContext
+    stringtype::Type
+    budget::Union{Nothing,AllocationBudget}
+    pools::IdDict{AC.ArrayData,AbstractVector}
+    poolslock::ReentrantLock
+end
+_ViewContext(stringtype::Type=DataStrings.DataString, budget=nothing) =
+    _ViewContext(stringtype, budget, IdDict{AC.ArrayData,AbstractVector}(), ReentrantLock())
+# The same settings and pool cache under another allowance (`Arrow.Stream` batches).
+_ViewContext(ctx::_ViewContext, budget) =
+    _ViewContext(ctx.stringtype, budget, ctx.pools, ctx.poolslock)
+
+# The view column of a dictionary's values, built once per pool snapshot. The
+# build runs outside the lock; a concurrent duplicate is dropped.
+function _dictpool(ctx::_ViewContext, vf::AC.Field, dict::AC.ArrayData)
+    pool = @lock ctx.poolslock get(ctx.pools, dict, nothing)
+    pool === nothing || return pool
+    built = _viewcolumn(vf, AC.ArrayData[dict], ctx)
+    return @lock ctx.poolslock get!(ctx.pools, dict, built)
+end
+
+function _markpools!(live, data::AC.ArrayData, cached)
+    dict = data.dictionary
+    if dict !== nothing
+        haskey(cached, dict) && (live[dict] = nothing)
+        _markpools!(live, dict, cached)
+    end
+    foreach(child -> _markpools!(live, child, cached), data.children)
+    return nothing
+end
+
+# A stream reuses the pool columns of the dictionaries still in effect
+# (`dictionaries`), but only returned tables may keep older ones alive.
+function _prunepools!(ctx::_ViewContext, dictionaries, budget)
+    lock(ctx.poolslock) do
+        isempty(ctx.pools) && return nothing
+        _chargedict!(budget, AC.ArrayData, Nothing, length(ctx.pools), "live stream pools")
+        live = IdDict{AC.ArrayData,Nothing}()
+        for dictionary in dictionaries
+            haskey(ctx.pools, dictionary) && (live[dictionary] = nothing)
+            _markpools!(live, dictionary, ctx.pools)
+        end
+        filter!(entry -> haskey(live, first(entry)), ctx.pools)
+        return nothing
+    end
+    return nothing
+end
+
+# A view object's own size (struct, wrapped vector headers), charged per batch.
+const _VIEW_OBJECT_BYTES = Int64(256)
+
+function _checkstringtype(stringtype)
+    stringtype === DataStrings.DataString ||
+        stringtype === String ||
+        throw(ArgumentError("stringtype must be DataString or String, got $stringtype"))
+    return stringtype
+end
+
+"""
+Whether `f` reads through this file's columns: a flat layout (as a view) or
+a list, fixed-size list, map, struct, or union of such layouts (as typed
+rows). An ArrowTypes extension label keeps the materializing path unless it
+maps to no Julia type (see `_storagelabel`) or is a fixed-shape tensor. List
+views, structs with duplicate or more than 64 field names, and layouts
+nested more than 8 deep also keep the materializing path.
+"""
+function _viewable(f::AC.Field)
+    if _hasarrowtypesextension(f)
+        _tensorshape(f) === nothing || return true
+        _storagelabel(f) || return false
+    end
+    return _viewablelayout(f)
+end
+
+# Whether `f` carries an extension label that reads as its storage: a quiet
+# canonical label (`arrow.json`, `arrow.opaque`), or a label the facade does
+# not own and no ArrowTypes.jl `JuliaType` method names, which warns once
+# per process. Other labels, and labels below the top level, keep the
+# materializing path, which resolves ArrowTypes.jl hooks once per field.
+function _storagelabel(f::AC.Field)
+    ext = _arrowtypesextension(f)
+    ext === nothing && return false
+    any(_hasarrowtypesextension, f.children) && return false
+    name = first(ext)
+    _quietextension(name) && return true
+    _facadelabel(name) && return false
+    # A name that is not a Symbol yet cannot be registered; looking it up
+    # does not intern it.
+    sym = _existingjlsymbol(name)
+    sym === nothing || !_juliatypenames(sym) || return false
+    _warnunsupportedextension((warn=true, budget=nothing), name, f)
+    return true
+end
+
+# Whether an `ArrowTypes.JuliaType` method other than its catch-all
+# fallbacks can take `Val(sym)` as its first argument.
+_juliatypenames(sym::Symbol) = any(methods(ArrowTypes.JuliaType)) do m
+    sig = Base.unwrap_unionall(m.sig)
+    length(sig.parameters) >= 2 || return false
+    arg = Base.rewrap_unionall(sig.parameters[2], m.sig)
+    return arg !== Any && Val{sym} <: arg
+end
+
+_facadelabel(name::String) =
+    name in (_UUID_EXTENSION, "JuliaLang.Int128", "JuliaLang.UInt128", "arrow.bool8") ||
+    any(p -> last(p) == name, _FACADE_PERIOD_NAMES)
+function _viewablelayout(f::AC.Field, depth::Int=0)
+    t = f.type
+    t isa Union{
+        AC.IntType,
+        AC.FloatType,
+        AC.BoolType,
+        AC.DateType,
+        AC.TimeType,
+        AC.TimestampType,
+        AC.DurationType,
+        AC.IntervalType,
+        AC.FixedSizeBinaryType,
+        AC.Utf8Type,
+        AC.BinaryType,
+        AC.ViewType,
+        AC.NullType,
+    } && return true
+    t isa AC.DecimalType && return true
+    t isa AC.DictionaryType && return _viewablelayout(AC.dictvaluefield(f, t), depth)
+    t isa AC.RunEndEncodedType &&
+        return length(f.children) == 2 && _viewablelayout(f.children[2], depth)
+    # Row types nest one type per level, and Julia compiles deep ones slowly.
+    t isa _NestedLayout && depth == _MAX_ROW_DEPTH && return false
+    viewable(c) = _viewablelayout(c, depth + 1)
+    t isa Union{AC.ListType,AC.FixedSizeListType} &&
+        return length(f.children) == 1 && viewable(f.children[1])
+    # A list view gathers its rows' values, which it does for flat values.
+    t isa AC.ListViewType && return length(f.children) == 1 &&
+           !_nestedvalue(f.children[1]) &&
+           viewable(f.children[1])
+    if t isa AC.MapType
+        length(f.children) == 1 || return false
+        entries = f.children[1]
+        return entries.type isa AC.StructType &&
+               length(entries.children) == 2 &&
+               all(viewable, entries.children)
+    end
+    t isa AC.StructType && return length(f.children) <= _MAX_ROW_FIELDS &&
+           allunique(String[c.name for c in f.children]) &&
+           all(viewable, f.children)
+    t isa AC.UnionType && return !isempty(f.children) && all(viewable, f.children)
+    return false
+end
+
+# Fixed-size binary values wider than this read as `DataBytes`: code over
+# an `NTuple{N,UInt8}` compiles in time that grows faster than `N` (minutes
+# at 16 KiB), and a hostile schema can declare any width.
+const _MAX_TUPLE_BYTES = 256
+_widebinary(t::AC.ArrowType) = t isa AC.FixedSizeBinaryType && t.nbytes > _MAX_TUPLE_BYTES
+
+# The stored element type and storage conversion of a fixed-width layout.
+function _fixedstorage(t::AC.ArrowType)
+    t isa AC.IntType && return AC.juliatype(t), Nothing
+    t isa AC.FloatType && return AC.juliatype(t), Nothing
+    if t isa AC.DecimalType
+        _shareddecimal(t) && return _decimalhost(t), Nothing
+        # Other decimals read as stored: integers, or bytes at 128 and 256 bits.
+        t.bits <= 64 && return (t.bits == 32 ? Int32 : Int64), Nothing
+        return NTuple{t.bits ÷ 8,UInt8}, _StoredBytes
+    end
+    t isa AC.TimestampType && return _facadebasetype(t), Nothing
+    t isa AC.DurationType && return _facadebasetype(t), Nothing
+    t isa AC.FixedSizeBinaryType && return NTuple{t.nbytes,UInt8}, Nothing
+    t isa AC.DateType &&
+        return t.unit == AC.DAY ? (Int32, _DaysToDate) : (Int64, _MillisToDateTime)
+    if t isa AC.TimeType
+        S = t.bits == 32 ? Int32 : Int64
+        return S, _TimeOfDay{_NANOS_PER_DAY ÷ _timeticksperday(t.unit)}
+    end
+    if t isa AC.IntervalType
+        t.unit == AC.YEAR_MONTH && return Int32, _YearMonth
+        t.unit == AC.DAY_TIME && return NTuple{2,Int32}, _DayTime
+        return Durations.Duration, Nothing
+    end
+    throw(ArgumentError("no fixed-width storage for $(AC.descriptorname(t))"))
+end
+
+_timeticksperday(unit) =
+    unit == AC.SECOND ? Int64(86_400) :
+    unit == AC.MILLISECOND ? Int64(86_400_000) :
+    unit == AC.MICROSECOND ? Int64(86_400_000_000) : _NANOS_PER_DAY
+
+"""
+The public element type of a column, before nullability. Nested rows take
+their children's element types over `datas`, the batches being read, so a
+child whose data holds undeclared nulls widens the row type of every batch.
+"""
+function _viewbasetype(f::AC.Field, ctx::_ViewContext, datas=AC.ArrayData[])
+    t = f.type
+    t isa AC.NullType && return Missing
+    t isa AC.BoolType && return Bool
+    t isa Union{AC.Utf8Type,AC.ViewType} &&
+        (!(t isa AC.ViewType) || t.utf8) &&
+        return ctx.stringtype === String ? String : DataStrings.DataString
+    (t isa Union{AC.BinaryType,AC.ViewType} || _widebinary(t)) &&
+        return DataStrings.DataBytes
+    t isa AC.DictionaryType && return _viewbasetype(AC.dictvaluefield(f, t), ctx)
+    t isa AC.RunEndEncodedType && return _viewbasetype(f.children[2], ctx)
+    shape = _tensorshape(f)
+    shape === nothing || return _tensortype(f, ctx, datas, shape)
+    t isa _NestedLayout && return _rowtype(f, ctx, datas)
+    S, C = _fixedstorage(t)
+    return C === Nothing ? S : _storagetarget(C)
+end
+
+# Physical nulls the column's values can hold, through dictionary pools and
+# run-end values.
+function _viewnulls(f::AC.Field, d::AC.ArrayData)
+    t = f.type
+    t isa AC.NullType && return d.len > 0
+    if t isa AC.RunEndEncodedType
+        return _viewnulls(f.children[2], d.children[2])
+    end
+    if t isa AC.DictionaryType
+        AC.nullcount(d) > 0 && return true
+        dict = d.dictionary::AC.ArrayData
+        return _viewnulls(AC.dictvaluefield(f, t), dict)
+    end
+    return AC.nullcount(d) > 0
+end
+
+# The declared type decides `Missing` (`_declaredeltype` is the authority);
+# data that holds nulls a non-nullable declaration did not admit widens the
+# column, as on every other read path.
+function _vieweltype(f::AC.Field, datas, ctx::_ViewContext)
+    B = _viewbasetype(f, ctx, datas)
+    B === Missing && return Missing
+    # A union has no validity of its own: its children's types carry nulls.
+    f.type isa AC.UnionType && return B
+    nullable = Missing <: _declaredeltype(f, true) || any(d -> _viewnulls(f, d), datas)
+    return nullable ? Union{Missing,B} : B
+end
+
+function _checktimes(f::AC.Field, t::AC.TimeType, d::AC.ArrayData, budget)
+    perday = _timeticksperday(t.unit)
+    S = t.bits == 32 ? Int32 : Int64
+    col = _primitive(Union{Missing,S}, S, Nothing, d, budget)
+    for x in col
+        (x === missing || 0 <= x < perday) && continue
+        P = nameof(_unitperiod(t.unit))
+        throw(
+            ValidationError(
+                "column $(repr(f.name)): time-of-day value $x is outside [0, $perday) " *
+                "in its unit; read the column as durations since midnight with " *
+                "`scan=Tables.Scan(select=($(_uninferred(repr, Symbol(f.name))::String) " *
+                "=> Dates.$P,))`",
+            ),
+        )
+    end
+    return nothing
+end
+
+# The period of one tick of a time-of-day unit.
+_unitperiod(unit) =
+    unit == AC.SECOND ? Dates.Second :
+    unit == AC.MILLISECOND ? Dates.Millisecond :
+    unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
+
+# Time-of-day storage `raw` read as `P` periods since midnight: the scan
+# override that reads times a `Dates.Time` cannot hold.
+function _timeperiods(t::AC.TimeType, raw, ::Type{P}) where {P}
+    unit = _unitperiod(t.unit)
+    out = Vector{Missing<:eltype(raw) ? Union{Missing,P} : P}(undef, length(raw))
+    for i in eachindex(out, raw)
+        x = raw[i]
+        out[i] = x === missing ? missing : convert(P, unit(x))
+    end
+    return out
+end
+
+# One batch of a view column. Nested layouts skip `_batchview`, whose body
+# for every flat layout would otherwise compile once per row type.
+_viewbatch(T::Type, f::AC.Field, d::AC.ArrayData, ctx::_ViewContext) =
+    f.type isa _NestedLayout ? _nestedbatch(T, f, d, ctx) : _batchview(T, f, d, ctx)
+
+"""
+One batch of a fixed-width, boolean, dictionary, or run-end view column.
+`T` is only passed on, so this body compiles once, not once per element type
+(every time zone and decimal scale is a type of its own).
+"""
+function _batchview(T::Type, f::AC.Field, d::AC.ArrayData, ctx::_ViewContext)
+    t = f.type
+    budget = ctx.budget
+    _chargeobject!(budget, _VIEW_OBJECT_BYTES, "column view")
+    t isa AC.BoolType && return _boolvector(T, d)
+    t isa AC.DictionaryType && return _dictview(T, f, t, d, ctx)
+    t isa AC.RunEndEncodedType && return _runendview(T, f, d, ctx)
+    t isa AC.TimeType && _checktimes(f, t, d, budget)
+    S, C = _fixedstorage(t)
+    return _primitive(T, S, C, d, budget)
+end
+
+function _dictview(
+    ::Type{T},
+    f::AC.Field,
+    t::AC.DictionaryType,
+    d::AC.ArrayData,
+    ctx::_ViewContext,
+) where {T}
+    pool = _dictpool(ctx, AC.dictvaluefield(f, t), d.dictionary::AC.ArrayData)
+    R = AC.juliatype(t.indextype)
+    indices = _primitive(Missing <: T ? Union{Missing,R} : R, R, Nothing, d, ctx.budget)
+    return DictEncoded{T,R,typeof(pool),typeof(indices)}(indices, pool, t.ordered)
+end
+
+function _runendview(::Type{T}, f::AC.Field, d::AC.ArrayData, ctx::_ViewContext) where {T}
+    runs, values = d.children[1], d.children[2]
+    R = AC.juliatype(runs.type::AC.IntType)
+    _chargeexact!(ctx.budget, Int64, runs.len, "run ends")
+    runends = _collectas(Int64, _primitive(R, R, Nothing, runs, ctx.budget))
+    vcol = _viewcolumn(f.children[2], [values], ctx, T; source=false)
+    return RunEndEncoded{T,typeof(vcol)}(runends, vcol, Int(d.offset), Int(d.len))
+end
+
+"""
+The view column of field `f` over its decoded batches `datas`: one view for
+one batch, a `ChainedVector` of per-batch views for several, and one
+`StringVector`/`BytesVector` (or `Vector{String}`) across all batches of a
+string or binary column. `T` overrides the element type (run-end values).
+A string column references the source's bytes in place unless `source` is
+false: the values of nested rows and run-end columns copy them, so a copy of
+a row (`copy(table)`, `DataFrame(table)`) owns its strings without copying
+each one.
+"""
+function _viewcolumn(
+    f::AC.Field,
+    datas::AbstractVector{AC.ArrayData},
+    ctx::_ViewContext,
+    T::Type=_vieweltype(f, datas, ctx);
+    source::Bool=true,
+)
+    t = f.type
+    t isa AC.NullType && return fill(missing, sum(d -> Int(d.len), datas; init=0))
+    if _isstringlayout(t)
+        b = _allocate!(_stringbuild(T, datas, ctx.budget; source))
+        for k in eachindex(b.chunks)
+            _buildchunk!(b, k)
+        end
+        return _finishbuild(b)
+    end
+    isempty(datas) && return T[]
+    first = _viewbatch(T, f, datas[1], ctx)
+    length(datas) == 1 && return first
+    # `first`'s type is known at run time; see `_uninferred`.
+    return _uninferred(_chainviews, first, f, datas, ctx, T)
+end
+
+# A concretely typed chunk vector (a comprehension over `_batchview` would
+# infer its element type at run time, per column). Batches whose views differ
+# in type (dictionary pools that differ in nullability) chain abstractly.
+function _chainviews(first::V, f::AC.Field, datas, ctx::_ViewContext, T::Type) where {V}
+    _chargevector!(ctx.budget, V, length(datas), "column views")
+    _chargevector!(ctx.budget, Int, length(datas), "chunked column index")
+    cols = Vector{V}(undef, length(datas))
+    cols[1] = first
+    for k = 2:length(datas)
+        col = _viewbatch(T, f, datas[k], ctx)
+        # The abstract chain compiles apart (see `_uninferred`).
+        col isa V || return _uninferred(_mixedchainviews, first, f, datas, ctx, T)
+        cols[k] = col
+    end
+    return ChainedVector(cols)
+end
+
+_mixedchainviews(first, f::AC.Field, datas, ctx::_ViewContext, T::Type) = ChainedVector(
+    AbstractVector{T}[
+        k == 1 ? first : _viewbatch(T, f, d, ctx) for (k, d) in enumerate(datas)
+    ],
+)
+
+# --- nested rows ----------------------------------------------------------------
+#
+# Lists read as `ListValue` views, maps as `MapValue` views, fixed-size lists of up
+# to 64 non-null values as `NTuple`s, structs as `NamedTuple`s built on access,
+# and unions as a `Union` of their children's element types. A column's
+# element type alone fixes how its child values are stored (`_columntype`):
+# strings in a `StringVector`, binary in a `BytesVector`, lists in a
+# `ListVector`, maps in a `MapVector`, structs in a `StructVector`, other
+# fixed-width values in a `Primitive{E,S,Nothing}` (`S` the non-missing `E`),
+# other values in a `Vector`. Columns keep their children untyped and read
+# them back through that type, so a column type has only its element type as
+# a parameter, however deep the schema, and access is type-stable. A
+# fixed-width child whose stored layout is its values views the source, as a
+# top-level column does, and keeps it alive; other children are owned copies.
+
+const _NestedLayout = Union{
+    AC.ListType,
+    AC.ListViewType,
+    AC.FixedSizeListType,
+    AC.MapType,
+    AC.StructType,
+    AC.UnionType,
+}
+const _MAX_ROW_FIELDS = 64
+# Each level nests a `Union{Missing,...}` in the row type, and the first read's
+# compile time grows steeply with it: on Julia 1.13, lists 10 deep take about
+# 1.5 s, 17 deep about 50 s, and structs 32 deep over 8 minutes.
+const _MAX_ROW_DEPTH = 8
+const _MAX_TUPLE_ROW = 64
+
+"""
+    Arrow.ListValue{T} <: AbstractVector{T}
+
+A row of a list column, or of a fixed-size list column longer than 64 values
+or with nullable values: a read-only view of consecutive child values of its
+column. It stays valid after its table is gone. `copy(row)` gives a
+`Vector{T}`.
+"""
+struct ListValue{T} <: AbstractVector{T}
+    values::Any   # the column's child values, a `_columntype(T)`
+    offset::Int   # child values before the row's first
+    len::Int
+end
+
+"""
+    Arrow.MapValue{K,V} <: AbstractDict{K,V}
+
+A row of a map column: a read-only dictionary that iterates the map's
+`key => value` entries in stored order, duplicate keys included, which `length`
+counts. `row[key]`, `get`, and `haskey` find the last entry with that key, the
+one `Dict(row)` keeps; `keys(row)` and `values(row)` are vectors in stored
+order. Each lookup scans the row, so for many lookups in a large map
+`Dict(row)` is faster. `collect(row)` gives the `Vector{Pair{K,V}}` of entries
+and `copy(row)` a `Dict{K,V}`. It stays valid after its table is gone.
+"""
+struct MapValue{K,V} <: AbstractDict{K,V}
+    keys::Any     # the column's keys and values, `_columntype(K)`, `_columntype(V)`
+    values::Any
+    offset::Int
+    len::Int
+end
+
+# List and map offsets: the batch's `Int32` (`Int64` for the large layouts)
+# offsets, or ones the read computed.
+const _Offsets = Union{Vector{Int32},Vector{Int64}}
+
+"""
+    Arrow.ListVector{T} <: Arrow.ArrowVector{T}
+
+A list column: row `i` is the [`Arrow.ListValue`](@ref) of child values
+`offsets[i]+1:offsets[i+1]`, or `missing` where the validity bitmap marks a
+null.
+"""
+struct ListVector{T} <: ArrowVector{T}
+    offsets::_Offsets   # the batch's own offsets where it can (see `_listoffsets`)
+    values::Any   # child values, a `_columntype(eltype(row))`
+    validity::Vector{UInt8}
+    bitoffset::Int
+    owner::Any
+end
+
+"""
+    Arrow.MapVector{T} <: Arrow.ArrowVector{T}
+
+A map column: row `i` is the [`Arrow.MapValue`](@ref) of entries
+`offsets[i]+1:offsets[i+1]`, or `missing` where the validity bitmap marks a
+null.
+"""
+struct MapVector{T} <: ArrowVector{T}
+    offsets::_Offsets
+    keys::Any
+    values::Any
+    validity::Vector{UInt8}
+    bitoffset::Int
+    owner::Any
+end
+
+"""
+    Arrow.StructVector{T} <: Arrow.ArrowVector{T}
+
+A struct column: row `i` is the `NamedTuple` of each field's value `i`,
+built when it is read, or `missing` where the validity bitmap marks a null.
+"""
+struct StructVector{T} <: ArrowVector{T}
+    children::Vector{AbstractVector}   # field `k`'s values, a `_columntype(fieldtype(row, k))`
+    offset::Int                        # child values before row 1
+    len::Int
+    validity::Vector{UInt8}
+    bitoffset::Int
+    owner::Any
+end
+
+_columntype(::Type{T}) where {T} = _columntype(T, Base.nonmissingtype(T))
+_columntype(::Type{Missing}) = Vector{Missing}
+_columntype(::Type{T}, ::Type{S}) where {T,S} =
+    isbitstype(S) && S !== Bool ? Primitive{T,S,Nothing,_buffertype(S)} : Vector{T}
+_columntype(::Type{T}, ::Type{DataStrings.DataString}) where {T} =
+    DataStrings.StringVector{T}
+_columntype(::Type{T}, ::Type{DataStrings.DataBytes}) where {T} = DataStrings.BytesVector{T}
+# A `Union` of row types (a union column's values) is stored as a `Vector`.
+_columntype(::Type{T}, ::Type{R}) where {T,R<:ListValue} =
+    R isa DataType ? ListVector{T} : Vector{T}
+_columntype(::Type{T}, ::Type{R}) where {T,R<:MapValue} =
+    R isa DataType ? MapVector{T} : Vector{T}
+_columntype(::Type{T}, ::Type{R}) where {T,R<:NamedTuple} =
+    R isa DataType ? StructVector{T} : Vector{T}
+
+_childdatas(datas, k::Int) = AC.ArrayData[d.children[k] for d in datas]
+
+# The row type of nested field `f` over batches `datas`: each child's element
+# type, so a child whose data holds undeclared nulls widens every batch's rows.
+function _rowtype(f::AC.Field, ctx::_ViewContext, datas)
+    t = f.type
+    if t isa AC.StructType
+        names = Tuple(Symbol(c.name) for c in f.children)
+        types =
+            (_vieweltype(c, _childdatas(datas, k), ctx) for (k, c) in enumerate(f.children))
+        return NamedTuple{names,Tuple{types...}}
+    end
+    t isa AC.UnionType && return Union{
+        (_vieweltype(c, _childdatas(datas, k), ctx) for (k, c) in enumerate(f.children))...,
+    }
+    if t isa AC.MapType
+        entries = f.children[1]
+        entrydatas = _childdatas(datas, 1)
+        K = _vieweltype(entries.children[1], _childdatas(entrydatas, 1), ctx)
+        V = _vieweltype(entries.children[2], _childdatas(entrydatas, 2), ctx)
+        return MapValue{K,V}
+    end
+    E = _vieweltype(f.children[1], _childdatas(datas, 1), ctx)
+    # A tuple of a non-concrete `E` (nullable values) is an abstract type:
+    # every row would be boxed, with up to 2^N runtime types.
+    t isa AC.FixedSizeListType &&
+        t.listsize <= _MAX_TUPLE_ROW &&
+        isconcretetype(E) &&
+        return NTuple{t.listsize,E}
+    return ListValue{E}
+end
+
+# Whether field `f`'s values are nested rows (through a dictionary's values
+# or run-end encoding too).
+_nestedvalue(f::AC.Field) =
+    f.type isa AC.DictionaryType ? _nestedvalue(AC.dictvaluefield(f, f.type)) :
+    f.type isa AC.RunEndEncodedType ? _nestedvalue(f.children[2]) : f.type isa _NestedLayout
+
+# Element `j` of `values`, a column of `T` values stored as its `_columntype`.
+Base.@propagate_inbounds _childvalue(::Type{T}, values, j::Int) where {T} =
+    (values::_columntype(T))[j]
+
+Base.IndexStyle(::Type{<:ListValue}) = IndexLinear()
+Base.size(r::ListValue) = (r.len,)
+Base.size(v::Union{ListVector,MapVector}) = (length(v.offsets) - 1,)
+Base.size(v::StructVector) = (v.len,)
+
+Base.@propagate_inbounds function Base.getindex(r::ListValue{T}, i::Int) where {T}
+    @boundscheck checkbounds(r, i)
+    return @inbounds _childvalue(T, r.values, r.offset + i)
+end
+
+# `push!`, `append!`, `merge!`, and the like go through `resize!`,
+# `setindex!`, and `delete!`.
+@noinline _readonlyvalue(x) = throw(
+    ArgumentError(
+        "an Arrow.$(nameof(typeof(x))) is read-only; copy(x) gives a " *
+        "$(x isa MapValue ? "Dict" : "Vector") that can change",
+    ),
+)
+Base.setindex!(x::ListValue, v, ::Int) = _readonlyvalue(x)
+Base.resize!(x::ListValue, ::Integer) = _readonlyvalue(x)
+Base.setindex!(x::MapValue, v, k) = _readonlyvalue(x)
+Base.delete!(x::MapValue, k) = _readonlyvalue(x)
+Base.empty!(x::MapValue) = _readonlyvalue(x)
+
+Base.length(r::MapValue) = r.len
+function Base.iterate(r::MapValue{K,V}, i::Int=1) where {K,V}
+    i > r.len && return nothing
+    j = r.offset + i
+    return Pair{K,V}(_childvalue(K, r.keys, j), _childvalue(V, r.values, j)), i + 1
+end
+
+# The child position of the last entry whose key is `key`, or `nothing`.
+function _mapentry(r::MapValue{K}, key) where {K}
+    for j = (r.offset + r.len):-1:(r.offset + 1)
+        isequal(_childvalue(K, r.keys, j), key) && return j
+    end
+    return nothing
+end
+Base.haskey(r::MapValue, key) = _mapentry(r, key) !== nothing
+function Base.get(r::MapValue{K,V}, key, default) where {K,V}
+    j = _mapentry(r, key)
+    return j === nothing ? default : _childvalue(V, r.values, j)
+end
+function Base.get(default::Base.Callable, r::MapValue{K,V}, key) where {K,V}
+    j = _mapentry(r, key)
+    return j === nothing ? default() : _childvalue(V, r.values, j)
+end
+function Base.getindex(r::MapValue{K,V}, key) where {K,V}
+    j = _mapentry(r, key)
+    j === nothing && throw(KeyError(key))
+    return _childvalue(V, r.values, j)
+end
+Base.keys(r::MapValue{K}) where {K} = ListValue{K}(r.keys, r.offset, r.len)
+Base.values(r::MapValue{K,V}) where {K,V} = ListValue{V}(r.values, r.offset, r.len)
+
+# Inside a container or under `:compact` (DataFrame cells), list and map values
+# print as the plain Julia values they hold, without element types:
+# `[1, missing]`, `Dict("a" => 1)`.
+_compactshow(io::IO) = get(io, :compact, false) === true || haskey(io, :typeinfo)
+function Base.show(io::IO, r::ListValue)
+    _compactshow(io) || return invoke(show, Tuple{IO,AbstractArray}, io, r)
+    # A `:typeinfo` of the row's own type leaves out the element type.
+    return invoke(show, Tuple{IO,AbstractArray}, IOContext(io, :typeinfo => typeof(r)), r)
+end
+function Base.show(io::IO, r::MapValue)
+    _compactshow(io) || return invoke(show, Tuple{IO,AbstractDict}, io, r)
+    entries = IOContext(io, :typeinfo => eltype(r))
+    limit = get(io, :limit, false)::Bool
+    print(io, "Dict(")
+    for (count, pair) in enumerate(r)
+        count > 1 && print(io, ", ")
+        show(entries, pair)
+        limit && count == 10 < length(r) && (print(io, ", …"); break)
+    end
+    print(io, ')')
+    return nothing
+end
+
+Base.@propagate_inbounds function Base.getindex(v::ListVector{T}, i::Int) where {T}
+    @boundscheck checkbounds(v, i)
+    if Missing <: T
+        null = GC.@preserve v _isnullslot(v.validity, v.bitoffset, i)
+        null && return missing
+    end
+    lo, hi = GC.@preserve v @inbounds Int(v.offsets[i]), Int(v.offsets[i + 1])
+    return Base.nonmissingtype(T)(v.values, lo, hi - lo)
+end
+
+Base.@propagate_inbounds function Base.getindex(v::MapVector{T}, i::Int) where {T}
+    @boundscheck checkbounds(v, i)
+    if Missing <: T
+        null = GC.@preserve v _isnullslot(v.validity, v.bitoffset, i)
+        null && return missing
+    end
+    lo, hi = GC.@preserve v @inbounds Int(v.offsets[i]), Int(v.offsets[i + 1])
+    return Base.nonmissingtype(T)(v.keys, v.values, lo, hi - lo)
+end
+
+Base.@propagate_inbounds function Base.getindex(v::StructVector{T}, i::Int) where {T}
+    @boundscheck checkbounds(v, i)
+    if Missing <: T
+        null = GC.@preserve v _isnullslot(v.validity, v.bitoffset, i)
+        null && return missing
+    end
+    return _structrow(Base.nonmissingtype(T), v.children, v.offset + i)
+end
+
+# Generated so each field reads through its own child type, without
+# allocating. The generator loops: a comprehension's closure would compile
+# once per row type.
+@generated function _structrow(
+    ::Type{R},
+    children::Vector{AbstractVector},
+    j::Int,
+) where {R<:NamedTuple}
+    fields = Expr[]
+    for k = 1:fieldcount(R)
+        push!(fields, :(@inbounds _childvalue($(fieldtype(R, k)), children[$k], j)))
+    end
+    return :(R(($(fields...),)))
+end
+
+# Owned column copies replace nested views too: a struct or list can contain
+# another list whose child values still point into the input's buffers.
+_ownedtype(::Type{T}) where {T} =
+    T isa Union ? Union{(_ownedtype(S) for S in Base.uniontypes(T))...} : T
+_ownedtype(::Type{ListValue{T}}) where {T} = Vector{_ownedtype(T)}
+_ownedtype(::Type{MapValue{K,V}}) where {K,V} = Dict{_ownedtype(K),_ownedtype(V)}
+_ownedtype(::Type{NamedTuple{N,T}}) where {N,T} = NamedTuple{N,_ownedtype(T)}
+_ownedtype(::Type{Pair{K,V}}) where {K,V} = Pair{_ownedtype(K),_ownedtype(V)}
+_ownedtype(::Type{T}) where {T<:Tuple} =
+    T isa Union ? Union{(_ownedtype(S) for S in Base.uniontypes(T))...} :
+    (T === Union{} || T isa UnionAll || Base.isvatuple(T)) ? T :
+    Tuple{map(_ownedtype, fieldtypes(T))...}
+
+# Unknown element types need a value check; concrete scalar types cannot
+# contain any of the nested views this module creates.
+_mayborrow(::Type{T}) where {T} =
+    T isa Union ? any(_mayborrow, Base.uniontypes(T)) : !isconcretetype(T)
+_mayborrow(::Type{<:ListValue}) = true
+_mayborrow(::Type{<:MapValue}) = true
+_mayborrow(::Type{T}) where {T<:Union{NamedTuple,Tuple,Pair}} =
+    !isconcretetype(T) || any(_mayborrow, fieldtypes(T))
+_mayborrow(::Type{T}) where {T<:AbstractVector} =
+    !isconcretetype(T) || _mayborrow(eltype(T))
+_mayborrow(::Type{T}) where {T<:AbstractDict} =
+    !isconcretetype(T) || _mayborrow(keytype(T)) || _mayborrow(valtype(T))
+
+_hasborrowed(x) = false
+_hasborrowed(::Union{ListValue,MapValue}) = true
+_hasborrowed(x::Union{NamedTuple,Tuple,Pair}) = any(_hasborrowed, x)
+_hasborrowed(x::Union{AbstractVector,AbstractDict}) =
+    _mayborrow(eltype(x)) && any(_hasborrowed, x)
+
+_needsowned(c::AbstractVector{T}) where {T} =
+    _ownedtype(T) !== T || (_mayborrow(T) && any(_hasborrowed, c))
+
+_ownedvalue(x) = x
+_ownedvalue(x::ListValue) = _copyrows(eltype(x), x)
+# A `Dict`, as Arrow 2.x read maps: a repeated key keeps its last value, the
+# one the view's lookup finds.
+_ownedvalue(x::MapValue{K,V}) where {K,V} =
+    Dict{_ownedtype(K),_ownedtype(V)}(_ownedvalue(k) => _ownedvalue(v) for (k, v) in x)
+_ownedvalue(x::Union{NamedTuple,Tuple}) = map(_ownedvalue, x)
+_ownedvalue(x::Pair) = _ownedvalue(first(x)) => _ownedvalue(last(x))
+_ownedvalue(x::AbstractVector) = _needsowned(x) ? _copyrows(eltype(x), x) : x
+_ownedvalue(x::AbstractDict) = _hasborrowed(x) ? Dict(_ownedvalue(p) for p in x) : x
+
+function _copyrows(::Type{T}, v) where {T}
+    R = _ownedtype(T)
+    # An abstract container may change its element type when a hidden view
+    # becomes a vector. Let map infer or widen it from the converted values.
+    R === T && _mayborrow(T) && !isempty(v) && return map(_ownedvalue, v)
+    out = Vector{R}(undef, length(v))
+    for (i, x) in enumerate(v)
+        out[i] = _ownedvalue(x)
+    end
+    return out
+end
+Base.copy(v::ArrowVector{T}) where {T} = _copyrows(T, v)
+Base.copy(c::ChainedVector{T,<:ArrowVector}) where {T} =
+    _ownedtype(T) === T ? invoke(copy, Tuple{ChainedVector}, c) : _copyrows(T, c)
+
+# The values of child `d` (field `f`) as their `_columntype(E)`: the column a
+# read builds, copied into owned storage when it is a view of the source
+# (rows view their column's children, and outlive their table).
+function _childcolumn(
+    f::AC.Field,
+    d::AC.ArrayData,
+    ctx::_ViewContext,
+    @nospecialize(E::Type)
+)
+    col = _viewcolumn(f, AC.ArrayData[d], ctx, E; source=false)
+    return _storedas(_columntype(E), col, ctx.budget)
+end
+_storedas(::Type{C}, col, budget) where {C} = col isa C ? col : _storeas(C, col, budget)
+
+function _storeas(::Type{Vector{E}}, col, budget) where {E}
+    _chargeexact!(budget, E, length(col), "nested child values")
+    return copyto!(Vector{E}(undef, length(col)), 1, col, 1, length(col))
+end
+# Converted values (dates, dictionary or run-end encoded values, ...) stored
+# as `S`s, with a validity bitmap when some slot is null; null slots hold zero
+# bytes.
+function _storeas(::Type{Primitive{T,S,Nothing,D}}, col, budget) where {T,S,D}
+    n = length(col)
+    _chargeexact!(budget, S, n, "nested child values")
+    data = Vector{S}(undef, n)
+    GC.@preserve data Libc.memset(pointer(data), 0, sizeof(data))
+    validity = UInt8[]
+    for (i, x) in enumerate(col)
+        if x === missing
+            validity = _setnull(validity, i, n, budget)
+        else
+            @inbounds data[i] = x
+        end
+    end
+    values = D === Vector{S} ? data : _UnalignedVector{S}(pointer(data), n, data)
+    return Primitive{T,S,Nothing,D}(values, validity, 0, nothing)
+end
+
+# A validity bitmap for `n` slots with slot `i` null; an empty `validity` (no
+# nulls yet) becomes an all-valid bitmap first.
+function _setnull(validity::Vector{UInt8}, i::Int, n::Int, budget)
+    if isempty(validity)
+        _chargeexact!(budget, UInt8, cld(n, 8), "nested child validity")
+        validity = fill(0xff, cld(n, 8))
+    end
+    @inbounds validity[((i - 1) >> 3) + 1] &= ~(0x01 << ((i - 1) & 7))
+    return validity
+end
+
+# Converted list, map, and struct values (run-end encoded or dictionary
+# children) gather their rows into a column of their own.
+function _storeas(::Type{ListVector{T}}, col, budget) where {T}
+    E = eltype(Base.nonmissingtype(T))
+    n = length(col)
+    _chargeexact!(budget, Int, n + 1, "list offsets")
+    offsets = zeros(Int, n + 1)
+    values, validity = E[], UInt8[]
+    for (i, row) in enumerate(col)
+        if row === missing
+            validity = _setnull(validity, i, n, budget)
+        else
+            append!(values, row)
+        end
+        offsets[i + 1] = length(values)
+    end
+    _chargeexact!(budget, E, length(values), "nested child values")
+    return ListVector{T}(
+        offsets,
+        _storedas(_columntype(E), values, budget),
+        validity,
+        0,
+        nothing,
+    )
+end
+function _storeas(::Type{MapVector{T}}, col, budget) where {T}
+    K, V = fieldtypes(eltype(Base.nonmissingtype(T)))
+    n = length(col)
+    _chargeexact!(budget, Int, n + 1, "map offsets")
+    offsets = zeros(Int, n + 1)
+    keys, values, validity = K[], V[], UInt8[]
+    for (i, row) in enumerate(col)
+        if row === missing
+            validity = _setnull(validity, i, n, budget)
+        else
+            for (k, v) in row
+                push!(keys, k)
+                push!(values, v)
+            end
+        end
+        offsets[i + 1] = length(keys)
+    end
+    _chargeexact!(budget, Pair{K,V}, length(keys), "nested child values")
+    keys = _storedas(_columntype(K), keys, budget)
+    return MapVector{T}(
+        offsets,
+        keys,
+        _storedas(_columntype(V), values, budget),
+        validity,
+        0,
+        nothing,
+    )
+end
+function _storeas(::Type{StructVector{T}}, col, budget) where {T}
+    R = Base.nonmissingtype(T)
+    n = length(col)
+    validity = UInt8[]
+    for (i, row) in enumerate(col)
+        row === missing && (validity = _setnull(validity, i, n, budget))
+    end
+    # A null row's field slots are never read; they repeat a valid row's
+    # values (none when every row is null).
+    k = findfirst(!ismissing, col)
+    rows = k === nothing ? R[] : R[row === missing ? col[k] : row for row in col]
+    _chargevector!(budget, AbstractVector, fieldcount(R), "struct children")
+    children = Vector{AbstractVector}(undef, fieldcount(R))
+    for j = 1:fieldcount(R)
+        F = fieldtype(R, j)
+        _chargeexact!(budget, F, length(rows), "nested child values")
+        children[j] = _storedas(_columntype(F), F[getfield(r, j) for r in rows], budget)
+    end
+    return StructVector{T}(children, 0, n, validity, 0, nothing)
+end
+_storeas(::Type{DataStrings.StringVector{E}}, col, budget) where {E} =
+    DataStrings.StringVector{E}(collect(col))
+function _storeas(::Type{DataStrings.BytesVector{E}}, col, budget) where {E}
+    payloads = Vector{_StringPayload}(undef, length(col))
+    buffers = Vector{UInt8}[]
+    for (i, x) in enumerate(col)
+        if x === missing
+            payloads[i] = DataStrings.PAYLOAD_MISSING
+            continue
+        end
+        bytes = collect(UInt8, x)
+        n = length(bytes)
+        payloads[i] = if n <= DataStrings.INLINE_MAX
+            DataStrings.inline_payload(bytes, 1, n)
+        else
+            push!(buffers, bytes)
+            DataStrings.view_payload(bytes, 1, n, length(buffers) - 1, 0)
+        end
+    end
+    return DataStrings.BytesVector{E}(payloads, buffers, Val(:trusted))
+end
+
+# The `n + 1` offsets of list or map batch `d`, plus `base` (a map's entries
+# struct offset): a view of the batch's buffer when `base` is 0 (copied only if
+# misaligned), else shifted copies.
+function _listoffsets(d::AC.ArrayData, base::Int, budget)
+    n = Int64(d.len)
+    n == 0 && return Int[base]
+    buf = AC.rolebuffer(d, AC.OFFSETS)
+    raw =
+        AC.layoutspec_of(d.type).offsetwidth == 8 ?
+        _wrapbuffer(Int64, buf, d.offset, n + 1, budget) :
+        _wrapbuffer(Int32, buf, d.offset, n + 1, budget)
+    # The view stays valid while the column (whose owner is `d`) is reachable.
+    base == 0 && return raw
+    _chargeexact!(budget, Int, n + 1, "list offsets")
+    return GC.@preserve d raw .+ base
+end
+
+# Not specialized on the row type, so it compiles once for every nested
+# column; the per-row loops it calls are function barriers specialized on
+# the row and column types.
+function _nestedbatch(
+    @nospecialize(T::Type),
+    f::AC.Field,
+    d::AC.ArrayData,
+    ctx::_ViewContext,
+)
+    t = f.type
+    R = Base.nonmissingtype(T)
+    budget = ctx.budget
+    _chargeobject!(budget, _VIEW_OBJECT_BYTES, "column view")
+    t isa AC.UnionType && return _unionrows(T, f, d, ctx)
+    validity, bitoffset = _validitybits(d)
+    if t isa AC.StructType
+        children = Vector{AbstractVector}(undef, length(f.children))
+        for (k, c) in enumerate(f.children)
+            children[k] = _childcolumn(c, d.children[k], ctx, fieldtype(R, k))
+        end
+        return StructVector{T}(children, Int(d.offset), Int(d.len), validity, bitoffset, d)
+    end
+    if t isa AC.MapType
+        entries, ed = f.children[1], d.children[1]
+        K, V = fieldtypes(eltype(R))
+        keys = _childcolumn(entries.children[1], ed.children[1], ctx, K)
+        vals = _childcolumn(entries.children[2], ed.children[2], ctx, V)
+        offsets = _listoffsets(d, Int(ed.offset), budget)
+        return MapVector{T}(offsets, keys, vals, validity, bitoffset, d)
+    end
+    R <: Array && return _tensorrows(T, f, d, ctx, _tensorshape(f)::Tuple)
+    E = eltype(R)
+    if t isa AC.FixedSizeListType && R <: Tuple
+        # `NTuple{0,E}` is `Tuple{}`, whose rows read no child values.
+        N = fieldcount(R)
+        N == 0 && return _tuplerows(T, Val(0), nothing, d, budget)
+        child = _viewcolumn(f.children[1], AC.ArrayData[d.children[1]], ctx, E)
+        return _tuplerows(T, Val(N), child, d, budget)
+    end
+    values = _childcolumn(f.children[1], d.children[1], ctx, E)
+    t isa AC.ListViewType &&
+        return _listviewvector(T, d, values, validity, bitoffset, budget)
+    offsets = if t isa AC.FixedSizeListType
+        w = t.listsize
+        _chargeexact!(budget, Int, d.len + 1, "fixed-size list offsets")
+        Int[(Int(d.offset) + i) * w for i = 0:(d.len)]
+    else
+        _listoffsets(d, 0, budget)
+    end
+    return ListVector{T}(offsets, values, validity, bitoffset, d)
+end
+
+# A list view batch: rows may overlap or come in any order, so the child
+# values of each row are gathered in row order (their own storage keeps
+# flat values only; see `_viewablelayout`).
+function _listviewvector(
+    @nospecialize(T::Type),
+    d::AC.ArrayData,
+    values,
+    validity,
+    bitoffset,
+    budget,
+)
+    n = Int64(d.len)
+    _chargeexact!(budget, Int, n + 1, "list view offsets")
+    offsets = zeros(Int, n + 1)
+    n == 0 &&
+        return ListVector{T}(offsets, _gathered(values, Int[]), validity, bitoffset, d)
+    wide = AC.layoutspec_of(d.type).offsetwidth == 8
+    starts, sizes = GC.@preserve d (
+        wide ?
+        (
+            Int.(_wrapbuffer(Int64, AC.rolebuffer(d, AC.ELEMENT_OFFSETS), d.offset, n)),
+            Int.(_wrapbuffer(Int64, AC.rolebuffer(d, AC.SIZES), d.offset, n)),
+        ) :
+        (
+            Int.(_wrapbuffer(Int32, AC.rolebuffer(d, AC.ELEMENT_OFFSETS), d.offset, n)),
+            Int.(_wrapbuffer(Int32, AC.rolebuffer(d, AC.SIZES), d.offset, n)),
+        )
+    )
+    for i = 1:n
+        len = _isnullslot(validity, bitoffset, i) ? 0 : sizes[i]
+        offsets[i + 1] = offsets[i] + len
+    end
+    _chargeexact!(budget, Int, offsets[end], "list view value index")
+    take = Vector{Int}(undef, offsets[end])
+    for i = 1:n
+        for k = 1:(offsets[i + 1] - offsets[i])
+            take[offsets[i] + k] = starts[i] + k
+        end
+    end
+    return ListVector{T}(offsets, _gathered(values, take), validity, bitoffset, d)
+end
+
+_gathered(values::Vector, take) = values[take]
+_gathered(v::Primitive{T,S,Nothing}, take) where {T,S} =
+    _storeas(typeof(v), view(v, take), nothing)
+_gathered(v::DataStrings.StringVector{E}, take) where {E} =
+    DataStrings.StringVector{E}(v.payloads[take], v.buffers, Val(:trusted))
+_gathered(v::DataStrings.BytesVector{E}, take) where {E} =
+    DataStrings.BytesVector{E}(v.payloads[take], v.buffers, Val(:trusted))
+
+function _tuplerows(::Type{T}, ::Val{N}, child, d::AC.ArrayData, budget) where {T,N}
+    n = Int(d.len)
+    _chargeexact!(budget, T, n, "fixed-size list rows")
+    out = Vector{T}(undef, n)
+    validity, bitoffset = _validitybits(d)
+    GC.@preserve validity child for i = 1:n
+        if Missing <: T && _isnullslot(validity, bitoffset, i)
+            out[i] = missing
+        else
+            base = (Int(d.offset) + i - 1) * N
+            out[i] = ntuple(j -> child[base + j], Val(N))
+        end
+    end
+    return out
+end
+
+# The value at child index `j` of the `k`th column, unrolled over the tuple.
+_pickchild(cols::Tuple, k::Int, j::Int) =
+    k == 1 ? first(cols)[j] : _pickchild(Base.tail(cols), k - 1, j)
+_pickchild(::Tuple{}, ::Int, ::Int) = throw(ValidationError("union child out of range"))
+
+function _unionrows(@nospecialize(T::Type), f::AC.Field, d::AC.ArrayData, ctx::_ViewContext)
+    t = f.type::AC.UnionType
+    budget = ctx.budget
+    cols = Tuple(
+        Any[
+            _viewcolumn(
+                c,
+                AC.ArrayData[d.children[k]],
+                ctx,
+                _vieweltype(c, AC.ArrayData[d.children[k]], ctx),
+            ) for (k, c) in enumerate(f.children)
+        ],
+    )
+    n = Int(d.len)
+    _chargeexact!(budget, T, n, "union rows")
+    out = Vector{T}(undef, n)
+    ids = _wrapbuffer(Int8, AC.rolebuffer(d, AC.TYPE_IDS), d.offset, n, budget)
+    dense = t.mode == AC.DenseMode
+    offsets =
+        dense ?
+        _wrapbuffer(Int32, AC.rolebuffer(d, AC.ELEMENT_OFFSETS), d.offset, n, budget) :
+        Int32[]
+    GC.@preserve ids offsets d _fillunion!(
+        out,
+        cols,
+        ids,
+        offsets,
+        t.typeids,
+        dense,
+        Int(d.offset),
+    )
+    return out
+end
+
+# Specialized on the children's column types (a function barrier).
+function _fillunion!(out, cols::Tuple, ids, offsets, typeids, dense::Bool, base::Int)
+    for i in eachindex(out)
+        k = findfirst(==(ids[i]), typeids)
+        k === nothing &&
+            throw(ValidationError("union type id $(ids[i]) not in declared domain"))
+        j = dense ? Int(offsets[i]) + 1 : base + i
+        out[i] = _pickchild(cols, k, j)
+    end
+    return out
+end
+
+# --- fixed-shape tensors ----------------------------------------------------------
+#
+# The canonical `arrow.fixed_shape_tensor` extension stores each tensor as a
+# fixed-size list of its elements in row-major order over its physical
+# `shape`; `permutation` says which physical dimension each logical one is.
+# Rows read as `Array{T,N}`s of the logical shape.
+
+const _TENSOR_EXTENSION = "arrow.fixed_shape_tensor"
+
+# `(shape, permutation)` of a tensor field (1-based permutation), or nothing
+# when `f` is not one this reader can read: a fixed-size list of a flat,
+# unlabelled child with a well-formed `shape`.
+function _tensorshape(f::AC.Field)
+    f.type isa AC.FixedSizeListType || return nothing
+    ext = _arrowtypesextension(f)
+    (ext === nothing || ext[1] != _TENSOR_EXTENSION) && return nothing
+    (length(f.children) == 1 && !_hasarrowtypesextension(f.children[1])) || return nothing
+    child = f.children[1]
+    (_viewablelayout(child) && !_nestedvalue(child)) || return nothing
+    shape = _jsonints(ext[2], "shape")
+    shape === nothing && return nothing
+    perm = _jsonints(ext[2], "permutation")
+    perm = perm === nothing ? collect(1:length(shape)) : perm .+ 1
+    (
+        all(>=(0), shape) &&
+        length(perm) == length(shape) &&
+        isperm(perm) &&
+        prod(shape; init=1) == f.type.listsize
+    ) || return nothing
+    return (Tuple(shape), Tuple(perm))
+end
+
+# The integers of JSON array `key` in `json`, or nothing.
+function _jsonints(json::AbstractString, key::String)
+    m = match(Regex("\"" * key * "\"\\s*:\\s*\\[([^\\]]*)\\]"), json)
+    m === nothing && return nothing
+    values = Int[]
+    for part in split(m[1], ','; keepempty=false)
+        x = tryparse(Int, strip(part))
+        x === nothing && return nothing
+        push!(values, x)
+    end
+    return values
+end
+
+# Tensor rows are `Array{E,N}`: `E` is the element type, without `Missing`
+# unless an element of a non-null tensor is null.
+function _tensortype(f::AC.Field, ctx::_ViewContext, datas, shape)
+    child = f.children[1]
+    B = _viewbasetype(child, ctx, _childdatas(datas, 1))
+    w = (f.type::AC.FixedSizeListType).listsize
+    nulls = any(d -> _tensornulls(child, d, w), datas)
+    return Array{nulls ? Union{Missing,B} : B,length(first(shape))}
+end
+
+# Whether a non-null row of tensor batch `d` holds a null element.
+function _tensornulls(child::AC.Field, d::AC.ArrayData, w::Int)
+    c = d.children[1]
+    _viewnulls(child, c) || return false
+    # Null elements under a null tensor are never read.
+    rows, rowoff = _validitybits(d)
+    elems, elemoff = _validitybits(c)
+    isempty(elems) && return true  # dictionary or run-end values with nulls
+    GC.@preserve d for i = 1:Int(d.len)
+        _isnullslot(rows, rowoff, i) && continue
+        base = (Int(d.offset) + i - 1) * w
+        any(j -> _isnullslot(elems, elemoff, base + j), 1:w) && return true
+    end
+    return false
+end
+
+function _tensorrows(@nospecialize(T::Type), f::AC.Field, d::AC.ArrayData, ctx, shapeperm)
+    shape, perm = shapeperm
+    R = Base.nonmissingtype(T)
+    child = _viewcolumn(f.children[1], AC.ArrayData[d.children[1]], ctx, eltype(R))
+    return _uninferred(_tensorrows, T, R, child, d, ctx.budget, shape, perm)
+end
+
+function _tensorrows(
+    ::Type{T},
+    ::Type{R},
+    child,
+    d::AC.ArrayData,
+    budget,
+    shape,
+    perm,
+) where {T,R}
+    n = Int(d.len)
+    w = prod(shape; init=1)
+    N = length(shape)
+    _chargeexact!(budget, T, n, "tensor rows")
+    _chargeexact!(budget, eltype(R), n * w, "tensor values")
+    out = Vector{T}(undef, n)
+    validity, bitoffset = _validitybits(d)
+    for i = 1:n
+        if Missing <: T && _isnullslot(validity, bitoffset, i)
+            out[i] = missing
+            continue
+        end
+        base = (Int(d.offset) + i - 1) * w
+        flat = eltype(R)[child[base + j] for j = 1:w]
+        # Row-major storage: reverse the dimensions to reshape, then back.
+        physical = permutedims(reshape(flat, reverse(shape)), N:-1:1)
+        out[i] = perm == Tuple(1:N) ? physical : permutedims(physical, perm)
+    end
+    return out
+end
+
+# Tensor rows back to their row-major storage values, for a rewrite.
+function _tensorstorage(v::AbstractVector, (shape, perm))
+    N = length(shape)
+    return [
+        row isa AbstractArray && ndims(row) == N ?
+        vec(
+            permutedims(perm == Tuple(1:N) ? row : permutedims(row, invperm(perm)), N:-1:1),
+        ) : row for row in v
+    ]
+end
diff --git a/src/cstream.jl b/src/cstream.jl
new file mode 100644
index 00000000..d7a40be7
--- /dev/null
+++ b/src/cstream.jl
@@ -0,0 +1,429 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The C stream interface (ArrowArrayStream) over the C data adapter in
+# cdata.jl: an exported stream is one export whose `get_schema` and `get_next`
+# results are exports of their own, and an imported stream is a moved struct
+# whose batches import as arrays do. Kept apart from cdata.jl so the trim gate
+# can compile the array interface without the IPC reader's `Limits`.
+
+"""
+    Arrow.CArrowArrayStream
+
+The C stream interface's `ArrowArrayStream` struct, field for field.
+"""
+struct CArrowArrayStream
+    get_schema::Ptr{Cvoid}     # int (*)(ArrowArrayStream*, ArrowSchema* out)
+    get_next::Ptr{Cvoid}       # int (*)(ArrowArrayStream*, ArrowArray* out)
+    get_last_error::Ptr{Cvoid} # const char* (*)(ArrowArrayStream*)
+    release::Ptr{Cvoid}        # void (*)(ArrowArrayStream*)
+    private_data::Ptr{Cvoid}
+end
+
+const EINVAL = Cint(Base.Libc.EINVAL)
+
+# An all-zero struct: a released one (`release == NULL`), which also ends a stream.
+function _zeroed(::Type{T}) where {T}
+    r = Ref{T}()
+    GC.@preserve r Libc.memset(Base.unsafe_convert(Ptr{T}, r), 0, sizeof(T))
+    return r
+end
+
+# The batches an exported stream yields, pulled one `get_next` at a time.
+mutable struct ExportedStreamState
+    const batchfield::Field          # struct-typed: children are the schema
+    const batches::Vector{AC.RecordBatch}
+    nextindex::Int
+end
+
+# A record batch crosses as a struct array: the struct field's children are
+# the schema's fields and it carries the schema-level metadata (the
+# C++/pyarrow convention for `schema.metadata`).
+_batchfield(sch::Schema) = Field(
+    "",
+    StructType();
+    nullable=false,
+    metadata=sch.metadata,
+    children=collect(Field, sch.fields),
+)
+_structarray(b::AC.RecordBatch) = ArrayData(
+    StructType(),
+    b.nrows,
+    [BufferSlice()];
+    children=collect(ArrayData, b.columns),
+    nullcount=0,
+)
+
+# The exported stream's state, or `nothing` once released or reaped.
+function _stream_state(sp::Ptr{CArrowArrayStream})
+    stream = unsafe_load(sp)
+    (stream.release == C_NULL || stream.private_data == C_NULL) && return nothing
+    e = lock(REGISTRY_LOCK) do
+        get(EXPORTS, Ptr{Int64}(stream.private_data), nothing)
+    end
+    e === nothing && return nothing
+    return e.roots[1]::ExportedStreamState
+end
+
+# Store `err` as the stream's last error, for `get_last_error`, in the 8 bytes
+# after the export's live count. Best effort: a C callback cannot throw.
+function _streamerror!(sp::Ptr{CArrowArrayStream}, err)
+    try
+        control = unsafe_load(sp).private_data
+        control == C_NULL && return nothing
+        slot = Ptr{Ptr{UInt8}}(control + 8)
+        old = unsafe_load(slot)
+        unsafe_store!(slot, Ptr{UInt8}(C_NULL))
+        old == C_NULL || Libc.free(old)
+        message = replace(sprint(showerror, err), '\0' => ' ')
+        n = ncodeunits(message)
+        p = Ptr{UInt8}(Libc.malloc(n + 1))
+        p == C_NULL && return nothing
+        GC.@preserve message unsafe_copyto!(p, pointer(message), n)
+        unsafe_store!(p, 0x00, n + 1)
+        unsafe_store!(slot, p)
+    catch
+    end
+    return nothing
+end
+
+function _stream_get_schema(sp::Ptr{CArrowArrayStream}, out::Ptr{CArrowSchema})::Cint
+    sp == C_NULL && return EINVAL
+    try
+        state = _stream_state(sp)
+        state === nothing && return EINVAL
+        out == C_NULL && throw(ArgumentError("ArrowSchema output pointer is NULL"))
+        e = _newexport(Any[state.batchfield])
+        try
+            _export_schema!(
+                e,
+                state.batchfield,
+                @cfunction(_release_schema, Cvoid, (Ptr{CArrowSchema},));
+                at=out,
+            )
+            _register!(e)
+        catch
+            _free!(e)
+            rethrow()
+        end
+        return Cint(0)
+    catch err
+        _streamerror!(sp, err)
+        return EINVAL
+    end
+end
+
+function _stream_get_next(sp::Ptr{CArrowArrayStream}, out::Ptr{CArrowArray})::Cint
+    sp == C_NULL && return EINVAL
+    try
+        state = _stream_state(sp)
+        state === nothing && return EINVAL
+        out == C_NULL && throw(ArgumentError("ArrowArray output pointer is NULL"))
+        i = state.nextindex
+        if i > length(state.batches)
+            unsafe_store!(out, _zeroed(CArrowArray)[])
+            return Cint(0)
+        end
+        d = _structarray(state.batches[i])
+        validate_semantic(state.batchfield, d)
+        e = _newexport(Any[d])
+        try
+            _export_array!(
+                e,
+                d,
+                @cfunction(_release_array, Cvoid, (Ptr{CArrowArray},));
+                at=out,
+            )
+            _register!(e)
+        catch
+            _free!(e)
+            rethrow()
+        end
+        state.nextindex = i + 1
+        return Cint(0)
+    catch err
+        _streamerror!(sp, err)
+        return EINVAL
+    end
+end
+
+function _stream_get_last_error(sp::Ptr{CArrowArrayStream})::Ptr{UInt8}
+    sp == C_NULL && return Ptr{UInt8}(C_NULL)
+    stream = unsafe_load(sp)
+    (stream.release == C_NULL || stream.private_data == C_NULL) && return Ptr{UInt8}(C_NULL)
+    return unsafe_load(Ptr{Ptr{UInt8}}(stream.private_data + 8))
+end
+
+function _stream_release(sp::Ptr{CArrowArrayStream})::Cvoid
+    sp == C_NULL && return nothing
+    stream = unsafe_load(sp)
+    stream.release == C_NULL && return nothing
+    _store_field!(sp, Val(:release), Ptr{Cvoid}(C_NULL))
+    stream.private_data == C_NULL ||
+        Base.unsafe_modify!(Ptr{Int64}(stream.private_data), -, 1, :sequentially_consistent)
+    return nothing
+end
+
+# Core's structural schema invariants (endianness, UTF-8 names,
+# valid descriptors) for the whole schema TREE. Stream schemas travel
+# separately from any batch, so both stream directions apply this walk to the
+# schema itself — a zero-batch stream never reaches batch validation.
+function _validate_stream_schema(sch::Schema)
+    AC._validate_schema(sch)
+    for f in sch.fields
+        _validate_stream_field(f)
+    end
+    return nothing
+end
+
+function _validate_stream_field(f::Field)
+    isvalid(f.name) || throw(ValidationError("field name is not valid UTF-8"))
+    AC._validate_descriptor_of(f.type)
+    for c in f.children
+        _validate_stream_field(c)
+    end
+    return nothing
+end
+
+"""
+    Arrow.export_stream!(streamptr::Ptr{CArrowArrayStream}, schema::Arrow.Schema, batches)
+
+The low-level form of [`Arrow.export_stream!`](@ref): fill the `ArrowArrayStream` the
+caller allocated at `streamptr` with a stream that yields `batches`, a vector of
+`Arrow.RecordBatch` values with `schema`. Each batch the consumer pulls is a struct
+array of the batch's columns, exported as [`Arrow.to_c_data`](@ref) exports a column.
+The batches stay reachable until the consumer releases the stream.
+"""
+function export_stream!(
+    sp::Ptr{CArrowArrayStream},
+    sch::Schema,
+    batches::AbstractVector{AC.RecordBatch},
+)
+    sp == C_NULL && throw(ArgumentError("ArrowArrayStream pointer is NULL"))
+    _validate_stream_schema(sch)
+    for b in batches
+        length(b.columns) == length(sch.fields) ||
+            throw(ValidationError("stream batch column count does not match the schema"))
+    end
+    state = ExportedStreamState(_batchfield(sch), collect(AC.RecordBatch, batches), 1)
+    e = _newexport(Any[state])
+    unsafe_store!(e.live, 1)   # the stream itself; its release counts it off
+    unsafe_store!(
+        sp,
+        CArrowArrayStream(
+            @cfunction(
+                _stream_get_schema,
+                Cint,
+                (Ptr{CArrowArrayStream}, Ptr{CArrowSchema})
+            ),
+            @cfunction(_stream_get_next, Cint, (Ptr{CArrowArrayStream}, Ptr{CArrowArray})),
+            @cfunction(_stream_get_last_error, Ptr{UInt8}, (Ptr{CArrowArrayStream},)),
+            @cfunction(_stream_release, Cvoid, (Ptr{CArrowArrayStream},)),
+            Ptr{Cvoid}(e.live),
+        ),
+    )
+    _register!(e)
+    return sp
+end
+
+# ---- import half ----------------------------------------------------------
+
+# One owner for one MOVED ArrowArrayStream, mirroring ForeignOwner: a malloc'd
+# copy of the moved struct gives the producer's callbacks a stable address,
+# and one atomic swap picks the single releaser between `release!` and the GC
+# finalizer.
+mutable struct StreamOwner
+    const block::Ptr{CArrowArrayStream}
+    const thread::Int   # where a collected owner releases (`_releasethread`)
+    @atomic released::Bool
+end
+
+function _movestream(sp::Ptr{CArrowArrayStream})
+    block = Ptr{CArrowArrayStream}(Libc.malloc(sizeof(CArrowArrayStream)))
+    block == C_NULL && throw(OutOfMemoryError())
+    unsafe_store!(block, unsafe_load(sp))
+    _store_field!(sp, Val(:release), Ptr{Cvoid}(C_NULL))
+    try
+        return finalizer(_finalizeowner, StreamOwner(block, _releasethread(), false))
+    catch
+        try
+            _release_producer!(block)
+        finally
+            Libc.free(block)
+        end
+        rethrow()
+    end
+end
+
+Base.deepcopy_internal(o::StreamOwner, ::IdDict) = o
+
+function release!(o::StreamOwner)
+    @atomicswap(o.released = true) && return nothing
+    GC.@preserve o try
+        _release_producer!(o.block)
+    finally
+        Libc.free(o.block)
+    end
+    return nothing
+end
+
+# A stream imported with `from_c_stream`. `nextbatch!` returns its next
+# `RecordBatch`, or `nothing` at the end, and `release!` releases the
+# producer's stream; batches already read stay valid. An error the producer
+# reports is a `ValidationError` with the producer's message. One task uses a
+# stream at a time: overlapping calls throw a `ConcurrencyViolationError`.
+mutable struct ImportedStream <: AC.RecordBatchSource
+    const owner::StreamOwner
+    const batchfield::Field
+    const schema::Schema
+    const limits::Limits
+    done::Bool
+    @atomic pulling::Bool
+end
+
+AC.schema(s::ImportedStream) = s.schema
+
+function _claimstreamcall!(s::ImportedStream)
+    _, ok = @atomicreplace s.pulling false => true
+    ok || throw(
+        Base.ConcurrencyViolationError(
+            "ImportedStream supports only one active stream call",
+        ),
+    )
+    return nothing
+end
+
+_finishstreamcall!(s::ImportedStream) = (@atomic :release s.pulling = false)
+
+function release!(s::ImportedStream)
+    _claimstreamcall!(s)
+    try
+        return release!(s.owner)
+    finally
+        _finishstreamcall!(s)
+    end
+end
+
+function _stream_call_failed(o::StreamOwner, what::AbstractString)
+    msg = "C stream $what failed"
+    GC.@preserve o begin
+        cb = unsafe_load(o.block).get_last_error
+        if cb != C_NULL
+            p = ccall(cb, Ptr{UInt8}, (Ptr{CArrowArrayStream},), o.block)
+            p == C_NULL || (msg *= ": " * _import_cstring(p, "stream error"))
+        end
+    end
+    throw(ValidationError(msg))
+end
+
+# Import a C stream: take over the stream, marking the struct at `sp` released,
+# and read its schema, whose fields are the batches' columns. `limits` bounds
+# what the facade allocates for each batch.
+function from_c_stream(sp::Ptr{CArrowArrayStream}; limits::Limits=Limits())
+    sp == C_NULL && throw(ArgumentError("ArrowArrayStream pointer is NULL"))
+    stream = unsafe_load(sp)
+    stream.release == C_NULL && throw(ArgumentError("cannot import a released stream"))
+    (
+        stream.get_schema == C_NULL ||
+        stream.get_next == C_NULL ||
+        stream.get_last_error == C_NULL
+    ) && throw(ArgumentError("C stream is missing required callbacks"))
+    owner = _movestream(sp)
+    try
+        out = _zeroed(CArrowSchema)
+        status = GC.@preserve owner out ccall(
+            unsafe_load(owner.block).get_schema,
+            Cint,
+            (Ptr{CArrowArrayStream}, Ptr{CArrowSchema}),
+            owner.block,
+            Base.unsafe_convert(Ptr{CArrowSchema}, out),
+        )
+        status == 0 || _stream_call_failed(owner, "get_schema")
+        sch = out[]
+        batchfield = GC.@preserve out try
+            _preflight_schema(sch)
+            _import_field(sch)
+        finally
+            _release_producer!(Base.unsafe_convert(Ptr{CArrowSchema}, out))
+        end
+        batchfield.type isa StructType ||
+            throw(ValidationError("C stream schema must be a struct-typed batch schema"))
+        schema = Schema(collect(Field, batchfield.children); metadata=batchfield.metadata)
+        _validate_stream_schema(schema)
+        return ImportedStream(owner, batchfield, schema, limits, false, false)
+    catch
+        release!(owner)
+        rethrow()
+    end
+end
+
+function AC.nextbatch!(s::ImportedStream)
+    _claimstreamcall!(s)
+    try
+        # Fail closed on a released stream even when it already ended: release
+        # ends the consumer contract, not just the batch supply.
+        (@atomic s.owner.released) &&
+            throw(ArgumentError("cannot pull from a released stream"))
+        s.done && return nothing
+        out = _zeroed(CArrowArray)
+        status = GC.@preserve s out ccall(
+            unsafe_load(s.owner.block).get_next,
+            Cint,
+            (Ptr{CArrowArrayStream}, Ptr{CArrowArray}),
+            s.owner.block,
+            Base.unsafe_convert(Ptr{CArrowArray}, out),
+        )
+        status == 0 || _stream_call_failed(s.owner, "get_next")
+        if out[].release == C_NULL
+            s.done = true
+            return nothing
+        end
+        owner = GC.@preserve out _moveowner(Base.unsafe_convert(Ptr{CArrowArray}, out))
+        d = _importarray(s.batchfield, owner)
+        try
+            return _structbatch(s.schema, d)
+        catch
+            release!(owner)
+            rethrow()
+        end
+    finally
+        _finishstreamcall!(s)
+    end
+end
+
+# A record batch has no row validity, so null struct rows are refused rather
+# than exposing the child values under them (Arrow C++ refuses them too).
+# Row i of a struct array is child row `offset + i`, and children may run past
+# `offset + length`; each column is that visible child window.
+function _structbatch(sch::Schema, d::ArrayData)
+    AC.nullcount(d) == 0 || throw(
+        ValidationError("a struct array with null rows has no record batch or table form"),
+    )
+    columns = ArrayData[
+        d.offset == 0 && c.len == d.len ? c :
+        AC._arraydata(
+            c.type,
+            d.len,
+            c.buffers,
+            c.offset + d.offset,
+            c.children,
+            c.dictionary,
+            c.owner,
+            -1,
+        ) for c in d.children
+    ]
+    return AC.RecordBatch(sch, columns, d.len)
+end
diff --git a/src/eltypes.jl b/src/eltypes.jl
deleted file mode 100644
index 52dbb809..00000000
--- a/src/eltypes.jl
+++ /dev/null
@@ -1,578 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""
-Given a flatbuffers metadata type definition (a Field instance from Schema.fbs),
-translate to the appropriate Julia storage eltype
-"""
-function juliaeltype end
-
-finaljuliatype(T) = T
-finaljuliatype(::Type{Missing}) = Missing
-finaljuliatype(::Type{Union{T,Missing}}) where {T} = Union{Missing,finaljuliatype(T)}
-
-"""
-Given a FlatBuffers.Builder and a Julia column or column eltype,
-Write the field.type flatbuffer definition of the eltype
-"""
-function arrowtype end
-
-arrowtype(b, col::AbstractVector{T}) where {T} = arrowtype(b, maybemissing(T))
-arrowtype(b, col::DictEncoded) = arrowtype(b, col.encoding.data)
-arrowtype(b, col::Compressed) = arrowtype(b, col.data)
-
-function juliaeltype(f::Meta.Field, ::Nothing, convert::Bool)
-    T = juliaeltype(f, convert)
-    return convert ? finaljuliatype(T) : T
-end
-
-function juliaeltype(f::Meta.Field, meta::AbstractDict{String,String}, convert::Bool)
-    TT = juliaeltype(f, convert)
-    !convert && return TT
-    T = finaljuliatype(TT)
-    if haskey(meta, "ARROW:extension:name")
-        typename = meta["ARROW:extension:name"]
-        metadata = get(meta, "ARROW:extension:metadata", "")
-        JT = ArrowTypes.JuliaType(Val(Symbol(typename)), maybemissing(TT), metadata)
-        if JT !== nothing
-            return f.nullable ? Union{JT,Missing} : JT
-        else
-            @warn "unsupported ARROW:extension:name type: \"$typename\", arrow type = $TT" maxlog =
-                1 _id = hash((:juliaeltype, typename, TT))
-        end
-    end
-    return something(TT, T)
-end
-
-function juliaeltype(f::Meta.Field, convert::Bool)
-    T = juliaeltype(f, f.type, convert)
-    return f.nullable ? Union{T,Missing} : T
-end
-
-juliaeltype(f::Meta.Field, ::Meta.Null, convert) = Missing
-
-function arrowtype(b, ::Type{Missing})
-    Meta.nullStart(b)
-    return Meta.Null, Meta.nullEnd(b), nothing
-end
-
-function juliaeltype(f::Meta.Field, int::Meta.Int, convert)
-    if int.is_signed
-        if int.bitWidth == 8
-            Int8
-        elseif int.bitWidth == 16
-            Int16
-        elseif int.bitWidth == 32
-            Int32
-        elseif int.bitWidth == 64
-            Int64
-        elseif int.bitWidth == 128
-            Int128
-        else
-            error("$int is not valid arrow type metadata")
-        end
-    else
-        if int.bitWidth == 8
-            UInt8
-        elseif int.bitWidth == 16
-            UInt16
-        elseif int.bitWidth == 32
-            UInt32
-        elseif int.bitWidth == 64
-            UInt64
-        elseif int.bitWidth == 128
-            UInt128
-        else
-            error("$int is not valid arrow type metadata")
-        end
-    end
-end
-
-function arrowtype(b, ::Type{T}) where {T<:Integer}
-    Meta.intStart(b)
-    Meta.intAddBitWidth(b, Int32(8 * sizeof(T)))
-    Meta.intAddIsSigned(b, T <: Signed)
-    return Meta.Int, Meta.intEnd(b), nothing
-end
-
-# primitive types
-function juliaeltype(f::Meta.Field, fp::Meta.FloatingPoint, convert)
-    if fp.precision == Meta.Precision.HALF
-        Float16
-    elseif fp.precision == Meta.Precision.SINGLE
-        Float32
-    elseif fp.precision == Meta.Precision.DOUBLE
-        Float64
-    end
-end
-
-function arrowtype(b, ::Type{T}) where {T<:AbstractFloat}
-    Meta.floatingPointStart(b)
-    Meta.floatingPointAddPrecision(
-        b,
-        T === Float16 ? Meta.Precision.HALF :
-        T === Float32 ? Meta.Precision.SINGLE : Meta.Precision.DOUBLE,
-    )
-    return Meta.FloatingPoint, Meta.floatingPointEnd(b), nothing
-end
-
-juliaeltype(f::Meta.Field, b::Union{Meta.Utf8,Meta.LargeUtf8,Meta.Utf8View}, convert) =
-    String
-
-datasizeof(x) = sizeof(x)
-datasizeof(x::AbstractVector) = sum(datasizeof, x)
-
-juliaeltype(
-    f::Meta.Field,
-    b::Union{Meta.Binary,Meta.LargeBinary,Meta.BinaryView},
-    convert,
-) = Base.CodeUnits
-
-juliaeltype(f::Meta.Field, x::Meta.FixedSizeBinary, convert) =
-    NTuple{Int(x.byteWidth),UInt8}
-
-# arggh!
-Base.write(io::IO, x::NTuple{N,T}) where {N,T} = sum(y -> Base.write(io, y), x)
-
-juliaeltype(f::Meta.Field, x::Meta.Bool, convert) = Bool
-
-function arrowtype(b, ::Type{Bool})
-    Meta.boolStart(b)
-    return Meta.Bool, Meta.boolEnd(b), nothing
-end
-
-struct Decimal{P,S,T}
-    value::T # only Int128 or Int256
-end
-
-Base.zero(::Type{Decimal{P,S,T}}) where {P,S,T} = Decimal{P,S,T}(T(0))
-==(a::Decimal{P,S,T}, b::Decimal{P,S,T}) where {P,S,T} = ==(a.value, b.value)
-Base.isequal(a::Decimal{P,S,T}, b::Decimal{P,S,T}) where {P,S,T} = isequal(a.value, b.value)
-
-function juliaeltype(f::Meta.Field, x::Meta.Decimal, convert)
-    return Decimal{x.precision,x.scale,x.bitWidth == 256 ? Int256 : Int128}
-end
-
-ArrowTypes.ArrowKind(::Type{<:Decimal}) = PrimitiveKind()
-
-function arrowtype(b, ::Type{Decimal{P,S,T}}) where {P,S,T}
-    Meta.decimalStart(b)
-    Meta.decimalAddPrecision(b, Int32(P))
-    Meta.decimalAddScale(b, Int32(S))
-    Meta.decimalAddBitWidth(b, Int32(T == Int256 ? 256 : 128))
-    return Meta.Decimal, Meta.decimalEnd(b), nothing
-end
-
-Base.write(io::IO, x::Decimal) = Base.write(io, x.value)
-
-abstract type ArrowTimeType end
-Base.write(io::IO, x::ArrowTimeType) = Base.write(io, x.x)
-ArrowTypes.ArrowKind(::Type{<:ArrowTimeType}) = PrimitiveKind()
-
-struct Date{U,T} <: ArrowTimeType
-    x::T
-end
-
-const DATE = Date{Meta.DateUnit.DAY,Int32}
-Base.zero(::Type{Date{U,T}}) where {U,T} = Date{U,T}(T(0))
-storagetype(::Type{Date{U,T}}) where {U,T} = T
-bitwidth(x::Meta.DateUnit.T) = x == Meta.DateUnit.DAY ? Int32 : Int64
-Date{Meta.DateUnit.DAY}(days) = DATE(Int32(days))
-Date{Meta.DateUnit.MILLISECOND}(ms) = Date{Meta.DateUnit.MILLISECOND,Int64}(Int64(ms))
-
-juliaeltype(f::Meta.Field, x::Meta.Date, convert) = Date{x.unit,bitwidth(x.unit)}
-finaljuliatype(::Type{DATE}) = Dates.Date
-Base.convert(::Type{Dates.Date}, x::DATE) =
-    Dates.Date(Dates.UTD(Int64(x.x + UNIX_EPOCH_DATE)))
-finaljuliatype(::Type{Date{Meta.DateUnit.MILLISECOND,Int64}}) = Dates.DateTime
-Base.convert(::Type{Dates.DateTime}, x::Date{Meta.DateUnit.MILLISECOND,Int64}) =
-    Dates.DateTime(Dates.UTM(Int64(x.x + UNIX_EPOCH_DATETIME)))
-
-function arrowtype(b, ::Type{Date{U,T}}) where {U,T}
-    Meta.dateStart(b)
-    Meta.dateAddUnit(b, U)
-    return Meta.Date, Meta.dateEnd(b), nothing
-end
-
-const UNIX_EPOCH_DATE = Dates.value(Dates.Date(1970))
-Base.convert(::Type{DATE}, x::Dates.Date) = DATE(Int32(Dates.value(x) - UNIX_EPOCH_DATE))
-
-const UNIX_EPOCH_DATETIME = Dates.value(Dates.DateTime(1970))
-Base.convert(::Type{Date{Meta.DateUnit.MILLISECOND,Int64}}, x::Dates.DateTime) =
-    Date{Meta.DateUnit.MILLISECOND,Int64}(Int64(Dates.value(x) - UNIX_EPOCH_DATETIME))
-
-ArrowTypes.ArrowType(::Type{Dates.Date}) = DATE
-ArrowTypes.toarrow(x::Dates.Date) = convert(DATE, x)
-const DATE_SYMBOL = Symbol("JuliaLang.Date")
-ArrowTypes.arrowname(::Type{Dates.Date}) = DATE_SYMBOL
-ArrowTypes.JuliaType(::Val{DATE_SYMBOL}, S) = Dates.Date
-ArrowTypes.fromarrow(::Type{Dates.Date}, x::DATE) = convert(Dates.Date, x)
-ArrowTypes.default(::Type{Dates.Date}) = Dates.Date(1, 1, 1)
-
-struct Time{U,T} <: ArrowTimeType
-    x::T
-end
-
-Base.zero(::Type{Time{U,T}}) where {U,T} = Time{U,T}(T(0))
-const TIME = Time{Meta.TimeUnit.NANOSECOND,Int64}
-
-bitwidth(x::Meta.TimeUnit.T) =
-    x == Meta.TimeUnit.SECOND || x == Meta.TimeUnit.MILLISECOND ? Int32 : Int64
-Time{U}(x) where {U<:Meta.TimeUnit.T} = Time{U,bitwidth(U)}(bitwidth(U)(x))
-storagetype(::Type{Time{U,T}}) where {U,T} = T
-juliaeltype(f::Meta.Field, x::Meta.Time, convert) = Time{x.unit,bitwidth(x.unit)}
-finaljuliatype(::Type{<:Time}) = Dates.Time
-periodtype(U::Meta.TimeUnit.T) =
-    U === Meta.TimeUnit.SECOND ? Dates.Second :
-    U === Meta.TimeUnit.MILLISECOND ? Dates.Millisecond :
-    U === Meta.TimeUnit.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
-Base.convert(::Type{Dates.Time}, x::Time{U,T}) where {U,T} =
-    Dates.Time(Dates.Nanosecond(Dates.tons(periodtype(U)(x.x))))
-
-function arrowtype(b, ::Type{Time{U,T}}) where {U,T}
-    Meta.timeStart(b)
-    Meta.timeAddUnit(b, U)
-    Meta.timeAddBitWidth(b, Int32(8 * sizeof(T)))
-    return Meta.Time, Meta.timeEnd(b), nothing
-end
-
-Base.convert(::Type{TIME}, x::Dates.Time) = TIME(Dates.value(x))
-
-ArrowTypes.ArrowType(::Type{Dates.Time}) = TIME
-ArrowTypes.toarrow(x::Dates.Time) = convert(TIME, x)
-const TIME_SYMBOL = Symbol("JuliaLang.Time")
-ArrowTypes.arrowname(::Type{Dates.Time}) = TIME_SYMBOL
-ArrowTypes.JuliaType(::Val{TIME_SYMBOL}, S) = Dates.Time
-ArrowTypes.fromarrow(::Type{Dates.Time}, x::Arrow.Time) = convert(Dates.Time, x)
-ArrowTypes.default(::Type{Dates.Time}) = Dates.Time(1, 1, 1)
-
-struct Timestamp{U,TZ} <: ArrowTimeType
-    x::Int64
-end
-
-Base.zero(::Type{Timestamp{U,T}}) where {U,T} = Timestamp{U,T}(Int64(0))
-
-function juliaeltype(f::Meta.Field, x::Meta.Timestamp, convert)
-    return Timestamp{x.unit,x.timezone === nothing ? nothing : Symbol(x.timezone)}
-end
-
-const DATETIME = Timestamp{Meta.TimeUnit.MILLISECOND,nothing}
-
-finaljuliatype(::Type{Timestamp{U,TZ}}) where {U,TZ} = ZonedDateTime
-finaljuliatype(::Type{Timestamp{U,nothing}}) where {U} = DateTime
-
-@noinline warntimestamp(U, T) =
-    @warn "automatically converting Arrow.Timestamp with precision = $U to `$T` which only supports millisecond precision; conversion may be lossy; to avoid converting, pass `Arrow.Table(source; convert=false)" maxlog =
-        1 _id = hash((:warntimestamp, U, T))
-
-function Base.convert(::Type{ZonedDateTime}, x::Timestamp{U,TZ}) where {U,TZ}
-    (U === Meta.TimeUnit.MICROSECOND || U == Meta.TimeUnit.NANOSECOND) &&
-        warntimestamp(U, ZonedDateTime)
-    return ZonedDateTime(
-        Dates.DateTime(
-            Dates.UTM(Int64(Dates.toms(periodtype(U)(x.x)) + UNIX_EPOCH_DATETIME)),
-        ),
-        TimeZone(String(TZ));
-        from_utc=true,
-    )
-end
-
-function Base.convert(::Type{DateTime}, x::Timestamp{U,nothing}) where {U}
-    (U === Meta.TimeUnit.MICROSECOND || U == Meta.TimeUnit.NANOSECOND) &&
-        warntimestamp(U, DateTime)
-    return Dates.DateTime(
-        Dates.UTM(Int64(Dates.toms(periodtype(U)(x.x)) + UNIX_EPOCH_DATETIME)),
-    )
-end
-
-Base.convert(::Type{Timestamp{Meta.TimeUnit.MILLISECOND,TZ}}, x::ZonedDateTime) where {TZ} =
-    Timestamp{Meta.TimeUnit.MILLISECOND,TZ}(
-        Int64(Dates.value(DateTime(x, UTC)) - UNIX_EPOCH_DATETIME),
-    )
-Base.convert(::Type{Timestamp{Meta.TimeUnit.MILLISECOND,nothing}}, x::DateTime) =
-    Timestamp{Meta.TimeUnit.MILLISECOND,nothing}(
-        Int64(Dates.value(x) - UNIX_EPOCH_DATETIME),
-    )
-
-function arrowtype(b, ::Type{Timestamp{U,TZ}}) where {U,TZ}
-    tz = TZ !== nothing ? FlatBuffers.createstring!(b, String(TZ)) : FlatBuffers.UOffsetT(0)
-    Meta.timestampStart(b)
-    Meta.timestampAddUnit(b, U)
-    Meta.timestampAddTimezone(b, tz)
-    return Meta.Timestamp, Meta.timestampEnd(b), nothing
-end
-
-ArrowTypes.ArrowType(::Type{Dates.DateTime}) = DATETIME
-ArrowTypes.toarrow(x::Dates.DateTime) = convert(DATETIME, x)
-const DATETIME_SYMBOL = Symbol("JuliaLang.DateTime")
-ArrowTypes.arrowname(::Type{Dates.DateTime}) = DATETIME_SYMBOL
-ArrowTypes.JuliaType(::Val{DATETIME_SYMBOL}, S) = Dates.DateTime
-ArrowTypes.fromarrow(::Type{Dates.DateTime}, x::Timestamp) = convert(Dates.DateTime, x)
-ArrowTypes.fromarrow(::Type{Dates.DateTime}, x::Date{Meta.DateUnit.MILLISECOND,Int64}) =
-    convert(Dates.DateTime, x)
-ArrowTypes.default(::Type{Dates.DateTime}) = Dates.DateTime(1, 1, 1, 1, 1, 1)
-
-ArrowTypes.ArrowType(::Type{ZonedDateTime}) = Timestamp
-ArrowTypes.toarrow(x::ZonedDateTime) =
-    convert(Timestamp{Meta.TimeUnit.MILLISECOND,Symbol(x.timezone)}, x)
-const ZONEDDATETIME_SYMBOL = Symbol("JuliaLang.ZonedDateTime-UTC")
-ArrowTypes.arrowname(::Type{ZonedDateTime}) = ZONEDDATETIME_SYMBOL
-ArrowTypes.JuliaType(::Val{ZONEDDATETIME_SYMBOL}, S) = ZonedDateTime
-ArrowTypes.fromarrow(::Type{ZonedDateTime}, x::Timestamp) = convert(ZonedDateTime, x)
-ArrowTypes.default(::Type{TimeZones.ZonedDateTime}) =
-    TimeZones.ZonedDateTime(1, 1, 1, 1, 1, 1, TimeZones.tz"UTC")
-
-# Backwards compatibility: older versions of Arrow saved ZonedDateTime's with this metdata:
-const OLD_ZONEDDATETIME_SYMBOL = Symbol("JuliaLang.ZonedDateTime")
-# and stored the local time instead of the UTC time.
-struct LocalZonedDateTime end
-ArrowTypes.JuliaType(::Val{OLD_ZONEDDATETIME_SYMBOL}, S) = LocalZonedDateTime
-function ArrowTypes.fromarrow(::Type{LocalZonedDateTime}, x::Timestamp{U,TZ}) where {U,TZ}
-    (U === Meta.TimeUnit.MICROSECOND || U == Meta.TimeUnit.NANOSECOND) &&
-        warntimestamp(U, ZonedDateTime)
-    return ZonedDateTime(
-        Dates.DateTime(
-            Dates.UTM(Int64(Dates.toms(periodtype(U)(x.x)) + UNIX_EPOCH_DATETIME)),
-        ),
-        TimeZone(String(TZ)),
-    )
-end
-
-"""
-    Arrow.ToTimestamp(x::AbstractVector{ZonedDateTime})
-
-Wrapper array that provides a more efficient encoding of `ZonedDateTime` elements to the arrow format. In the arrow format,
-timestamp columns with timezone information are encoded as the arrow equivalent of a Julia type parameter, meaning an entire column
-_should_ have elements all with the same timezone. If a `ZonedDateTime` column is passed to `Arrow.write`, for correctness, it must
-scan each element to check each timezone. `Arrow.ToTimestamp` provides a "bypass" of this process by encoding the timezone of the
-first element of the `AbstractVector{ZonedDateTime}`, which in turn allows `Arrow.write` to avoid costly checking/conversion and
-can encode the `ZonedDateTime` as `Arrow.Timestamp` directly.
-"""
-struct ToTimestamp{A,TZ} <: AbstractVector{Timestamp{Meta.TimeUnit.MILLISECOND,TZ}}
-    data::A # AbstractVector{ZonedDateTime}
-end
-
-ToTimestamp(x::A) where {A<:AbstractVector{ZonedDateTime}} =
-    ToTimestamp{A,Symbol(x[1].timezone)}(x)
-Base.IndexStyle(::Type{<:ToTimestamp}) = Base.IndexLinear()
-Base.size(x::ToTimestamp) = (length(x.data),)
-Base.eltype(::Type{ToTimestamp{A,TZ}}) where {A,TZ} =
-    Timestamp{Meta.TimeUnit.MILLISECOND,TZ}
-Base.getindex(x::ToTimestamp{A,TZ}, i::Integer) where {A,TZ} =
-    convert(Timestamp{Meta.TimeUnit.MILLISECOND,TZ}, getindex(x.data, i))
-
-struct Interval{U,T} <: ArrowTimeType
-    x::T
-end
-
-Base.zero(::Type{Interval{U,T}}) where {U,T} = Interval{U,T}(T(0))
-
-bitwidth(x::Meta.IntervalUnit.T) = x == Meta.IntervalUnit.YEAR_MONTH ? Int32 : Int64
-Interval{Meta.IntervalUnit.YEAR_MONTH}(x) =
-    Interval{Meta.IntervalUnit.YEAR_MONTH,Int32}(Int32(x))
-Interval{Meta.IntervalUnit.DAY_TIME}(x) =
-    Interval{Meta.IntervalUnit.DAY_TIME,Int64}(Int64(x))
-
-function juliaeltype(f::Meta.Field, x::Meta.Interval, convert)
-    return Interval{x.unit,bitwidth(x.unit)}
-end
-
-function arrowtype(b, ::Type{Interval{U,T}}) where {U,T}
-    Meta.intervalStart(b)
-    Meta.intervalAddUnit(b, U)
-    return Meta.Interval, Meta.intervalEnd(b), nothing
-end
-
-struct Duration{U} <: ArrowTimeType
-    x::Int64
-end
-
-Base.zero(::Type{Duration{U}}) where {U} = Duration{U}(Int64(0))
-
-function juliaeltype(f::Meta.Field, x::Meta.Duration, convert)
-    return Duration{x.unit}
-end
-
-finaljuliatype(::Type{Duration{U}}) where {U} = periodtype(U)
-Base.convert(::Type{P}, x::Duration{U}) where {P<:Dates.Period,U} = P(periodtype(U)(x.x))
-
-function arrowtype(b, ::Type{Duration{U}}) where {U}
-    Meta.durationStart(b)
-    Meta.durationAddUnit(b, U)
-    return Meta.Duration, Meta.durationEnd(b), nothing
-end
-
-arrowtype(b, ::Type{P}) where {P<:Dates.Period} = arrowtype(b, Duration{arrowperiodtype(P)})
-
-arrowperiodtype(P) = Meta.TimeUnit.SECOND
-arrowperiodtype(::Type{Dates.Millisecond}) = Meta.TimeUnit.MILLISECOND
-arrowperiodtype(::Type{Dates.Microsecond}) = Meta.TimeUnit.MICROSECOND
-arrowperiodtype(::Type{Dates.Nanosecond}) = Meta.TimeUnit.NANOSECOND
-
-Base.convert(::Type{Duration{U}}, x::Dates.Period) where {U} =
-    Duration{U}(Dates.value(periodtype(U)(x)))
-
-ArrowTypes.ArrowType(::Type{P}) where {P<:Dates.Period} = Duration{arrowperiodtype(P)}
-ArrowTypes.toarrow(x::P) where {P<:Dates.Period} = convert(Duration{arrowperiodtype(P)}, x)
-const PERIOD_SYMBOL = Symbol("JuliaLang.Dates.Period")
-ArrowTypes.arrowname(::Type{P}) where {P<:Dates.Period} = PERIOD_SYMBOL
-ArrowTypes.JuliaType(::Val{PERIOD_SYMBOL}, ::Type{Duration{U}}) where {U} = periodtype(U)
-ArrowTypes.fromarrow(::Type{P}, x::Duration{U}) where {P<:Dates.Period,U} = convert(P, x)
-
-# nested types; call juliaeltype recursively on nested children
-function juliaeltype(
-    f::Meta.Field,
-    list::Union{Meta.List,Meta.LargeList,Meta.ListView,Meta.LargeListView},
-    convert,
-)
-    return Vector{juliaeltype(f.children[1], buildmetadata(f.children[1]), convert)}
-end
-
-# arrowtype will call fieldoffset recursively for children
-function arrowtype(b, x::List{T,O,A}) where {T,O,A}
-    if liststringtype(x)
-        if T <: AbstractString || T <: Union{AbstractString,Missing}
-            if O == Int32
-                Meta.utf8Start(b)
-                return Meta.Utf8, Meta.utf8End(b), nothing
-            else # if O == Int64
-                Meta.largUtf8Start(b)
-                return Meta.LargeUtf8, Meta.largUtf8End(b), nothing
-            end
-        else # if Base.CodeUnits
-            if O == Int32
-                Meta.binaryStart(b)
-                return Meta.Binary, Meta.binaryEnd(b), nothing
-            else # if O == Int64
-                Meta.largeBinaryStart(b)
-                return Meta.LargeBinary, Meta.largeBinaryEnd(b), nothing
-            end
-        end
-    else
-        children = [fieldoffset(b, "", x.data)]
-        if O == Int32
-            Meta.listStart(b)
-            return Meta.List, Meta.listEnd(b), children
-        else
-            Meta.largeListStart(b)
-            return Meta.LargeList, Meta.largeListEnd(b), children
-        end
-    end
-end
-
-function juliaeltype(f::Meta.Field, list::Meta.FixedSizeList, convert)
-    type = juliaeltype(f.children[1], buildmetadata(f.children[1]), convert)
-    return NTuple{Int(list.listSize),type}
-end
-
-function arrowtype(b, x::FixedSizeList{T,A}) where {T,A}
-    N = ArrowTypes.getsize(
-        ArrowTypes.ArrowKind(ArrowTypes.ArrowType(Base.nonmissingtype(T))),
-    )
-    if eltype(A) == UInt8
-        Meta.fixedSizeBinaryStart(b)
-        Meta.fixedSizeBinaryAddByteWidth(b, Int32(N))
-        return Meta.FixedSizeBinary, Meta.fixedSizeBinaryEnd(b), nothing
-    else
-        children = [fieldoffset(b, "", x.data)]
-        Meta.fixedSizeListStart(b)
-        Meta.fixedSizeListAddListSize(b, Int32(N))
-        return Meta.FixedSizeList, Meta.fixedSizeListEnd(b), children
-    end
-end
-
-function juliaeltype(f::Meta.Field, map::Meta.Map, convert)
-    K = juliaeltype(
-        f.children[1].children[1],
-        buildmetadata(f.children[1].children[1]),
-        convert,
-    )
-    V = juliaeltype(
-        f.children[1].children[2],
-        buildmetadata(f.children[1].children[2]),
-        convert,
-    )
-    return Dict{K,V}
-end
-
-function arrowtype(b, x::Map)
-    children = [fieldoffset(b, "entries", x.data)]
-    Meta.mapStart(b)
-    return Meta.Map, Meta.mapEnd(b), children
-end
-
-struct KeyValue{K,V}
-    key::K
-    value::V
-end
-keyvalueK(::Type{KeyValue{K,V}}) where {K,V} = K
-keyvalueV(::Type{KeyValue{K,V}}) where {K,V} = V
-Base.length(kv::KeyValue) = 1
-Base.iterate(kv::KeyValue, st=1) = st === nothing ? nothing : (kv, nothing)
-ArrowTypes.default(::Type{KeyValue{K,V}}) where {K,V} = KeyValue(default(K), default(V))
-
-function arrowtype(b, ::Type{KeyValue{K,V}}) where {K,V}
-    children = [fieldoffset(b, "key", K), fieldoffset(b, "value", V)]
-    Meta.structStart(b)
-    return Meta.Struct, Meta.structEnd(b), children
-end
-
-function juliaeltype(f::Meta.Field, list::Meta.Struct, convert)
-    names = Tuple(Symbol(x.name) for x in f.children)
-    types = Tuple(juliaeltype(x, buildmetadata(x), convert) for x in f.children)
-    return NamedTuple{names,Tuple{types...}}
-end
-
-function arrowtype(b, x::Struct{T,S}) where {T,S}
-    names = fieldnames(Base.nonmissingtype(T))
-    children = [fieldoffset(b, names[i], x.data[i]) for i = 1:length(names)]
-    Meta.structStart(b)
-    return Meta.Struct, Meta.structEnd(b), children
-end
-
-# Unions
-function UnionT(f::Meta.Field, convert)
-    typeids = f.type.typeIds === nothing ? nothing : Tuple(Int(x) for x in f.type.typeIds)
-    UT = UnionT{
-        f.type.mode,
-        typeids,
-        Tuple{(juliaeltype(x, buildmetadata(x), convert) for x in f.children)...},
-    }
-    return UT
-end
-
-juliaeltype(f::Meta.Field, u::Meta.Union, convert) =
-    Union{(juliaeltype(x, buildmetadata(x), convert) for x in f.children)...}
-
-function arrowtype(
-    b,
-    x::Union{DenseUnion{S,UnionT{T,typeIds,U}},SparseUnion{S,UnionT{T,typeIds,U}}},
-) where {S,T,typeIds,U}
-    if typeIds !== nothing
-        Meta.unionStartTypeIdsVector(b, length(typeIds))
-        for id in Iterators.reverse(typeIds)
-            FlatBuffers.prepend!(b, id)
-        end
-        TI = FlatBuffers.endvector!(b, length(typeIds))
-    end
-    children = [fieldoffset(b, "", x.data[i]) for i = 1:fieldcount(U)]
-    Meta.unionStart(b)
-    Meta.unionAddMode(b, T)
-    if typeIds !== nothing
-        Meta.unionAddTypeIds(b, TI)
-    end
-    return Meta.Union, Meta.unionEnd(b), children
-end
diff --git a/src/ipc_dictionary.jl b/src/ipc_dictionary.jl
new file mode 100644
index 00000000..9aac2061
--- /dev/null
+++ b/src/ipc_dictionary.jl
@@ -0,0 +1,430 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Dictionary updates retain immutable snapshots. Concatenate physical storage,
+# never materialized Julia values: Union routes, nested dictionary indices,
+# logical descriptors, and null payloads must not pass through type inference.
+
+mutable struct _DictionaryRange
+    const data::ArrayData
+    const first::Int64                 # zero-based logical position within data
+    len::Int64
+end
+
+function _dictionaryvector(::Type{T}, n::Integer, limits::Limits, budget) where {T}
+    bytes = AC.checked_mul(Int64(n), Int64(sizeof(T)))
+    bytes <= limits.max_buffer_bytes || _limiterror(
+        "combined dictionary buffer of $bytes bytes",
+        "max_buffer_bytes",
+        limits.max_buffer_bytes,
+    )
+    _chargevector!(budget, T, n, "dictionary concatenation")
+    return zeros(T, n)
+end
+
+function _dictionaryrange!(ranges, data, first, len, budget)
+    len == 0 && return ranges
+    if !isempty(ranges)
+        previous = last(ranges)
+        if previous.data === data && previous.first + previous.len == first
+            previous.len = AC.checked_add(previous.len, len)
+            return ranges
+        end
+    end
+    # Charge capacity growth before push!, including the range object.
+    _chargeobject!(budget, 2 * sizeof(_DictionaryRange), "dictionary child ranges")
+    push!(ranges, _DictionaryRange(data, first, len))
+    return ranges
+end
+
+function _dictionaryput!(
+    bytes::Vector{UInt8},
+    offset::Integer,
+    value::Integer,
+    width::Int;
+    signed=true,
+)
+    bits = 8 * width - signed
+    maximum = bits >= 63 ? typemax(Int64) : (Int64(1) << bits) - 1
+    0 <= value <= maximum ||
+        throw(ValidationError("combined dictionary offset exceeds its integer width"))
+    for k = 0:(width - 1)
+        bytes[offset + k + 1] = UInt8((value >> (8 * k)) & 0xff)
+    end
+end
+
+function _dictionarycopy!(out, dest, src::BufferSlice, first, len)
+    len == 0 && return
+    0 <= dest <= length(out) && 0 <= len <= length(out) - dest ||
+        throw(ValidationError("dictionary copy escapes destination buffer"))
+    # subslice checks the source before exposing bytes.
+    slice = AC.subslice(src, first, len)
+    GC.@preserve out slice begin
+        unsafe_copyto!(pointer(out, dest + 1), AC.sliceptr(slice), len)
+    end
+end
+
+function _dictionarylength(ranges, limits)
+    n = Int64(0)
+    for r in ranges
+        n = AC.checked_add(n, r.len)
+    end
+    n <= limits.max_array_length || _limiterror(
+        "combined dictionary length $n",
+        "max_array_length",
+        limits.max_array_length,
+    )
+    return n
+end
+
+# Also used recursively to compact selected child ranges. Every range points
+# into a pool that has already passed full semantic validation.
+function _dictionaryconcat(f::Field, ranges, limits::Limits, budget)
+    n = _dictionarylength(ranges, limits)
+    t = f.type
+    spec = AC.layoutspec_of(t)
+    _chargeobject!(budget, sizeof(ArrayData), "combined dictionary array")
+    _chargevector!(budget, BufferSlice, length(spec.buffers), "dictionary buffers")
+    _chargevector!(budget, ArrayData, length(f.children), "dictionary children")
+    buffers = BufferSlice[]
+    children = ArrayData[]
+    dictionary = nothing
+    nc = Int64(0)
+    if !isempty(spec.buffers) && spec.buffers[1] == AC.VALIDITY
+        validity = _dictionaryvector(UInt8, cld(n, 8), limits, budget)
+        k = 0
+        for r in ranges, i = (r.first + 1):(r.first + r.len)
+            if AC.isvalid_at(r.data, i)
+                validity[(k >> 3) + 1] |= UInt8(1 << (k & 7))
+            else
+                nc += 1
+            end
+            k += 1
+        end
+        push!(buffers, nc == 0 ? BufferSlice() : AC._databuffer(validity))
+    end
+    if t isa NullType
+        nc = n
+    elseif t isa Union{Utf8Type,BinaryType,ListType,ListViewType,MapType}
+        width = spec.offsetwidth
+        isview = t isa ListViewType
+        isbinary = t isa Union{Utf8Type,BinaryType}
+        offsets = _dictionaryvector(
+            UInt8,
+            AC.checked_mul(n + !isview, Int64(width)),
+            limits,
+            budget,
+        )
+        sizes =
+            isview ?
+            _dictionaryvector(UInt8, AC.checked_mul(n, Int64(width)), limits, budget) :
+            UInt8[]
+        childranges = _DictionaryRange[]
+        total = Int64(0)
+        k = Int64(0)
+        # Compute lengths and child selection before allocating the payload.
+        for r in ranges, i = (r.first + 1):(r.first + r.len)
+            _dictionaryput!(offsets, k * width, total, width)
+            if AC.isvalid_at(r.data, i)
+                lo, hi =
+                    isview ? AC._listview_range(t, r.data, i) :
+                    AC._offsets_at(r.data, i, width == 8)
+                len = isview ? hi : hi - lo
+                isview && _dictionaryput!(sizes, k * width, len, width)
+                total = AC.checked_add(total, len)
+                if !isbinary
+                    total <= limits.max_array_length || _limiterror(
+                        "combined dictionary child length $total",
+                        "max_array_length",
+                        limits.max_array_length,
+                    )
+                    _dictionaryrange!(childranges, r.data.children[1], lo, len, budget)
+                end
+            end
+            k += 1
+        end
+        !isview && _dictionaryput!(offsets, n * width, total, width)
+        push!(buffers, AC._databuffer(offsets))
+        if isbinary
+            payload = _dictionaryvector(UInt8, total, limits, budget)
+            pos = Int64(0)
+            for r in ranges, i = (r.first + 1):(r.first + r.len)
+                AC.isvalid_at(r.data, i) || continue
+                lo, hi = AC._offsets_at(r.data, i, width == 8)
+                _dictionarycopy!(payload, pos, AC.rolebuffer(r.data, AC.DATA), lo, hi - lo)
+                pos += hi - lo
+            end
+            push!(buffers, AC._databuffer(payload))
+        else
+            isview && push!(buffers, AC._databuffer(sizes))
+            push!(children, _dictionaryconcat(f.children[1], childranges, limits, budget))
+        end
+    elseif t isa Union{StructType,FixedSizeListType} ||
+           (t isa UnionType && t.mode == AC.SparseMode)
+        if t isa UnionType
+            ids = _dictionaryvector(UInt8, n, limits, budget)
+            k = 0
+            for r in ranges
+                _dictionarycopy!(
+                    ids,
+                    k,
+                    AC.rolebuffer(r.data, AC.TYPE_IDS),
+                    r.data.offset + r.first,
+                    r.len,
+                )
+                k += r.len
+            end
+            push!(buffers, AC._databuffer(ids))
+        end
+        width = t isa FixedSizeListType ? Int64(t.listsize) : Int64(1)
+        for j in eachindex(f.children)
+            childranges = _DictionaryRange[]
+            for r in ranges
+                _dictionaryrange!(
+                    childranges,
+                    r.data.children[j],
+                    AC.checked_mul(r.data.offset + r.first, width),
+                    AC.checked_mul(r.len, width),
+                    budget,
+                )
+            end
+            push!(children, _dictionaryconcat(f.children[j], childranges, limits, budget))
+        end
+    elseif t isa UnionType
+        ids = _dictionaryvector(UInt8, n, limits, budget)
+        offsets = _dictionaryvector(UInt8, AC.checked_mul(n, Int64(4)), limits, budget)
+        _chargevector!(
+            budget,
+            Vector{_DictionaryRange},
+            length(f.children),
+            "dictionary union routes",
+        )
+        routes = [_DictionaryRange[] for _ in f.children]
+        counts = _dictionaryvector(Int64, length(f.children), limits, budget)
+        k = Int64(0)
+        for r in ranges, i = (r.first + 1):(r.first + r.len)
+            tid = AC.loadat(AC.rolebuffer(r.data, AC.TYPE_IDS), Int8, r.data.offset + i - 1)
+            j = findfirst(==(tid), t.typeids)::Int
+            off = Int64(
+                AC.loadat(
+                    AC.rolebuffer(r.data, AC.ELEMENT_OFFSETS),
+                    Int32,
+                    (r.data.offset + i - 1) * 4,
+                ),
+            )
+            ids[k + 1] = reinterpret(UInt8, tid)
+            _dictionaryput!(offsets, k * 4, counts[j], 4)
+            _dictionaryrange!(routes[j], r.data.children[j], off, Int64(1), budget)
+            counts[j] += 1
+            k += 1
+        end
+        append!(buffers, (AC._databuffer(ids), AC._databuffer(offsets)))
+        for j in eachindex(f.children)
+            push!(children, _dictionaryconcat(f.children[j], routes[j], limits, budget))
+        end
+    elseif t isa RunEndEncodedType
+        # Intersect physical runs with each requested logical range. This
+        # handles sliced/overlong last runs without expanding one value per row.
+        runranges = _DictionaryRange[]
+        _chargevector!(budget, Int64, 0, "dictionary run ends")
+        ends = Int64[]
+        total = Int64(0)
+        for r in ranges
+            pos = r.first + 1
+            stop = r.first + r.len
+            while pos <= stop
+                run = AC._ree_runindex(r.data, pos)
+                runend =
+                    Int64(AC.getvalue(f.children[1], r.data.children[1], run)) -
+                    r.data.offset
+                len = min(runend, stop) - pos + 1
+                total = AC.checked_add(total, len)
+                _chargeobject!(budget, 2 * sizeof(Int64), "dictionary run ends")
+                push!(ends, total)
+                _dictionaryrange!(runranges, r.data.children[2], run - 1, Int64(1), budget)
+                pos += len
+            end
+        end
+        _chargeobject!(budget, sizeof(ArrayData), "dictionary run-end array")
+        _chargevector!(budget, BufferSlice, 2, "dictionary run-end buffers")
+        rt = f.children[1].type::IntType
+        width = AC.primwidth(rt)
+        data = _dictionaryvector(
+            UInt8,
+            AC.checked_mul(Int64(length(ends)), Int64(width)),
+            limits,
+            budget,
+        )
+        for (i, value) in enumerate(ends)
+            _dictionaryput!(data, (i - 1) * width, value, width)
+        end
+        push!(
+            children,
+            ArrayData(rt, length(ends), [BufferSlice(), AC._databuffer(data)]; nullcount=0),
+        )
+        push!(children, _dictionaryconcat(f.children[2], runranges, limits, budget))
+    elseif t isa ViewType
+        views = _dictionaryvector(UInt8, AC.checked_mul(n, Int64(16)), limits, budget)
+        # Keep long-value buffers borrowed; only descriptors need rebasing.
+        _chargedict!(budget, ArrayData, Int64, length(ranges), "dictionary view buffers")
+        bases = IdDict{ArrayData,Int64}()
+        databuffers = BufferSlice[]
+        k = Int64(0)
+        for r in ranges
+            base = get(bases, r.data, Int64(-1))
+            if base < 0
+                base = Int64(length(databuffers))
+                bases[r.data] = base
+                _chargevector!(
+                    budget,
+                    BufferSlice,
+                    2 * (length(r.data.buffers) - 2),
+                    "dictionary view buffers",
+                )
+                append!(databuffers, r.data.buffers[3:end])
+            end
+            for i = (r.first + 1):(r.first + r.len)
+                if AC.isvalid_at(r.data, i)
+                    src = AC.rolebuffer(r.data, AC.VIEWS)
+                    off = (r.data.offset + i - 1) * 16
+                    _dictionarycopy!(views, k * 16, src, off, Int64(16))
+                    if AC.loadat(src, Int32, off) > AC.VIEW_INLINE_MAX
+                        idx = AC.loadat(src, Int32, off + 8)
+                        _dictionaryput!(
+                            views,
+                            k * 16 + 8,
+                            AC.checked_add(base, Int64(idx)),
+                            4,
+                        )
+                    end
+                end
+                k += 1
+            end
+        end
+        push!(buffers, AC._databuffer(views))
+        append!(buffers, databuffers)
+    elseif t isa DictionaryType
+        # Nested dictionary values can refer to different snapshots. Concatenate
+        # unique pools and rebase their indices, preserving their value routes.
+        _chargedict!(budget, ArrayData, Int64, length(ranges), "nested dictionary pools")
+        bases = IdDict{ArrayData,Int64}()
+        poolranges = _DictionaryRange[]
+        total = Int64(0)
+        for r in ranges
+            pool = r.data.dictionary::ArrayData
+            if !haskey(bases, pool)
+                bases[pool] = total
+                _dictionaryrange!(poolranges, pool, Int64(0), pool.len, budget)
+                total = AC.checked_add(total, pool.len)
+            end
+        end
+        dictionary =
+            length(poolranges) == 1 ? poolranges[1].data :
+            _dictionaryconcat(AC.dictvaluefield(f, t), poolranges, limits, budget)
+        width = AC.primwidth(t.indextype)
+        data = _dictionaryvector(UInt8, AC.checked_mul(n, Int64(width)), limits, budget)
+        k = Int64(0)
+        for r in ranges, i = (r.first + 1):(r.first + r.len)
+            if AC.isvalid_at(r.data, i)
+                idx = AC._load_int(
+                    AC.rolebuffer(r.data, AC.DATA),
+                    t.indextype,
+                    (r.data.offset + i - 1) * width,
+                )
+                value = AC.checked_add(bases[r.data.dictionary], Int64(idx))
+                _dictionaryput!(data, k * width, value, width; signed=t.indextype.signed)
+            end
+            k += 1
+        end
+        push!(buffers, AC._databuffer(data))
+    elseif t isa BoolType
+        data = _dictionaryvector(UInt8, cld(n, 8), limits, budget)
+        k = Int64(0)
+        for r in ranges, i = (r.first + 1):(r.first + r.len)
+            if AC.getbit(AC.rolebuffer(r.data, AC.DATA), r.data.offset + i - 1)
+                data[(k >> 3) + 1] |= UInt8(1 << (k & 7))
+            end
+            k += 1
+        end
+        push!(buffers, AC._databuffer(data))
+    else
+        width = spec.fixedwidth
+        width >= 0 || throw(ValidationError("unsupported dictionary value layout"))
+        data = _dictionaryvector(UInt8, AC.checked_mul(n, Int64(width)), limits, budget)
+        k = Int64(0)
+        for r in ranges
+            len = AC.checked_mul(r.len, Int64(width))
+            _dictionarycopy!(
+                data,
+                k,
+                AC.rolebuffer(r.data, AC.DATA),
+                AC.checked_mul(r.data.offset + r.first, Int64(width)),
+                len,
+            )
+            k += len
+        end
+        push!(buffers, AC._databuffer(data))
+    end
+    return ArrayData(t, n, buffers; children, dictionary, nullcount=nc)
+end
+
+function _dictionarytransition(id, isdelta, present; file=false)
+    isdelta &&
+        !present &&
+        throw(ValidationError("delta dictionary id $id has no base dictionary"))
+    file &&
+        !isdelta &&
+        present &&
+        throw(ValidationError("dictionary replacement is forbidden in the IPC file format"))
+    return nothing
+end
+
+function _updatedictionary!(
+    dicts,
+    validated,
+    id,
+    isdelta,
+    vf,
+    decoded,
+    limits,
+    budget;
+    file=false,
+)
+    _dictionarytransition(id, isdelta, haskey(dicts, id); file)
+    validate_semantic(vf, decoded)
+    if isdelta
+        previous = dicts[id]
+        if decoded.len == 0
+            return previous
+        end
+        _chargevector!(budget, _DictionaryRange, 2, "dictionary delta ranges")
+        _chargeobject!(budget, 2 * sizeof(_DictionaryRange), "dictionary delta ranges")
+        decoded = _dictionaryconcat(
+            vf,
+            [
+                _DictionaryRange(previous, 0, previous.len),
+                _DictionaryRange(decoded, 0, decoded.len),
+            ],
+            limits,
+            budget,
+        )
+        validate_semantic(vf, decoded)
+    end
+    haskey(dicts, id) && delete!(validated, dicts[id])
+    validated[decoded] = nothing
+    dicts[id] = decoded
+    return decoded
+end
diff --git a/src/ipc_read.jl b/src/ipc_read.jl
new file mode 100644
index 00000000..6de62e8f
--- /dev/null
+++ b/src/ipc_read.jl
@@ -0,0 +1,2754 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# The IPC stream reader and, at the end of this file, the file-format reader
+# (readfile/ArrowFile), as thin peers over ArrowCore.
+#
+#   * Framing: checked spans, the generated FlatBuffers verifier before any
+#     generated getter runs, and explicit resource limits (`Limits` +
+#     `framemessages`) enforced before metadata-directed allocation. The
+#     message body is the decoding AUTHORITY: every wire buffer is first a
+#     checked subslice of its message-body slice, so corrupt metadata cannot
+#     alias the schema message, another batch, or anything else in the file.
+#     Positively compressed buffers are decoded into separate exact-sized
+#     owned regions.
+#
+#   * Decoding: ONE generic recursive decoder (`decodefield`) walks nodes and
+#     buffers in the order `layoutspec` declares; variadic layouts carry
+#     their own bounded count handling.
+#
+#   * IPC bookkeeping stays in the adapter: dictionary ids live in an
+#     adapter-side table; Core Fields carry `DictionaryType` object
+#     references and never see an id.
+#
+#   * Metadata bindings and the verifier are GENERATED from the vendored
+#     apache/arrow format/*.fbs (tools/fbsgen.jl -> src/metadata/) over the
+#     vendored FlatBuffers runtime.
+# =============================================================================
+
+# ---------------------------------------------------------------------------
+# Framing stage: resource limits before metadata-directed decode allocation
+# ---------------------------------------------------------------------------
+
+const _DEFAULT_MAX_NEW_SYMBOLS = 1_000_000
+
+"""
+    Arrow.Limits(; keyword arguments...)
+
+Resource limits for an Arrow IPC reader. Each bound is checked before the
+work it governs can exceed it.
+
+| keyword                     | default         | bounds                              |
+|:----------------------------|:----------------|:------------------------------------|
+| `max_metadata_bytes`        | 16 MiB          | metadata per message                |
+| `max_body_bytes`            | none            | one message body                    |
+| `max_buffer_bytes`          | none            | one buffer, compressed or not       |
+| `max_total_allocated_bytes` | physical memory | allocation per read or stream batch |
+| `max_allocation_ratio`      | 64              | allocation per input byte           |
+| `max_messages`              | 1,000,000       | messages per file or `Arrow.Table`  |
+| `max_metadata_objects`      | 1,000,000       | flatbuffer objects per message      |
+| `max_nesting_depth`         | 64              | schema and metadata nesting         |
+| `max_array_length`          | 1,000,000,000   | array length                        |
+| `max_concurrent_reads`      | 64              | concurrent range reads              |
+| `max_new_symbols`           | 1,000,000       | new `Symbol` values per read        |
+
+A read may allocate `max_allocation_ratio` bytes per byte of its input (the
+file, buffer, IO, or object), at least 256 MiB, and at most
+`max_total_allocated_bytes`. A compressed buffer counts at its decompressed
+size, up to the size its column needs, so a compressed file reads with the
+allowance it would have uncompressed. Each batch an [`Arrow.Stream`](@ref)
+yields gets its own allowance from its own bytes. Ordinary columns cost a
+small multiple of their stored bytes, so files of any size and compression
+ratio read with the defaults; lengths a small malformed file declares without
+the bytes to back them (run-end encoded, view, null-child, or decompressed
+lengths beyond what the columns need) fail before they are allocated. Raise
+`max_allocation_ratio` for trusted data that expands further, such as long runs
+or heavily repeated dictionary values.
+
+A `Symbol` column (Julia's `JuliaLang.Symbol` extension) creates the `Symbol`s
+this process has not seen yet, and Julia never frees them, so a read (or one
+stream batch) creates at most `max_new_symbols`; a column needing more is
+refused before any of its values is converted. `select=[:col => String]` reads
+such a column as strings instead.
+
+Pass a `Limits` value as the `limits` keyword to [`Arrow.Table`](@ref) or
+[`Arrow.Stream`](@ref).
+"""
+Base.@kwdef struct Limits
+    max_metadata_bytes::Int64 = 16 * 1024 * 1024
+    max_body_bytes::Int64 = typemax(Int64)
+    max_buffer_bytes::Int64 = typemax(Int64)
+    max_total_allocated_bytes::Int64 = _physicalmemory()
+    max_allocation_ratio::Int64 = 64
+    max_messages::Int = 1_000_000
+    max_metadata_objects::Int = 1_000_000
+    max_nesting_depth::Int = 64
+    max_array_length::Int64 = 1_000_000_000
+    max_concurrent_reads::Int = 64
+    max_new_symbols::Int = _DEFAULT_MAX_NEW_SYMBOLS
+end
+
+_physicalmemory() = Int64(min(Sys.total_memory(), UInt64(typemax(Int64))))
+
+# `left` is charged and refunded with compare-and-swap, so decoding tasks
+# share a budget without a lock. `limit` grows as decompressed input arrives
+# (`ratio` bytes per byte, never past `cap`).
+# A read's budget also carries its `Limits.max_new_symbols`.
+mutable struct AllocationBudget
+    @atomic left::Int64
+    @atomic limit::Int64
+    const ratio::Int64
+    const cap::Int64
+    const maxnewsymbols::Int
+end
+
+function AllocationBudget(
+    limit::Integer;
+    ratio::Integer=0,
+    cap::Integer=limit,
+    maxnewsymbols::Integer=_DEFAULT_MAX_NEW_SYMBOLS,
+)
+    value = Int64(limit)
+    value >= 0 || throw(ArgumentError("allocation budget must be nonnegative"))
+    return AllocationBudget(
+        value,
+        value,
+        Int64(ratio),
+        max(value, Int64(cap)),
+        maxnewsymbols,
+    )
+end
+
+# Below this, a read's budget does not shrink with its input: small files keep
+# the allowance every input had before the budget scaled with input size.
+const _MIN_INPUT_BUDGET = Int64(256) * 1024 * 1024
+
+_saturatingmul(a::Int64, b::Int64) =
+    (p=Base.Checked.mul_with_overflow(a, b); p[2] ? typemax(Int64) : p[1])
+
+"The allocation budget for one read of `nbytes` input bytes (see [`Limits`](@ref))."
+function _readlimit(limits::Limits, nbytes::Integer)
+    perinput = _saturatingmul(limits.max_allocation_ratio, Int64(nbytes))
+    return min(limits.max_total_allocated_bytes, max(_MIN_INPUT_BUDGET, perinput))
+end
+
+_readbudget(limits::Limits, nbytes::Integer) = AllocationBudget(
+    _readlimit(limits, nbytes);
+    ratio=limits.max_allocation_ratio,
+    cap=limits.max_total_allocated_bytes,
+    maxnewsymbols=limits.max_new_symbols,
+)
+
+# Move `limit` to `new` and shift `left` by the same amount (not below 0).
+function _setlimit!(budget::AllocationBudget, old::Int64, new::Int64)
+    _, ok = @atomicreplace budget.limit old => new
+    ok || return false
+    left = @atomic budget.left
+    while true
+        left, done = @atomicreplace budget.left left => max(Int64(0), left + (new - old))
+        done && return true
+    end
+end
+
+"Lower an open read's budget to its input's allowance once the input size is known."
+function _boundbudget!(budget::AllocationBudget, limits::Limits, nbytes::Integer)
+    limit = _readlimit(limits, nbytes)
+    while true
+        old = @atomic budget.limit
+        (limit >= old || _setlimit!(budget, old, limit)) && return budget
+    end
+end
+
+"Raise the allowance as if `extra` more input bytes had been read, up to the cap."
+function _grow!(budget::AllocationBudget, extra::Int64)
+    (budget.ratio > 0 && extra > 0) || return nothing
+    add = _saturatingmul(budget.ratio, extra)
+    while true
+        old = @atomic budget.limit
+        new = min(budget.cap, old > typemax(Int64) - add ? typemax(Int64) : old + add)
+        (new <= old || _setlimit!(budget, old, new)) && return nothing
+    end
+end
+
+"""
+    Arrow.AllocationLimitError
+
+Thrown when a read needs more memory than its allocation budget: `max_allocation_ratio`
+bytes per byte of input, at least 256 MiB and at most `max_total_allocated_bytes`
+([`Arrow.Limits`](@ref)). The message names the fields to raise for trusted input.
+"""
+struct AllocationLimitError <: Exception
+    msg::String
+end
+
+function Base.showerror(io::IO, e::AllocationLimitError)
+    print(
+        io,
+        e.msg,
+        " (Limits.max_allocation_ratio bytes per input byte, at most ",
+        "Limits.max_total_allocated_bytes; to read trusted input that needs more, pass ",
+        "`limits=Arrow.Limits(max_allocation_ratio=..., max_total_allocated_bytes=...)`)",
+    )
+    return nothing
+end
+
+function _charge!(budget::AllocationBudget, amount::Int64, what::AbstractString)
+    amount >= 0 || throw(ArgumentError("negative allocation charge"))
+    left = @atomic budget.left
+    while true
+        amount <= left ||
+            throw(AllocationLimitError("$what exceeds the reader allocation budget"))
+        left, ok = @atomicreplace budget.left left => left - amount
+        ok && return nothing
+    end
+end
+
+function _refund!(budget::AllocationBudget, amount::Int64)
+    amount >= 0 || throw(ArgumentError("negative allocation refund"))
+    left = @atomic budget.left
+    while true
+        refunded = Base.Checked.checked_add(left, amount)
+        refunded <= (@atomic budget.limit) ||
+            throw(ArgumentError("allocation refund exceeds the charged total"))
+        left, ok = @atomicreplace budget.left left => refunded
+        ok && return nothing
+    end
+end
+
+_remaining(budget::AllocationBudget) = @atomic budget.left
+
+AC._charge_materialization!(budget::AllocationBudget, amount::Int64, what::AbstractString) =
+    _charge!(budget, amount, what)
+AC._materialization_remaining(budget::AllocationBudget) = _remaining(budget)
+AC._materialization_limit_exceeded!(::AllocationBudget, what::AbstractString) =
+    throw(AllocationLimitError("$what exceeds the reader allocation budget"))
+
+function _verify_ipc_metadata_budgeted(
+    metabytes::Vector{UInt8},
+    limits::Limits,
+    budget::AllocationBudget,
+)
+    result = verify_ipc_metadata(metabytes, limits, _remaining(budget))
+    _charge!(budget, result[4], "verified metadata expansion")
+    return result
+end
+
+function _verify_footer_budgeted(
+    footerbytes::Vector{UInt8},
+    limits::Limits,
+    budget::AllocationBudget,
+)
+    result = verify_footer(footerbytes, limits, _remaining(budget))
+    _charge!(budget, result[5], "verified footer expansion")
+    return result
+end
+
+@inline function _chargevector!(
+    budget::Union{Nothing,AllocationBudget},
+    ::Type{T},
+    n::Integer,
+    what::AbstractString,
+) where {T}
+    budget === nothing || _charge!(budget, AC._materializedvectorbytes(T, n), what)
+    return nothing
+end
+
+# A vector allocated once at its final length (`Vector{T}(undef, n)`).
+# Beyond Julia's small-object size classes its storage is the payload plus
+# a header, so large columns are charged what they cost.
+@inline function _exactbytes(::Type{T}, n::Integer) where {T}
+    payload = AC.checked_mul(Int64(n), Int64(Base.elsize(Vector{T})))
+    Base.isbitsunion(T) && (payload = AC.checked_add(payload, Int64(n)))
+    return payload <= 4096 ? AC._materializedvectorbytes(T, n) :
+           AC.checked_add(payload, Int64(128))
+end
+
+@inline function _chargeexact!(
+    budget::Union{Nothing,AllocationBudget},
+    ::Type{T},
+    n::Integer,
+    what::AbstractString,
+) where {T}
+    budget === nothing || _charge!(budget, _exactbytes(T, n), what)
+    return nothing
+end
+
+@inline function _chargeobject!(
+    budget::Union{Nothing,AllocationBudget},
+    payload::Integer,
+    what::AbstractString,
+)
+    budget === nothing || _charge!(budget, AC._materializedobjectbytes(payload), what)
+    return nothing
+end
+
+@inline function _dictslotbytes(::Type{K}, ::Type{V}) where {K,V}
+    return AC.checked_add(
+        Int64(Base.elsize(Vector{K})),
+        AC.checked_add(Int64(Base.elsize(Vector{V})), Int64(16)),
+    )
+end
+
+const _MIN_EMPTY_DICT_SLOTS = Int64(16)
+
+"Reserve the supported-version minimum backing store for one empty dictionary."
+function _chargeemptydict!(
+    budget::Union{Nothing,AllocationBudget},
+    ::Type{K},
+    ::Type{V},
+    what::AbstractString,
+) where {K,V}
+    budget === nothing && return nothing
+    payload = AC.checked_mul(_MIN_EMPTY_DICT_SLOTS, _dictslotbytes(K, V))
+    # Julia 1.10 eagerly allocates minimum Dict backing arrays. Later Julia
+    # versions defer more of this work. Reserve the larger supported layout so
+    # cache construction has one stable reader-budget contract on every host.
+    _charge!(budget, AC.checked_add(Int64(512), payload), what)
+    return nothing
+end
+
+function _chargedict!(
+    budget::Union{Nothing,AllocationBudget},
+    ::Type{K},
+    ::Type{V},
+    n::Integer,
+    what::AbstractString,
+) where {K,V}
+    budget === nothing && return nothing
+    n >= 0 || throw(ArgumentError("negative dictionary capacity"))
+    entries = Int64(n)
+    capacity = entries == 0 ? Int64(0) : AC.checked_mul(entries, Int64(2))
+    payload = AC.checked_mul(capacity, _dictslotbytes(K, V))
+    # Dict's requested hash-table capacity and Julia's backing-store capacity
+    # can each round upward. Reserve both layers conservatively.
+    bytes = AC.checked_add(Int64(512), AC.checked_mul(Int64(2), payload))
+    _charge!(budget, bytes, what)
+    return nothing
+end
+
+"Charge amortized growth for one new entry after its container reserve."
+function _chargedictentry!(
+    budget::Union{Nothing,AllocationBudget},
+    ::Type{K},
+    ::Type{V},
+    what::AbstractString,
+) where {K,V}
+    budget === nothing && return nothing
+    # `_chargedict!` reserves two slots per requested entry and two backing
+    # layers. Charge that linear term once per new memo key. ArrowTypes memo
+    # owners reserve the supported-version empty container separately.
+    bytes = AC.checked_mul(Int64(4), _dictslotbytes(K, V))
+    _charge!(budget, bytes, what)
+    return nothing
+end
+
+"Memoize one value after reserving the new dictionary entry's allocation."
+function _memoized!(
+    f::F,
+    cache::AbstractDict{K,V},
+    key,
+    budget::Union{Nothing,AllocationBudget},
+    what::AbstractString,
+) where {F,K,V}
+    haskey(cache, key) && return cache[key]
+    _chargedictentry!(budget, K, V, what)
+    return get!(f, cache, key)
+end
+
+struct FramedMessage
+    msg::Meta.Message        # parsed flatbuffer metadata
+    body::BufferSlice        # THE authority: buffers must subslice this
+    version::Int16
+    header_type::UInt8
+    features::Vector{Int64}  # populated on schema messages
+end
+
+# The encapsulated-message marker that precedes every metadata length. This
+# reader requires it even on V4 metadata, so streams written before the
+# marker existed are refused.
+const CONTINUATION = 0xFFFFFFFF
+const EXPERIMENTAL_COMPRESSION_KEY = "ARROW:experimental_compression"
+
+# ---------------------------------------------------------------------------
+# FlatBuffers verification (generated walkers over a schema-blind runtime)
+# ---------------------------------------------------------------------------
+
+# The shape verifier is GENERATED from the vendored format/*.fbs by
+# tools/fbsgen.jl (src/metadata/Verifier.jl). Table geometry, scalar widths,
+# enum domains, string and vector bounds, union dispatch, and the
+# nesting/object/reserve budgets all derive from the schema, so binding drift
+# cannot reach them. The wrappers below own only what the schema cannot
+# express: the accepted metadata versions and message kinds, and the
+# features/version coupling.
+# The aliases below exist for test fixtures, which reuse the runtime's
+# traversal primitives to LOCATE the bytes they corrupt. No src file uses them.
+const _VTable = Meta.VTable
+const _vtable = Meta._vtable
+const _vfield = Meta._vfield
+const _vref = Meta._vref
+const _vvector = Meta._vvector
+const _vrange = Meta._vrange
+const _vu8 = Meta._vu8
+const _vu32 = Meta._vu32
+const _vi32 = Meta._vi32
+const _vi64 = Meta._vi64
+
+_vfail(msg) = throw(ValidationError("invalid IPC FlatBuffer: $msg"))
+
+_verifyctx(limits::Limits, reserve_limit::Int64) = Meta.VerifyContext(
+    Int64(limits.max_metadata_objects),
+    limits.max_nesting_depth,
+    reserve_limit,
+)
+
+# Translate the metadata module's verifier exceptions into the adapter's
+# error vocabulary at the wrapper boundary.
+function _verified(f::F) where {F}
+    try
+        return f()
+    catch e
+        e isa Meta.VerifyError && _vfail(e.msg)
+        e isa Meta.VerifyLimitError && (
+            e.ceiling === :depth ?
+            _limiterror("metadata nesting", "max_nesting_depth", e.limit) :
+            _limiterror("metadata object count", "max_metadata_objects", e.limit)
+        )
+        e isa Meta.VerifyBudgetError && throw(AllocationLimitError(e.msg))
+        rethrow()
+    end
+end
+
+function _schemafeatures(sch::Meta.Schema, version::Int16)
+    fv = sch.features
+    features = fv === nothing ? Int64[] : Int64[Int64(x) for x in fv]
+    version == Int16(3) &&
+        !isempty(features) &&
+        _vfail("schema features require metadata V5")
+    return features
+end
+
+function verify_ipc_metadata(
+    bytes::Vector{UInt8},
+    limits::Limits,
+    reserve_limit::Int64=limits.max_total_allocated_bytes,
+)
+    ctx = _verifyctx(limits, reserve_limit)
+    # STAGED root verification. The inline stage proves the table shell and
+    # every non-reference field, including the version. The adapter then
+    # gates the version, so an unsupported one rejects in constant time. Only
+    # after that does the reference stage walk the attacker-directed header
+    # graph.
+    t = _verified(() -> Meta.verifyrootstart_Message(bytes, ctx))
+    msg = FB.getrootas(Meta.Message, bytes, 0)
+    version = Int16(Int64(msg.version))
+    version in (Int16(3), Int16(4)) ||
+        _vfail("unsupported metadata version $version (only V4/V5 are accepted)")
+    _verified(() -> Meta.verifyrootrest_Message(t, ctx))
+    # The verifier proved header presence and rejected union members outside
+    # the generated schemas (the Tensor family), so this dispatch is total.
+    header = msg.header
+    header_type =
+        header isa Meta.Schema ? UInt8(1) :
+        header isa Meta.DictionaryBatch ? UInt8(2) :
+        header isa Meta.RecordBatch ? UInt8(3) : _vfail("unsupported message header tag")
+    features = header isa Meta.Schema ? _schemafeatures(header, version) : Int64[]
+    return version, header_type, features, ctx.reserved
+end
+
+"""
+    framemessages(region, limits) -> Vector{FramedMessage}
+
+Walk the IPC stream framing (continuation marker, metadata length, metadata
+flatbuffer, body), checking every declared length against the limits and the
+region's real extent before metadata-directed decode allocation. A truncated
+prefix, metadata block, or body throws. EOF exactly after a complete message
+is the intentional missing-EOS boundary case and is accepted. The framing's
+metadata length covers the padded metadata only; a Footer Block's
+metaDataLength instead covers prefix + metadata.
+"""
+framemessages(region::OwnerRegion, limits::Limits=Limits()) =
+    _framemessages(region, limits, Base.ENDIAN_BOM, _readbudget(limits, region.len))
+
+function _validatelimits(limits::Limits)
+    limits.max_metadata_bytes >= 0 || throw(ArgumentError("negative metadata limit"))
+    limits.max_body_bytes >= 0 || throw(ArgumentError("negative body limit"))
+    limits.max_buffer_bytes >= 0 || throw(ArgumentError("negative buffer limit"))
+    limits.max_total_allocated_bytes >= 0 ||
+        throw(ArgumentError("negative allocation limit"))
+    limits.max_allocation_ratio >= 0 || throw(ArgumentError("negative allocation ratio"))
+    limits.max_messages >= 0 || throw(ArgumentError("negative message limit"))
+    limits.max_metadata_objects >= 0 ||
+        throw(ArgumentError("negative metadata-object limit"))
+    limits.max_nesting_depth >= 0 || throw(ArgumentError("negative nesting limit"))
+    limits.max_array_length >= 0 || throw(ArgumentError("negative array-length limit"))
+    limits.max_concurrent_reads >= 1 ||
+        throw(ArgumentError("concurrent-read limit must be positive"))
+    limits.max_new_symbols >= 0 || throw(ArgumentError("negative new-Symbol limit"))
+    return nothing
+end
+
+function _framemessages(
+    region::OwnerRegion,
+    limits::Limits,
+    host_endian_bom::UInt32,
+    budget::AllocationBudget=_readbudget(limits, region.len),
+)
+    # The generated FlatBuffers bindings use native-endian scalar
+    # loads. Reject an unsupported host before any generated getter sees the
+    # little-endian wire bytes. The explicit argument keeps this ordering
+    # testable on the supported little-endian CI host.
+    host_endian_bom == UInt32(0x04030201) ||
+        throw(ValidationError("the IPC reader requires a little-endian host"))
+    _validatelimits(limits)
+    blob = BufferSlice(region, 0, region.len)
+    msgs = FramedMessage[]
+    pos = Int64(0)   # 0-based byte position within the blob
+    while true
+        fm, pos = _framemessage(blob, pos, limits, budget, length(msgs))
+        fm === nothing && return msgs
+        push!(msgs, fm)
+    end
+end
+
+# The error for a message prefix without the continuation marker: at the
+# start of the input, the input is not Arrow IPC data (or is a stream from
+# before Arrow 0.15, whose messages start with their metadata length).
+# An IPC stream of `n` bytes that holds no schema message.
+_emptystream(n) =
+    n == 0 ? "the input is empty: Arrow IPC data has at least a schema message" :
+    "empty IPC stream: it ends before its schema message"
+
+function _nomarker(pos::Int64, word::UInt32)
+    pos == 0 || return "missing continuation marker at byte $pos"
+    msg =
+        "not Arrow IPC data: the input starts with neither the file magic " *
+        "ARROW1 nor an IPC stream message"
+    # "PAR1", read as a little-endian word.
+    word == 0x31524150 && return msg * " (it starts with PAR1, as a Parquet file does)"
+    word & 0xffff == 0x8b1f &&
+        return msg * " (it starts with 1f 8b, as gzip data does; decompress it first)"
+    0 < (word % Int32) <= 1 << 24 || return msg
+    return msg *
+           " (a stream written before Arrow 0.15 starts like this; " *
+           "rewrite it with a newer Arrow writer)"
+end
+
+"""
+Frame the message at 0-based `pos` of `blob`, the `nread + 1`th of its stream:
+returns it and the position after it, or `nothing` at the end-of-stream
+marker or the end of the bytes.
+"""
+function _framemessage(
+    blob::BufferSlice,
+    pos::Int64,
+    limits::Limits,
+    budget::AllocationBudget,
+    nread::Int,
+)
+    pos == blob.len && return nothing, pos
+    blob.len - pos >= 8 || throw(
+        ValidationError(
+            pos == 0 ? "not Arrow IPC data: the input is $(blob.len) bytes" :
+            "truncated IPC prefix at byte $pos",
+        ),
+    )
+    pos % 8 == 0 || throw(ValidationError("IPC message is not 8-byte aligned"))
+    cont = AC.loadat(blob, UInt32, pos)
+    cont == CONTINUATION || throw(ValidationError(_nomarker(pos, cont)))
+    # The stream framing's metadata length covers the padded metadata
+    # only. A Footer Block.metaDataLength instead covers prefix +
+    # metadata (see block!).
+    metalen = Int64(AC.loadat(blob, Int32, AC.checked_add(pos, Int64(4))))
+    # Continuation marker + zero length is the end-of-stream marker.
+    # Nothing may follow it.
+    if metalen == 0
+        AC.checked_add(pos, Int64(8)) == blob.len || throw(
+            ValidationError(
+                "trailing bytes after IPC end-of-stream; for IPC streams written " *
+                "one after another, an Arrow.Stream of an IO reads one stream and " *
+                "leaves the IO at the next",
+            ),
+        )
+        return nothing, blob.len
+    end
+    _checkmessagecount(nread, limits)
+    _checkmetalen(metalen, limits)
+    metastart = AC.checked_add(pos, Int64(8))
+    bodystart = AC.checked_add(metastart, metalen)
+    bodystart <= blob.len ||
+        throw(ValidationError("truncated metadata: need $metalen bytes at $pos"))
+    _chargevector!(budget, UInt8, metalen, "metadata allocation")
+    metabytes = AC.slicebytes(AC.subslice(blob, metastart, metalen))
+    msg, version, header_type, features, bodylen =
+        _verifiedmessage(metabytes, limits, budget)
+    bodyend = AC.checked_add(bodystart, bodylen)
+    bodyend <= blob.len ||
+        throw(ValidationError("truncated body: need $bodylen bytes at $bodystart"))
+    fm = FramedMessage(
+        msg,
+        AC.subslice(blob, bodystart, bodylen),
+        version,
+        header_type,
+        features,
+    )
+    return fm, bodyend
+end
+
+# `what` (a declared size) passes `Limits` field `field`, whose value is `limit`.
+@noinline _limiterror(what::AbstractString, field::String, limit) = throw(
+    ValidationError(
+        "$what exceeds Arrow.Limits $field ($limit); raise it with " *
+        "limits=Arrow.Limits($field=...)",
+    ),
+)
+
+# A footer block's declared metadata and body lengths.
+function _checkblocklengths(metalen::Int64, bodylen::Int64, limits::Limits)
+    metalen > 0 || throw(ValidationError("metadata length $metalen is not positive"))
+    metalen <= limits.max_metadata_bytes || _limiterror(
+        "metadata length $metalen",
+        "max_metadata_bytes",
+        limits.max_metadata_bytes,
+    )
+    bodylen >= 0 || throw(ValidationError("body length $bodylen is negative"))
+    bodylen <= limits.max_body_bytes ||
+        _limiterror("body length $bodylen", "max_body_bytes", limits.max_body_bytes)
+    return nothing
+end
+
+_checkmessagecount(nread::Int, limits::Limits) =
+    nread < limits.max_messages ||
+    _limiterror("message count", "max_messages", limits.max_messages)
+
+function _checkmetalen(metalen::Int64, limits::Limits)
+    metalen > 0 || throw(ValidationError("metadata length $metalen is not positive"))
+    metalen <= limits.max_metadata_bytes || _limiterror(
+        "metadata length $metalen",
+        "max_metadata_bytes",
+        limits.max_metadata_bytes,
+    )
+    metalen % 8 == 0 ||
+        throw(ValidationError("metadata length $metalen is not 8-byte aligned"))
+    return nothing
+end
+
+# Verify a message's metadata, then read it and its body length.
+function _verifiedmessage(
+    metabytes::Vector{UInt8},
+    limits::Limits,
+    budget::AllocationBudget,
+)
+    version, header_type, features, _ =
+        _verify_ipc_metadata_budgeted(metabytes, limits, budget)
+    # No generated getter runs before the verifier has bounded the full
+    # table/vector/string graph it may visit.
+    msg = FB.getrootas(Meta.Message, metabytes, 0)
+    bodylen = Int64(msg.bodyLength)
+    bodylen >= 0 || throw(ValidationError("body length $bodylen is negative"))
+    bodylen <= limits.max_body_bytes ||
+        _limiterror("body length $bodylen", "max_body_bytes", limits.max_body_bytes)
+    bodylen % 8 == 0 || throw(ValidationError("body length $bodylen is not 8-byte aligned"))
+    return msg, version, header_type, features, bodylen
+end
+
+# ---------------------------------------------------------------------------
+# Metadata mapping: Meta.* type structs -> Core runtime descriptors
+# ---------------------------------------------------------------------------
+
+# One value-level mapping table: one function per direction over runtime
+# descriptors. Julia-type conversion is the facade's concern, not this
+# adapter's.
+
+function coretype(t)::ArrowType
+    if t isa Meta.Int
+        IntType(Int(t.bitWidth), t.is_signed)
+    elseif t isa Meta.FloatingPoint
+        FloatType(
+            t.precision == Meta.Precision.HALF ? 16 :
+            t.precision == Meta.Precision.SINGLE ? 32 : 64,
+        )
+    elseif t isa Meta.Bool
+        BoolType()
+    elseif t isa Meta.Utf8
+        Utf8Type(false)
+    elseif t isa Meta.LargeUtf8
+        Utf8Type(true)
+    elseif t isa Meta.Binary
+        BinaryType(false)
+    elseif t isa Meta.LargeBinary
+        BinaryType(true)
+    elseif t isa Meta.FixedSizeBinary
+        FixedSizeBinaryType(Int(something(t.byteWidth, Int32(0))))
+    elseif t isa Meta.List
+        ListType(false)
+    elseif t isa Meta.LargeList
+        ListType(true)
+    elseif t isa Meta.FixedSizeList
+        FixedSizeListType(Int(t.listSize))
+    elseif t isa Meta.Struct
+        StructType()
+    elseif t isa Meta.Map
+        MapType(something(t.keysSorted, false))
+    elseif t isa Meta.Timestamp
+        timezone = t.timezone
+        TimestampType(timeunit(t.unit), timezone === nothing ? nothing : String(timezone))
+    elseif t isa Meta.Date
+        DateType(t.unit == Meta.DateUnit.DAY ? AC.DAY : AC.MILLISECOND_DATE)
+    elseif t isa Meta.Time
+        TimeType(timeunit(t.unit), Int(t.bitWidth))
+    elseif t isa Meta.Duration
+        DurationType(timeunit(t.unit))
+    elseif t isa Meta.Decimal
+        DecimalType(Int(t.precision), Int(t.scale), Int(t.bitWidth))
+    elseif t isa Meta.Interval
+        IntervalType(
+            t.unit == Meta.IntervalUnit.YEAR_MONTH ? AC.YEAR_MONTH :
+            t.unit == Meta.IntervalUnit.DAY_TIME ? AC.DAY_TIME : AC.MONTH_DAY_NANO,
+        )
+    elseif t isa Meta.Utf8View
+        ViewType(true)
+    elseif t isa Meta.BinaryView
+        ViewType(false)
+    elseif t isa Meta.ListView
+        ListViewType(false)
+    elseif t isa Meta.LargeListView
+        ListViewType(true)
+    elseif t isa Meta.RunEndEncoded
+        RunEndEncodedType()
+    elseif t isa Meta.Null
+        NullType()
+    else
+        throw(ValidationError("IPC adapter does not map metadata type $(typeof(t))"))
+    end
+end
+
+"""
+Map one metadata type to a Core descriptor, with the built child Fields in
+hand — Union is the one type whose descriptor (mode + type ids) spans the
+type table AND the children vector, so it cannot go through `coretype`.
+"""
+function _coremetatype(mt, children::Vector{Field})::ArrowType
+    mt isa Meta.Union || return coretype(mt)
+    mode = mt.mode == Meta.UnionMode.Dense ? AC.DenseMode : AC.SparseMode
+    ids = mt.typeIds
+    nchildren = length(children)
+    # Type ids are Int8 in [0, 127] (checked below), so 128 distinct children
+    # is the ceiling.
+    nchildren <= 128 || throw(ValidationError("a union cannot have more than 128 children"))
+    if ids === nothing
+        return UnionType(mode, Int8[Int8(i) for i = 0:(nchildren - 1)])
+    end
+    length(ids) == nchildren ||
+        throw(ValidationError("union type-id count must equal child count"))
+    all(x -> 0 <= x <= 127, ids) ||
+        throw(ValidationError("union type ids must be in [0, 127]"))
+    coreids = Int8[Int8(x) for x in ids]
+    length(unique(coreids)) == length(coreids) ||
+        throw(ValidationError("union type ids must be unique"))
+    return UnionType(mode, coreids)
+end
+
+timeunit(u) =
+    u == Meta.TimeUnit.SECOND ? AC.SECOND :
+    u == Meta.TimeUnit.MILLISECOND ? AC.MILLISECOND :
+    u == Meta.TimeUnit.MICROSECOND ? AC.MICROSECOND : AC.NANOSECOND
+
+function coremetadata(kvs)
+    kvs === nothing && return nothing
+    return Pair{String,String}[
+        String(kv.key) => String(something(kv.value, "")) for kv in kvs
+    ]
+end
+
+"""
+Convert a metadata Field to a Core Field. Dictionary-encoded fields become
+`DictionaryType` here; the IPC dictionary id is recorded in the adapter's
+side table (`dictids`), NOT on the Core field — Core never learns about ids.
+"""
+function corefield(
+    f::Meta.Field,
+    dictids::Dict{Int64,Meta.Field},
+    fielddictids::IdDict{Field,Int64},
+)
+    children = Field[
+        corefield(c, dictids, fielddictids) for c in something(f.children, Meta.Field[])
+    ]
+    t = _coremetatype(f.type, children)
+    if f.dictionary === nothing
+        return Field(
+            String(something(f.name, "")),
+            t,
+            f.nullable,
+            coremetadata(f.custom_metadata),
+            children,
+        )
+    end
+    # Nested dictionary encoding (a dictionary field whose VALUE type has
+    # dictionary-encoded children) is spec-legal and present in the
+    # arrow-testing gold corpus (nested_dictionary: dict(list(dict(utf8)))).
+    # A dictionary batch's values decode through the same `decodefield`
+    # with the live pool table, so inner pools resolve as long as batches
+    # arrive in dependency order — which the IPC spec requires.
+    dictids[f.dictionary.id] = f
+    idxt =
+        f.dictionary.indexType === nothing ? IntType(32, true) :
+        coretype(f.dictionary.indexType)::IntType
+    cf = Field(
+        String(something(f.name, "")),
+        DictionaryType(idxt, t, f.dictionary.isOrdered),
+        f.nullable,
+        coremetadata(f.custom_metadata),
+        children,
+    )
+    # Identity-keyed: safe for duplicate column names and nested dict fields
+    # (name matching would be neither).
+    fielddictids[cf] = f.dictionary.id
+    return cf
+end
+
+function validatedictionaryids(fields, fielddictids::IdDict{Field,Int64})
+    seen = Dict{Int64,Field}()
+    compatible(a::Field, b::Field; compare_name::Bool=false) =
+        (!compare_name || a.name == b.name) &&
+        AC.typeequal(a.type, b.type) &&
+        a.nullable == b.nullable &&
+        # One id resolves ONE pool, so repeated ids must agree on the whole
+        # nested dictionary-id topology: compatible value schemas whose
+        # nested fields carry DIFFERENT wire ids would decode the second
+        # field through pools its schema never declared.
+        (!(a.type isa DictionaryType) || fielddictids[a] == fielddictids[b]) &&
+        length(a.children) == length(b.children) &&
+        all(compatible(x, y; compare_name=true) for (x, y) in zip(a.children, b.children))
+    function walk(f::Field)
+        if f.type isa DictionaryType
+            id = fielddictids[f]
+            vf = AC.dictvaluefield(f, f.type)
+            if haskey(seen, id)
+                old = seen[id]
+                compatible(old, vf) || throw(
+                    ValidationError(
+                        "dictionary id $id is shared by incompatible value schemas",
+                    ),
+                )
+            else
+                seen[id] = vf
+                # A pool's value schema may itself hold dictionary-encoded
+                # fields (nested dictionary encoding); their ids resolve
+                # through this same table, so register them too.
+                walk(vf)
+            end
+            return
+        end
+        foreach(walk, f.children)
+    end
+    foreach(walk, fields)
+    return seen
+end
+
+function validateschemafield(f::Field)
+    AC._validate_descriptor(f.type)
+    if f.type isa DictionaryType
+        validateschemafield(AC.dictvaluefield(f, f.type))
+        return f
+    end
+    spec = AC.layoutspec_of(f.type)
+    expected = spec.childcount == -1 ? length(f.children) : spec.childcount
+    length(f.children) == expected || throw(
+        ValidationError(
+            "$(typeof(f.type)) schema expects $expected children, got $(length(f.children))",
+        ),
+    )
+    if f.type isa UnionType
+        typeids = (f.type::UnionType).typeids
+        length(typeids) == length(f.children) ||
+            throw(ValidationError("union type-id count must equal child count"))
+        length(unique(typeids)) == length(typeids) ||
+            throw(ValidationError("union type ids must be unique"))
+        all(>=(0), typeids) || throw(ValidationError("union type ids must be in [0, 127]"))
+    elseif f.type isa MapType
+        entries = f.children[1]
+        entries.type isa StructType &&
+        !entries.nullable &&
+        length(entries.children) == 2 &&
+        !entries.children[1].nullable ||
+            throw(ValidationError("invalid map entries/key schema"))
+    elseif f.type isa RunEndEncodedType
+        length(f.children) == 2 || throw(ValidationError("REE requires two children"))
+        run, values = f.children
+        run.name == "run_ends" &&
+        values.name == "values" &&
+        run.type isa IntType &&
+        run.type.signed &&
+        run.type.bits in (16, 32, 64) &&
+        !run.nullable || throw(ValidationError("invalid run-end encoded schema"))
+    end
+    foreach(validateschemafield, f.children)
+    return f
+end
+
+# ---------------------------------------------------------------------------
+# THE generic decoder: registry-driven node/buffer consumption
+# ---------------------------------------------------------------------------
+
+# Node/buffer consumption order falls out of `layoutspec`: one field = one
+# node (unless the layout says otherwise) + the registry's buffers in
+# registry order + children in declared order. Nothing threads
+# (nodeidx, bufferidx, varbufferidx) by hand per layout, so an off-by-one
+# cannot silently shift every subsequent buffer; a mismatch is a thrown
+# error at the *end* of the batch (leftover nodes/buffers), not corruption.
+
+# Buffer compression: one codec context per reader, reused across buffers
+# and explicitly finalized when the reader is done — no global pools.
+const CODEC_NONE = Int8(-1)
+const CODEC_LZ4_FRAME = Int8(0)   # Meta.CompressionType.LZ4_FRAME
+const CODEC_ZSTD = Int8(1)        # Meta.CompressionType.ZSTD
+
+mutable struct DecodeState
+    lz4::Ptr{CLZ4.LZ4F_dctx}
+    zstd::Ptr{ZSTD.ZSTD_DCtx}
+    budget::AllocationBudget
+end
+
+DecodeState(budget::AllocationBudget) =
+    DecodeState(Ptr{CLZ4.LZ4F_dctx}(C_NULL), Ptr{ZSTD.ZSTD_DCtx}(C_NULL), budget)
+
+function _lz4ctx!(state::DecodeState)
+    state.lz4 != C_NULL && return state.lz4
+    slot = Ref{Ptr{CLZ4.LZ4F_dctx}}(C_NULL)
+    CLZ4.LZ4F_createDecompressionContext(slot, CLZ4.LZ4F_getVersion())
+    state.lz4 = slot[]
+    return state.lz4
+end
+
+function _zstdctx!(state::DecodeState)
+    state.zstd != C_NULL && return state.zstd
+    p = ZSTD.ZSTD_createDCtx()
+    p == C_NULL && throw(OutOfMemoryError())
+    state.zstd = p
+    return p
+end
+
+function Base.close(state::DecodeState)
+    lz4 = state.lz4
+    state.lz4 = Ptr{CLZ4.LZ4F_dctx}(C_NULL)
+    try
+        lz4 == C_NULL || CLZ4.LZ4F_freeDecompressionContext(lz4)
+    finally
+        zstd = state.zstd
+        state.zstd = Ptr{ZSTD.ZSTD_DCtx}(C_NULL)
+        zstd == C_NULL || ZSTD.ZSTD_freeDCtx(zstd)
+    end
+    return nothing
+end
+
+# --- task parallelism -------------------------------------------------------
+
+function _checkntasks(ntasks)
+    (ntasks isa Integer && ntasks >= 1) ||
+        throw(ArgumentError("ntasks must be a positive integer, got $(repr(ntasks))"))
+    return Int(ntasks)
+end
+
+# The next item `_foreach` hands out and the smallest item that failed.
+mutable struct _Claims
+    @atomic next::Int
+    @atomic failed::Int
+end
+
+"""
+Call `f(i, w)` for each `i` in `1:n` on at most `ntasks` tasks, the caller
+being one of them; `w` in `1:min(n, ntasks)` names the task, so `f` can use
+per-task scratch state. Items are claimed in increasing order. When items
+throw, items after the smallest failing one are skipped and its exception is
+rethrown once every task has stopped, so errors do not depend on `ntasks`.
+"""
+function _foreach(f::F, n::Int, ntasks::Int) where {F}
+    nt = min(n, ntasks)
+    if nt <= 1
+        for i = 1:n
+            f(i, 1)
+        end
+        return nothing
+    end
+    claims = _Claims(0, typemax(Int))
+    errors = Vector{Any}(nothing, n)
+    # The tasks reach `f` (and whatever it captures, such as a read's decoded
+    # batches) only through `job`, which is cleared once they are done: a
+    # finished task can stay reachable after this call (an idle thread keeps
+    # the last task it ran), and must not keep that data alive.
+    job = Ref{Union{Nothing,F}}(f)
+    function work(w)
+        g = job[]::F
+        while true
+            i = @atomic claims.next += 1
+            (i > n || i > @atomic(claims.failed)) && return nothing
+            try
+                g(i, w)
+            catch e
+                errors[i] = (e, catch_backtrace())
+                old = @atomic claims.failed
+                while i < old
+                    old, ok = @atomicreplace claims.failed old => i
+                    ok && break
+                end
+            end
+        end
+    end
+    tasks = Task[errormonitor(Threads.@spawn work(w)) for w = 2:nt]
+    try
+        work(1)
+    finally
+        foreach(wait, tasks)
+        job[] = nothing
+    end
+    failed = @atomic claims.failed
+    failed == typemax(Int) && return nothing
+    e, bt = errors[failed]
+    # The caller sees the worker's exception, with the worker's backtrace as
+    # its cause.
+    try
+        throw(CapturedException(e, bt))
+    catch
+        throw(e)
+    end
+end
+
+# Decode into `out[1:declared]` and return the bytes produced. With
+# `exact=false` the frame may hold more (decoding stops once `out` is full)
+# or less; the caller checks the count.
+function _decode_lz4!(
+    state::DecodeState,
+    src::Ptr{UInt8},
+    srclen::Int64,
+    out::Vector{UInt8},
+    declared::Int64,
+    exact::Bool=true,
+)
+    ctx = _lz4ctx!(state)
+    CLZ4.LZ4F_resetDecompressionContext(ctx)
+    inpos = Int64(0)
+    outpos = Int64(0)
+    while true
+        insize = Ref{Csize_t}(Csize_t(srclen - inpos))
+        outsize = Ref{Csize_t}(Csize_t(declared - outpos))
+        # A zero-capacity destination is valid. It lets the decoder consume
+        # an empty frame or the footer after the last output byte without a
+        # second allocation.
+        dst = outpos == declared ? Ptr{UInt8}(C_NULL) : pointer(out) + outpos
+        hint = CLZ4.LZ4F_decompress(ctx, dst, outsize, src + inpos, insize, C_NULL)
+        inpos += Int64(insize[])
+        outpos += Int64(outsize[])
+        exact || outpos < declared || return outpos
+        if hint == 0
+            exact || return outpos
+            inpos == srclen || throw(
+                ValidationError("LZ4 buffer contains trailing bytes or multiple frames"),
+            )
+            outpos == declared || throw(
+                ValidationError(
+                    "LZ4 output length $outpos does not match declared $declared",
+                ),
+            )
+            return outpos
+        end
+        inpos < srclen ||
+            (exact ? throw(ValidationError("truncated LZ4 frame")) : return outpos)
+        (insize[] != 0 || outsize[] != 0) ||
+            throw(ValidationError("LZ4 output exceeds declared length $declared"))
+    end
+end
+
+function _decode_zstd!(
+    state::DecodeState,
+    src::Ptr{UInt8},
+    srclen::Int64,
+    out::Vector{UInt8},
+    declared::Int64,
+)
+    dst = declared == 0 ? Ptr{UInt8}(C_NULL) : pointer(out)
+    got = ZSTD.ZSTD_decompressDCtx(
+        _zstdctx!(state),
+        dst,
+        Csize_t(declared),
+        src,
+        Csize_t(srclen),
+    )
+    if ZSTD.ZSTD_isError(got) != 0
+        msg = unsafe_string(ZSTD.ZSTD_getErrorName(got))
+        throw(ValidationError("ZSTD decompression failed: $msg"))
+    end
+    Int64(got) == declared || throw(
+        ValidationError(
+            "ZSTD output length $(Int64(got)) does not match declared $declared",
+        ),
+    )
+    return Int64(got)
+end
+
+# Decode at most `length(out)` bytes of a zstd buffer and return how many
+# were produced; the rest of the input is not read.
+function _decode_zstd_prefix!(
+    state::DecodeState,
+    src::Ptr{UInt8},
+    srclen::Int64,
+    out::Vector{UInt8},
+)
+    dctx = _zstdctx!(state)
+    ZSTD.ZSTD_DCtx_reset(dctx, ZSTD.ZSTD_reset_session_only)
+    input = ZSTD.ZSTD_inBuffer(Ptr{Cvoid}(src), Csize_t(srclen), Csize_t(0))
+    output = ZSTD.ZSTD_outBuffer(Ptr{Cvoid}(pointer(out)), Csize_t(length(out)), Csize_t(0))
+    while output.pos < length(out)
+        before = (input.pos, output.pos)
+        r = ZSTD.ZSTD_decompressStream(dctx, output, input)
+        ZSTD.ZSTD_isError(r) == 0 || throw(
+            ValidationError(
+                "ZSTD decompression failed: $(unsafe_string(ZSTD.ZSTD_getErrorName(r)))",
+            ),
+        )
+        (r == 0 || (input.pos, output.pos) == before) && break
+    end
+    return Int64(output.pos)
+end
+
+# `B` is the body representation: a contiguous `BufferSlice` for in-memory
+# and mmapped messages, or a sparse body (scan.jl) whose fetched
+# spans stand in for the contiguous message body. `_bodyslice` is the one
+# seam between them; the parameter keeps the cursor concrete per use.
+# Concretely typed vectors: node and buffer reads run once per field per batch.
+mutable struct DecodeCursor{
+    B,
+    N<:AbstractVector{Meta.FieldNode},
+    U<:AbstractVector{Meta.Buffer},
+    V<:AbstractVector{<:Integer},
+}
+    nodes::N
+    buffers::U
+    body::B
+    max_buffer_bytes::Int64
+    max_array_length::Int64
+    nodeidx::Int
+    bufidx::Int
+    last_nonempty_end::Int64
+    codec::Int8                   # CODEC_NONE, or the batch's declared codec
+    state::Union{Nothing,DecodeState}
+    # One entry per view-typed field in depth-first schema order: how many
+    # variadic data buffers that field consumes (format 1.4). Non-view
+    # batches carry an empty vector; a leftover entry is a skew error.
+    variadics::V
+    varidx::Int
+end
+
+"Resolve one declared buffer window against the message body."
+_bodyslice(body::BufferSlice, offset::Int64, len::Int64) = AC.subslice(body, offset, len)
+
+DecodeCursor(
+    nodes,
+    buffers,
+    body,
+    limits::Limits;
+    codec::Int8=CODEC_NONE,
+    state::Union{Nothing,DecodeState}=nothing,
+    variadics=nothing,
+) = DecodeCursor(
+    something(nodes, Meta.FieldNode[]),
+    something(buffers, Meta.Buffer[]),
+    body,
+    limits.max_buffer_bytes,
+    limits.max_array_length,
+    1,
+    1,
+    0,
+    codec,
+    state,
+    something(variadics, Int64[]),
+    1,
+)
+
+"""
+    variadiccounts(rb::Meta.RecordBatch) -> Vector{Int64}
+
+The batch's `variadicBufferCounts` as a concrete `Vector{Int64}` (empty when
+the slot is absent). The generated binding reads the spec's `[long]` at
+8-byte width; this accessor exists so every site shares one normalized shape.
+"""
+variadiccounts(rb::Meta.RecordBatch) =
+    collect(Int64, something(rb.variadicBufferCounts, Int64[]))
+
+"One variadic-buffer count, in depth-first view-field order (format 1.4)."
+function takevariadic!(c::DecodeCursor)
+    c.varidx <= length(c.variadics) || throw(
+        ValidationError(
+            "metadata declares fewer variadic buffer counts than the schema requires",
+        ),
+    )
+    n = c.variadics[c.varidx]
+    c.varidx += 1
+    0 <= n <= length(c.buffers) ||
+        throw(ValidationError("variadic buffer count $n outside [0, $(length(c.buffers))]"))
+    return Int(n)
+end
+
+function takenode!(c::DecodeCursor)
+    c.nodeidx <= length(c.nodes) || throw(
+        ValidationError("metadata declares fewer field nodes than the schema requires"),
+    )
+    n = c.nodes[c.nodeidx]
+    c.nodeidx += 1
+    n.length >= 0 || throw(ValidationError("field-node length $(n.length) is negative"))
+    n.length <= c.max_array_length ||
+        _limiterror("field-node length $(n.length)", "max_array_length", c.max_array_length)
+    0 <= n.null_count <= n.length ||
+        throw(ValidationError("invalid field-node null count $(n.null_count)"))
+    return n
+end
+
+"""
+Consume one buffer-table entry's METADATA: bounds, alignment, limits, and the
+non-overlap/monotone invariants — every check that needs no body byte.
+`takebuffer!` continues into the body subslice and decompression;
+`skipbuffer!` stops here, so scan pushdown can skip a column's decode and its
+body range. Ranged tail reads and coalescing may still over-read those bytes.
+"""
+function _buffermeta!(c::DecodeCursor)
+    c.bufidx <= length(c.buffers) ||
+        throw(ValidationError("metadata declares fewer buffers than the schema requires"))
+    b = c.buffers[c.bufidx]
+    c.bufidx += 1
+    offset = Int64(b.offset)
+    len = Int64(b.length)
+    offset >= 0 || throw(ValidationError("negative batch buffer offset $offset"))
+    offset % 8 == 0 ||
+        throw(ValidationError("batch buffer offset $offset is not 8-byte aligned"))
+    len >= 0 || throw(ValidationError("batch buffer length $len is negative"))
+    len <= c.max_buffer_bytes ||
+        _limiterror("batch buffer length $len", "max_buffer_bytes", c.max_buffer_bytes)
+    if len > 0
+        offset >= c.last_nonempty_end ||
+            throw(ValidationError("batch buffers overlap or move backwards"))
+        c.last_nonempty_end = _checkedadd(offset, len, "batch buffer end")
+    end
+    return offset, len
+end
+
+# Checked arithmetic on metadata values: an overflow is a `ValidationError`
+# naming `what`.
+function _checkedadd(a::Int64, b::Int64, what::AbstractString)
+    try
+        return AC.checked_add(a, b)
+    catch e
+        e isa OverflowError || rethrow()
+        throw(ValidationError("$what overflows"))
+    end
+end
+
+function _checkedmul(a::Int64, b::Int64, what::AbstractString)
+    try
+        return AC.checked_mul(a, b)
+    catch e
+        e isa OverflowError || rethrow()
+        throw(ValidationError("$what overflows"))
+    end
+end
+
+skipbuffer!(c::DecodeCursor) = (_buffermeta!(c); nothing)
+
+# `needed` is the byte count the buffer's column reads (-1 when unknown); it
+# bounds how far decompressed bytes extend the read's allowance.
+function takebuffer!(c::DecodeCursor, needed::Int64=Int64(-1))
+    offset, len = _buffermeta!(c)
+    # THE checked-subslice step: a buffer is only ever a window into this
+    # message's body span (or, for a sparse body, into a fetched span that
+    # was itself derived from this buffer table). Checked arithmetic turns a
+    # corrupt offset/length into a clean ValidationError.
+    wire = try
+        _bodyslice(c.body, offset, len)
+    catch e
+        e isa ArgumentError || e isa OverflowError || rethrow()
+        throw(ValidationError("batch buffer [$offset, $len] escapes its message body"))
+    end
+    (c.codec == CODEC_NONE || len == 0) && return wire
+    return _decompressbuffer!(c, wire, needed)
+end
+
+# Advise the kernel to map now the pages holding `n` bytes at `p`, which a
+# reader is about to read once each: one request instead of a fault per page
+# of a memory-mapped file (Unix). A range under 64 KiB spans a few pages at
+# most, and advising it costs more than it saves.
+function _willneed(p::Ptr{UInt8}, n::Int)
+    @static if Sys.isunix()
+        n >= 1 << 16 || return nothing
+        lo = UInt(p) & ~(UInt(AC.Mmap.PAGESIZE) - 1)
+        len = UInt(p) + UInt(n) - lo
+        ccall(
+            :madvise,
+            Cint,
+            (Ptr{Cvoid}, Csize_t, Cint),
+            Ptr{Cvoid}(lo),
+            len,
+            AC.Mmap.MADV_WILLNEED,
+        )
+    end
+    return nothing
+end
+
+"""
+Decode one compressed buffer: an Int64 uncompressed-length prefix, then the
+payload. A prefix of -1 means the payload is stored raw and stays a view of
+the wire mapping. The declared size is attacker-controlled: it must agree with
+the size the frame headers record, if any, and is charged to the read's budget
+before allocation. A buffer that declares more than its column reads
+(`needed`, from the field node; a writer may store a sliced column's whole
+buffer) decodes only the column's bytes; otherwise the decompressed size must
+match the declaration exactly. A positively compressed buffer becomes its own
+exact-sized owned region.
+
+Decompressed bytes count as input to the budget as far as the column reads
+them, so a highly compressible buffer is funded while a claim beyond what the
+column reads is not.
+"""
+function _decompressbuffer!(c::DecodeCursor, wire::BufferSlice, needed::Int64=Int64(-1))
+    wire.len >= 8 || throw(
+        ValidationError("compressed buffer of $(wire.len) bytes lacks its length prefix"),
+    )
+    declared = AC.loadat(wire, Int64, Int64(0))
+    declared == -1 && return AC.subslice(wire, 8, wire.len - 8)  # stored raw
+    declared >= 0 ||
+        throw(ValidationError("declared decompressed length $declared is negative"))
+    declared <= c.max_buffer_bytes || _limiterror(
+        "declared decompressed length $declared",
+        "max_buffer_bytes",
+        c.max_buffer_bytes,
+    )
+    declared <= typemax(Int) >> 1 ||
+        throw(ValidationError("declared decompressed buffer is not addressable"))
+    payloadlen = wire.len - 8
+    payloadlen > 0 || throw(ValidationError("compressed buffer has an empty payload"))
+    state = c.state::DecodeState
+    wireregion = wire.region::OwnerRegion
+    recorded = GC.@preserve wireregion _framecontentsize(
+        c.codec,
+        AC.sliceptr(wire) + 8,
+        payloadlen,
+    )
+    (recorded < 0 || recorded == declared) || throw(
+        ValidationError(
+            "declared decompressed length $declared does not match the $recorded bytes " *
+            "its frame records",
+        ),
+    )
+    # A buffer longer than its column reads (a writer may store a sliced
+    # column's whole buffer) decodes only the column's bytes.
+    exact = needed < 0 || declared <= _padded64(needed)
+    outlen = exact ? declared : _padded64(needed)
+    # No payload decodes to more than its codec's largest expansion: LZ4
+    # turns one byte into at most 255, a 4-byte zstd RLE block into at most
+    # 128 KiB. A larger claim is refused before it is allocated.
+    expansion = c.codec == CODEC_LZ4_FRAME ? Int64(255) : Int64(32768)
+    outlen <= AC.checked_mul(expansion, payloadlen) || throw(
+        ValidationError(
+            "declared decompressed length $outlen exceeds what $payloadlen " *
+            "compressed bytes can hold",
+        ),
+    )
+    needed >= 0 && _grow!(state.budget, outlen - payloadlen)
+    charged = _exactbytes(UInt8, outlen)
+    _charge!(state.budget, charged, "decompressed bytes")
+    committed = false
+    try
+        # This is the only output allocation. Its size was checked and
+        # charged before either native decoder sees the input frame.
+        out = Vector{UInt8}(undef, Int(outlen))
+        # The native decoders read through a raw pointer, so the wire
+        # region's root must stay reachable for the whole call (Core rule 2).
+        got = GC.@preserve out wireregion begin
+            src = AC.sliceptr(wire) + 8
+            _willneed(src, Int(payloadlen))
+            if c.codec == CODEC_LZ4_FRAME
+                _decode_lz4!(state, src, payloadlen, out, outlen, exact)
+            elseif exact
+                _decode_zstd!(state, src, payloadlen, out, outlen)
+            else
+                _decode_zstd_prefix!(state, src, payloadlen, out)
+            end
+        end
+        exact ||
+            got >= needed ||
+            throw(
+                ValidationError(
+                    "compressed buffer holds $got bytes; its column needs $needed",
+                ),
+            )
+        region = OwnerRegion(Ptr{UInt8}(pointer(out)), sizeof(out); root=_Decompressed(out))
+        result = BufferSlice(region, 0, got)
+        committed = true
+        return result
+    catch e
+        e isa Union{ValidationError,AllocationLimitError} && rethrow()
+        e isa OutOfMemoryError && rethrow()
+        e isa InterruptException && rethrow()
+        throw(ValidationError("buffer decompression failed: $(sprint(showerror, e))"))
+    finally
+        committed || _refund!(state.budget, charged)
+    end
+end
+
+_padded64(n::Int64) = n > typemax(Int64) - 63 ? typemax(Int64) : (n + 63) & ~Int64(63)
+
+# The root of a decompressed buffer's region: bytes this read allocated and no
+# other buffer shares, so a column may keep them instead of a copy (string
+# data, `_adoptbytes`).
+struct _Decompressed
+    bytes::Vector{UInt8}
+end
+
+# The decompressed size the frame headers record: zstd frames usually do (a
+# buffer may hold several), LZ4 frames optionally. -1 when a header does not
+# say; a malformed header is left for the decoder to reject.
+function _framecontentsize(codec::Int8, src::Ptr{UInt8}, len::Int64)::Int64
+    if codec == CODEC_ZSTD
+        total = Int64(0)
+        pos = Int64(0)
+        while pos < len
+            n = ZSTD.ZSTD_getFrameContentSize(src + pos, Csize_t(len - pos))
+            n >= ZSTD.ZSTD_CONTENTSIZE_ERROR && return Int64(-1)
+            n > typemax(Int64) - total && return Int64(-1)
+            total += Int64(n)
+            framelen = ZSTD.ZSTD_findFrameCompressedSize(src + pos, Csize_t(len - pos))
+            (ZSTD.ZSTD_isError(framelen) == 0 && framelen > 0) || return Int64(-1)
+            pos += Int64(framelen)
+        end
+        return total
+    end
+    # LZ4 frame: magic, FLG (bit 3: content size present), BD, then the size.
+    (
+        len >= 14 &&
+        unsafe_load(src, 1) == 0x04 &&
+        unsafe_load(src, 2) == 0x22 &&
+        unsafe_load(src, 3) == 0x4d &&
+        unsafe_load(src, 4) == 0x18
+    ) || return Int64(-1)
+    unsafe_load(src, 5) & 0x08 == 0 && return Int64(-1)
+    n = UInt64(0)
+    for k = 14:-1:7
+        n = (n << 8) | unsafe_load(src, k)
+    end
+    return n > typemax(Int64) ? Int64(-1) : Int64(n)
+end
+
+function finishcursor!(c::DecodeCursor)
+    c.nodeidx == length(c.nodes) + 1 ||
+        throw(ValidationError("unconsumed field nodes: schema/batch mismatch"))
+    c.bufidx == length(c.buffers) + 1 ||
+        throw(ValidationError("unconsumed buffers: schema/batch mismatch"))
+    c.varidx == length(c.variadics) + 1 ||
+        throw(ValidationError("unconsumed variadic buffer counts: schema/batch mismatch"))
+    return nothing
+end
+
+function missingdicts(
+    fields,
+    nodes,
+    dicts::Dict{Int64,ArrayData},
+    fielddictids::IdDict{Field,Int64},
+)
+    ns = something(nodes, Meta.FieldNode[])
+    idx = Ref(1)
+    missing = Set{Int64}()
+    function walk(f::Field)
+        idx[] <= length(ns) || throw(
+            ValidationError("metadata declares fewer field nodes than the schema requires"),
+        )
+        node = ns[idx[]]
+        idx[] += 1
+        if f.type isa DictionaryType
+            id = fielddictids[f]
+            if !haskey(dicts, id)
+                node.length >= 0 && node.null_count == node.length || throw(
+                    ValidationError(
+                        "record batch uses undefined dictionary id $id for a non-null slot",
+                    ),
+                )
+                push!(missing, id)
+            end
+            return
+        end
+        spec = AC.layoutspec_of(f.type)
+        nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+        for i = 1:nchildren
+            walk(f.children[i])
+        end
+    end
+    foreach(walk, fields)
+    return missing
+end
+
+"""
+    decodefield(field, cursor, dictionaries, fielddictids) -> ArrayData
+
+Generic over every mapped layout in this adapter, variadic (view) layouts
+included.
+Dictionary-encoded columns consume the INDEX layout's buffers (validity +
+indices) and resolve their values through the adapter's dictionary table.
+"""
+# The bytes a column of `n` slots reads from a buffer in `role`, from its
+# field node alone (-1 when that needs bytes not decoded yet). Variable-width
+# data ends at the last offset, which precedes it in `previous`.
+function _neededbytes(role::AC.BufferRole, spec::AC.LayoutSpec, n::Int64, previous)
+    role == AC.VALIDITY && return cld(n, 8)
+    role == AC.TYPE_IDS && return n
+    role == AC.VIEWS && return _saturatingmul(n, Int64(16))
+    role == AC.OFFSETS &&
+        return n == 0 ? Int64(0) : _saturatingmul(n + 1, Int64(spec.offsetwidth))
+    (role == AC.ELEMENT_OFFSETS || role == AC.SIZES) &&
+        return _saturatingmul(n, Int64(spec.offsetwidth))
+    role == AC.DATA || return Int64(-1)
+    spec.fixedwidth > 0 && return _saturatingmul(n, Int64(spec.fixedwidth))
+    spec.fixedwidth == -1 && return cld(n, 8)
+    # Byte-addressed data follows its offsets (validity, offsets, data).
+    (spec.offsetwidth > 0 && length(previous) == 2) || return Int64(-1)
+    n == 0 && return Int64(0)
+    offsets = previous[2]
+    w = spec.offsetwidth
+    offsets.len >= (n + 1) * w || return Int64(-1)
+    last =
+        w == 8 ? AC.loadat(offsets, Int64, n * 8) : Int64(AC.loadat(offsets, Int32, n * 4))
+    return last >= 0 ? last : Int64(-1)
+end
+
+# The end of the last value each variadic data buffer of a view column holds,
+# from its views: what a compressed data buffer's column reads. `nothing` for
+# an uncompressed batch, whose buffers are not decompressed.
+function _variadicends(c::DecodeCursor, views::BufferSlice, n::Int64, nvariadic::Int)
+    c.codec == CODEC_NONE && return nothing
+    _chargevector!((c.state::DecodeState).budget, Int64, nvariadic, "variadic buffer ends")
+    ends = fill(Int64(-1), nvariadic)
+    (nvariadic == 0 || views.len < 16n) && return ends
+    fill!(ends, 0)
+    for i = 0:(n - 1)
+        len = AC.loadat(views, Int32, 16i)
+        len > 12 || continue
+        k = AC.loadat(views, Int32, 16i + 8)
+        off = AC.loadat(views, Int32, 16i + 12)
+        (0 <= k < nvariadic && off >= 0) || continue
+        ends[k + 1] = max(ends[k + 1], Int64(off) + len)
+    end
+    return ends
+end
+
+function decodefield(
+    f::Field,
+    c::DecodeCursor,
+    dicts::Dict{Int64,ArrayData},
+    fielddictids::IdDict{Field,Int64},
+)
+    t = f.type
+    node = takenode!(c)
+    spec = AC.layoutspec_of(t)
+    n = Int64(node.length)
+    buffers = BufferSlice[]
+    for role in spec.buffers
+        push!(buffers, takebuffer!(c, _neededbytes(role, spec, n, buffers)))
+    end
+    if spec.variadic
+        # View layouts append their declared count of variadic data buffers
+        # after the fixed validity/views pair (format 1.4).
+        nvariadic = takevariadic!(c)
+        ends = _variadicends(c, buffers[end], n, nvariadic)
+        for k = 1:nvariadic
+            push!(buffers, takebuffer!(c, ends === nothing ? Int64(-1) : ends[k]))
+        end
+    end
+    for (role, buffer) in zip(spec.buffers, buffers)
+        # A zero-length array may omit its offsets buffer entirely; Core
+        # accepts that canonical empty form, and nanoarrow and C++ write it.
+        # A PARTIAL offsets buffer — nonempty but short of one slot — is
+        # still malformed framing.
+        if role == AC.OFFSETS && node.length == 0 && 0 < buffer.len < spec.offsetwidth
+            throw(ValidationError("IPC offsets buffer is shorter than one offset slot"))
+        end
+    end
+    children = ArrayData[]
+    if t isa DictionaryType
+        # Index buffers were just consumed; values come from the side table.
+        id = fielddictids[f]
+        haskey(dicts, id) || throw(
+            ValidationError(
+                "record batch references dictionary id $id before its dictionary batch",
+            ),
+        )
+        return ArrayData(
+            t,
+            node.length,
+            buffers;
+            dictionary=dicts[id],
+            nullcount=node.null_count,
+        )
+    end
+    nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+    for i = 1:nchildren
+        push!(children, decodefield(f.children[i], c, dicts, fielddictids))
+    end
+    if t isa UnionType && t.mode == AC.SparseMode
+        all(child -> child.len == node.length, children) ||
+            throw(ValidationError("IPC sparse-union children must equal the union length"))
+    end
+    return ArrayData(t, node.length, buffers; children=children, nullcount=node.null_count)
+end
+
+function validaterecordcolumns(
+    fields,
+    cols,
+    validated_dictionaries::AC._ValidatedDictionaries,
+)
+    for (f, col) in zip(fields, cols)
+        # One IPC dictionary id can back many fields. Compatible value
+        # schemas were proved when the stream schema was built. Each immutable
+        # pool snapshot is fully certified at its DictionaryBatch, so record
+        # validation skips that pool tree. Index contracts still run
+        # independently for every field.
+        AC._validate_semantic(f, col, validated_dictionaries)
+    end
+    return validated_dictionaries
+end
+
+"""
+The sequential half of decoding a record batch: its codec, its length, and
+where each top-level field's nodes and buffers start. A metadata-only walk
+(`skipfield!`) checks the whole node and buffer table first; the fields then
+decode independently (`_decodeplanned`), in any order or concurrently.
+"""
+struct _RecordPlan{B}
+    header::Meta.RecordBatch
+    body::B
+    codec::Int8
+    variadics::Vector{Int64}
+    rblen::Int64
+    # Cursor (node, buffer, variadic count, last buffer end) at each field.
+    starts::Vector{NTuple{4,Int64}}
+end
+
+function _recordplan(header::Meta.RecordBatch, body, version::Int16, fields, limits::Limits)
+    codec = _batchcodec(header.compression, version)
+    rblen = something(header.length, Int64(0))
+    rblen >= 0 || throw(ValidationError("record batch length $rblen is negative"))
+    rblen <= limits.max_array_length || _limiterror(
+        "record batch length $rblen",
+        "max_array_length",
+        limits.max_array_length,
+    )
+    variadics = variadiccounts(header)
+    c = DecodeCursor(
+        header.nodes,
+        header.buffers,
+        body,
+        limits;
+        codec=codec,
+        variadics=variadics,
+    )
+    starts = Vector{NTuple{4,Int64}}(undef, length(fields))
+    for (j, f) in enumerate(fields)
+        starts[j] = (c.nodeidx, c.bufidx, c.varidx, c.last_nonempty_end)
+        skipfield!(f, c)
+    end
+    finishcursor!(c)
+    return _RecordPlan(header, body, codec, variadics, rblen, starts)
+end
+
+"Decode and validate field `j` of a planned record batch."
+function _decodeplanned(
+    p::_RecordPlan,
+    j::Int,
+    f::Field,
+    dicts::Dict{Int64,ArrayData},
+    fielddictids::IdDict{Field,Int64},
+    limits::Limits,
+    validated_dictionaries,
+    state::DecodeState,
+)
+    c = DecodeCursor(
+        p.header.nodes,
+        p.header.buffers,
+        p.body,
+        limits;
+        codec=p.codec,
+        state=state,
+        variadics=p.variadics,
+    )
+    c.nodeidx, c.bufidx, c.varidx, c.last_nonempty_end = p.starts[j]
+    col = decodefield(f, c, dicts, fielddictids)
+    # One IPC dictionary id can back many fields. Each immutable pool
+    # snapshot was certified at its DictionaryBatch, so semantic validation
+    # skips that pool tree; index contracts still run for every field.
+    AC._validate_semantic(f, col, validated_dictionaries)
+    col.len == p.rblen ||
+        throw(ValidationError("RecordBatch length does not match top-level field nodes"))
+    return col
+end
+
+"""
+Arrow 0.17 V4 streams signaled buffer compression on the Message, before
+RecordBatch.compression existed. Reject that legacy marker before treating
+its length-prefixed compressed buffers as raw data.
+"""
+function rejectexperimentalcompression(
+    msg::Meta.Message,
+    version::Int16,
+    header_type::UInt8,
+)
+    version == Int16(3) || return nothing # V4
+    header_type in (UInt8(2), UInt8(3)) || return nothing
+    metadata = msg.custom_metadata
+    metadata === nothing && return nothing
+    any(kv -> kv.key == EXPERIMENTAL_COMPRESSION_KEY, metadata) && throw(
+        ValidationError(
+            "pre-1.0 experimental V4 IPC compression (the " *
+            "ARROW:experimental_compression metadata convention, superseded " *
+            "by V5 BodyCompression in 2020) is not supported",
+        ),
+    )
+    return nothing
+end
+rejectexperimentalcompression(fm::FramedMessage) =
+    rejectexperimentalcompression(fm.msg, fm.version, fm.header_type)
+
+# ---------------------------------------------------------------------------
+# Stream reader: RecordBatchSource over framed messages
+# ---------------------------------------------------------------------------
+
+mutable struct IPCStream <: AC.RecordBatchSource
+    schema::Schema
+    corefields::AC.FrozenVector{Field}
+    batches::Vector{AC.RecordBatch}
+    region::OwnerRegion                  # one lifetime root for the wire bytes
+    nextindex::Int
+    @atomic pulling::Bool
+    fielddictids::IdDict{Field,Int64}   # adapter-side id table (shared ids preserved)
+    dictionaries::Dict{Int64,ArrayData} # final pools, including updates after the last record
+    budget::AllocationBudget           # framing, decode, and facade materialization
+    limits::Limits                     # complete policy used when this handle opened
+end
+
+AC.schema(s::IPCStream) = s.schema
+
+function AC.nextbatch!(s::IPCStream)
+    # One active pull at a time: the claim CAS rejects concurrent callers
+    # (fail closed, no duplicated or skipped batches) and is released on
+    # every exit path.
+    _, ok = @atomicreplace s.pulling false => true
+    ok || throw(
+        Base.ConcurrencyViolationError(
+            "IPCStream supports only one active nextbatch! call",
+        ),
+    )
+    try
+        i = s.nextindex
+        i > length(s.batches) && return nothing
+        b = s.batches[i]
+        s.nextindex = i + 1
+        return b
+    finally
+        @atomic :release s.pulling = false
+    end
+end
+
+"""
+Map a batch's declared BodyCompression to a codec id, enforcing the spec
+subset this adapter supports: BUFFER-method LZ4_FRAME or ZSTD.
+BodyCompression is V5-only; a V4 batch that declares it is refused.
+"""
+function _batchcodec(compression, version::Int16)::Int8
+    compression === nothing && return CODEC_NONE
+    version == Int16(4) || throw(ValidationError("BodyCompression requires metadata V5"))
+    method = something(compression.method, Meta.BodyCompressionMethod.BUFFER)
+    method == Meta.BodyCompressionMethod.BUFFER ||
+        throw(ValidationError("unsupported body-compression method $method"))
+    codec = something(compression.codec, Meta.CompressionType.LZ4_FRAME)
+    codec == Meta.CompressionType.LZ4_FRAME && return CODEC_LZ4_FRAME
+    codec == Meta.CompressionType.ZSTD && return CODEC_ZSTD
+    throw(ValidationError("unsupported compression codec $codec"))
+end
+
+"""
+    readstream(bytes; limits=Limits()) -> IPCStream
+
+Decode a stream from a borrowed byte vector. Raw batch buffers remain
+zero-copy views of `bytes`; positively compressed buffers become exact-sized
+owned copies. The caller must not mutate or resize `bytes` until the returned
+stream and all batches from it are unreachable (the facade's `Arrow.Table`
+and `Arrow.Stream` own their backing storage and do not expose this borrow).
+`IPCStream` is a single-owner cursor; overlapping `nextbatch!` calls throw
+`ConcurrencyViolationError`.
+"""
+readstream(bytes::Vector{UInt8}; limits::Limits=Limits()) =
+    _readstream(bytes, limits, _readbudget(limits, length(bytes)))
+
+"""
+The schema of an IPC stream from its first message: the Core schema and
+fields, the dictionary ids, and each dictionary's value field.
+"""
+function _streamschema(fm::FramedMessage)
+    fm.header_type == 1 || # Schema
+        throw(ValidationError("first IPC message must be a schema"))
+    fm.msg.header isa Meta.Schema ||
+        throw(ValidationError("first IPC message must be a schema"))
+    metaschema = fm.msg.header
+    fm.body.len == 0 || throw(ValidationError("schema message must have an empty body"))
+    endian = something(metaschema.endianness, Meta.Endianness.Little)
+    endian == Meta.Endianness.Little || throw(
+        ValidationError("big-endian IPC is not supported (no endianness normalization)"),
+    )
+    dictids = Dict{Int64,Meta.Field}()
+    fielddictids = IdDict{Field,Int64}()   # adapter-side id table
+    fields = Field[
+        corefield(f, dictids, fielddictids) for
+        f in something(metaschema.fields, Meta.Field[])
+    ]
+    foreach(validateschemafield, fields)
+    dictvaluefields = validatedictionaryids(fields, fielddictids)
+    sch = Schema(
+        fields;
+        metadata=coremetadata(metaschema.custom_metadata),
+        endianness=AC.LittleEndian,
+    )
+    return sch, fields, dictids, fielddictids, dictvaluefields
+end
+
+"""
+The decoding state of an IPC stream after its schema: the dictionaries as of
+the last message applied and the stream's metadata version.
+"""
+struct _StreamState
+    schema::Schema
+    fields::Vector{Field}
+    dictids::Dict{Int64,Meta.Field}
+    fielddictids::IdDict{Field,Int64}
+    dictvaluefields::Dict{Int64,Field}
+    dicts::Dict{Int64,ArrayData}
+    validated::AC._ValidatedDictionaries
+    version::Int16
+    limits::Limits
+end
+
+function _StreamState(fm::FramedMessage, limits::Limits)
+    sch, fields, dictids, fielddictids, dictvaluefields = _streamschema(fm)
+    return _StreamState(
+        sch,
+        fields,
+        dictids,
+        fielddictids,
+        dictvaluefields,
+        Dict{Int64,ArrayData}(),
+        AC._ValidatedDictionaries(),
+        fm.version,
+        limits,
+    )
+end
+
+# A message after the schema: its version, and the legacy V4 compression
+# marker (see rejectexperimentalcompression).
+function _checkstreammessage(st::_StreamState, fm::FramedMessage)
+    fm.version == st.version ||
+        throw(ValidationError("IPC metadata version changes within the stream"))
+    rejectexperimentalcompression(fm)
+    return nothing
+end
+
+"""
+The values of dictionary batch `rb` (its RecordBatch, under message version
+`version`), decoded from `body` as field `vf`.
+"""
+function _decodedictionary(
+    rb::Meta.RecordBatch,
+    body,
+    version::Int16,
+    vf::Field,
+    dicts,
+    fielddictids,
+    limits::Limits,
+    state::DecodeState,
+)
+    rblen = something(rb.length, Int64(0))
+    rblen >= 0 || throw(ValidationError("dictionary batch length $rblen is negative"))
+    rblen <= limits.max_array_length || _limiterror(
+        "dictionary batch length $rblen",
+        "max_array_length",
+        limits.max_array_length,
+    )
+    cursor = DecodeCursor(
+        rb.nodes,
+        rb.buffers,
+        body,
+        limits;
+        codec=_batchcodec(rb.compression, version),
+        state=state,
+        variadics=variadiccounts(rb),
+    )
+    decoded = decodefield(vf, cursor, dicts, fielddictids)
+    finishcursor!(cursor)
+    decoded.len == rblen || throw(
+        ValidationError("dictionary RecordBatch length does not match its field node"),
+    )
+    return decoded
+end
+
+"""
+Decode dictionary batch `fm` and apply it to the stream's dictionaries (a
+first pool, a delta, or a replacement). Returns its id, the pool now in
+effect, and whether the id already had one.
+"""
+function _applydictionary!(
+    st::_StreamState,
+    fm::FramedMessage,
+    budget::AllocationBudget,
+    state::DecodeState,
+)
+    header = fm.msg.header::Meta.DictionaryBatch
+    rb = header.data
+    haskey(st.dictids, header.id) ||
+        throw(ValidationError("dictionary batch has unknown id $(header.id)"))
+    replacement = haskey(st.dicts, header.id)
+    _dictionarytransition(header.id, header.isDelta, replacement)
+    # A dictionary batch's payload is a one-column record batch of the VALUE
+    # type, so the generic decoder handles it. Pool nullability is
+    # independent of the encoded index field.
+    haskey(st.dictvaluefields, header.id) ||
+        throw(ValidationError("dictionary batch has unknown id $(header.id)"))
+    vf = st.dictvaluefields[header.id]
+    decoded = _decodedictionary(
+        rb,
+        fm.body,
+        fm.version,
+        vf,
+        st.dicts,
+        st.fielddictids,
+        st.limits,
+        state,
+    )
+    decoded = _updatedictionary!(
+        st.dicts,
+        st.validated,
+        header.id,
+        header.isDelta,
+        vf,
+        decoded,
+        st.limits,
+        budget,
+    )
+    return header.id, decoded, replacement
+end
+
+"""
+A record batch of a stream, planned against the dictionaries in effect at its
+position. The IPC format lets a batch whose dictionary column is all null
+arrive before that dictionary; such a batch waits (`missing` is not empty)
+until the dictionary arrives, and then decodes with it.
+"""
+mutable struct PendingRecord
+    plan::_RecordPlan{BufferSlice}
+    dictionaries::Dict{Int64,ArrayData}
+    missing::Set{Int64}
+    budget::AllocationBudget
+end
+
+function _pendingrecord(st::_StreamState, fm::FramedMessage, budget::AllocationBudget)
+    header = fm.msg.header::Meta.RecordBatch
+    missing = missingdicts(st.fields, header.nodes, st.dicts, st.fielddictids)
+    plan = _recordplan(header, fm.body, fm.version, st.fields, st.limits)
+    return PendingRecord(plan, copy(st.dicts), missing, budget)
+end
+
+# A dictionary that arrived resolves the records waiting for it.
+function _resolvepending!(queue, id::Int64, pool::ArrayData)
+    for p in queue
+        p isa PendingRecord && id in p.missing || continue
+        p.dictionaries[id] = pool
+        delete!(p.missing, id)
+    end
+    return queue
+end
+
+"""
+Decode the fields of planned records `ps` (every one resolved) on at most
+`ntasks` tasks, one (record, field) pair at a time.
+"""
+function _decoderecords(st::_StreamState, ps::Vector{PendingRecord}, ntasks::Int)
+    isempty(ps) && return AC.RecordBatch[]
+    nf = length(st.fields)
+    cols = [Vector{ArrayData}(undef, nf) for _ in ps]
+    # One codec state per task, charging the budget of the record at hand.
+    states = [DecodeState(first(ps).budget) for _ = 1:min(ntasks, length(ps) * nf)]
+    try
+        _foreach(length(ps) * nf, ntasks) do item, w
+            k, j = divrem(item - 1, nf) .+ (1, 1)
+            p = ps[k]
+            state = states[w]
+            state.budget = p.budget
+            cols[k][j] = _decodeplanned(
+                p.plan,
+                j,
+                st.fields[j],
+                p.dictionaries,
+                st.fielddictids,
+                st.limits,
+                st.validated,
+                state,
+            )
+            return nothing
+        end
+    finally
+        foreach(close, states)
+    end
+    return AC.RecordBatch[
+        AC.RecordBatch(st.schema, cols[k], p.plan.rblen, st.validated) for
+        (k, p) in enumerate(ps)
+    ]
+end
+
+"""
+The framed stream in `region`: its decoding state after every message, and its
+record batches planned against the dictionaries in effect at each.
+"""
+function _streamrecords(region::OwnerRegion, limits::Limits, budget::AllocationBudget)
+    msgs = _framemessages(region, limits, Base.ENDIAN_BOM, budget)
+    isempty(msgs) && throw(ValidationError(_emptystream(region.len)))
+    st = _StreamState(msgs[1], limits)
+    # One codec context per reader for the dictionary batches, which apply in
+    # order; record batches are planned in order and decoded together after.
+    state = DecodeState(budget)
+    records = PendingRecord[]
+    try
+        for fm in msgs[2:end]
+            _checkstreammessage(st, fm)
+            header = fm.msg.header
+            if header isa Meta.DictionaryBatch
+                id, pool, replaced = _applydictionary!(st, fm, budget, state)
+                # Waiting records take an id's first pool only; a later
+                # replacement is for the records after it.
+                replaced || _resolvepending!(records, id, pool)
+            elseif header isa Meta.RecordBatch
+                push!(records, _pendingrecord(st, fm, budget))
+            else
+                throw(ValidationError("unsupported IPC message header $(typeof(header))"))
+            end
+        end
+    finally
+        close(state)
+    end
+    all(p -> isempty(p.missing), records) ||
+        throw(ValidationError("stream ended before required dictionary batches arrived"))
+    return st, records
+end
+
+function _readstream(
+    bytes::Vector{UInt8},
+    limits::Limits,
+    budget::AllocationBudget,
+    ntasks::Int=1,
+)
+    region = heapregion(bytes)
+    st, records = _streamrecords(region, limits, budget)
+    return IPCStream(
+        st.schema,
+        AC.FrozenVector{Field}(st.fields),
+        _decoderecords(st, records, ntasks),
+        region,
+        1,
+        false,
+        st.fielddictids,
+        st.dicts,
+        budget,
+        limits,
+    )
+end
+
+# --- incremental streams ----------------------------------------------------
+
+"""
+The messages of an IPC stream, framed one at a time from a byte region (a
+byte vector or a memory map) as the reader reaches them.
+"""
+mutable struct _RegionMessages
+    const blob::BufferSlice
+    pos::Int64
+end
+_RegionMessages(region::OwnerRegion) =
+    _RegionMessages(BufferSlice(region, 0, region.len), 0)
+
+function _nextmessage!(m::_RegionMessages, limits::Limits, budget::AllocationBudget)
+    fm, m.pos = _framemessage(m.blob, m.pos, limits, budget, 0)
+    return fm
+end
+
+"""
+The messages of an IPC stream read from an `IO` one at a time: each message's
+metadata and body are read when the reader reaches them, so a pipe or socket
+streams with one message in memory. `head` holds bytes already read from the
+`IO` (while telling the formats apart).
+"""
+mutable struct _IOMessages{I<:IO}
+    const io::I
+    head::Vector{UInt8}
+    pos::Int64
+end
+
+# Read `n` bytes into `out` from index `at` on; false when the stream ends first.
+function _readinto!(m::_IOMessages, out::Vector{UInt8}, at::Int, n::Int)
+    k = min(length(m.head), n)
+    copyto!(out, at, m.head, 1, k)
+    deleteat!(m.head, 1:k)
+    if k < n
+        try
+            GC.@preserve out unsafe_read(m.io, pointer(out, at + k), UInt(n - k))
+        catch e
+            e isa EOFError || rethrow()
+            return false
+        end
+    end
+    m.pos += n
+    return true
+end
+
+function _readbytes!(m::_IOMessages, n::Int64)
+    out = Vector{UInt8}(undef, Int(n))
+    return _readinto!(m, out, 1, Int(n)) ? out : nothing
+end
+
+# A body is read in pieces of growing size, so a declared length the stream
+# does not back costs only the bytes that arrive. Those bytes are the input
+# itself, so they are not charged to the reader's allowance.
+const _IO_BODY_PIECE = 64 * 1024 * 1024
+
+function _readbody!(m::_IOMessages, bodylen::Int64)
+    body = UInt8[]
+    while length(body) < bodylen
+        have = length(body)
+        n = Int(min(bodylen - have, max(_IO_BODY_PIECE, have)))
+        resize!(body, have + n)
+        _readinto!(m, body, have + 1, n) ||
+            throw(ValidationError("truncated body: need $bodylen bytes at byte $(m.pos)"))
+    end
+    return body
+end
+
+function _nextmessage!(m::_IOMessages, limits::Limits, budget::AllocationBudget)
+    at = m.pos
+    isempty(m.head) && eof(m.io) && return nothing   # the stream ended between messages
+    prefix = _readbytes!(m, Int64(8))
+    prefix === nothing && throw(ValidationError("truncated IPC prefix at byte $at"))
+    word = reinterpret(UInt32, prefix)[1]
+    word == CONTINUATION || throw(ValidationError(_nomarker(at, word)))
+    metalen = Int64(ltoh(reinterpret(Int32, prefix)[2]))
+    metalen == 0 && return nothing   # end-of-stream marker
+    _checkmetalen(metalen, limits)
+    _chargevector!(budget, UInt8, metalen, "metadata allocation")
+    metabytes = _readbytes!(m, metalen)
+    metabytes === nothing &&
+        throw(ValidationError("truncated metadata: need $metalen bytes at $at"))
+    msg, version, header_type, features, bodylen =
+        _verifiedmessage(metabytes, limits, budget)
+    body = _readbody!(m, bodylen)
+    return FramedMessage(
+        msg,
+        BufferSlice(heapregion(body), 0, length(body)),
+        version,
+        header_type,
+        features,
+    )
+end
+
+# The budget a stream message frames under; its batch then decodes under one
+# sized from the message's own bytes.
+_framebudget(limits::Limits) = _readbudget(limits, 0)
+
+"""
+An IPC stream read incrementally: messages are read and decoded as record
+batches are requested (`_nextrecord!`), each under its own allowance, so a
+stream of any length reads with one batch in memory. A stream over a byte
+region can start over; one over an `IO` reads once.
+"""
+mutable struct _StreamReader{M}
+    const messages::M
+    const start::Int64                 # position after the schema
+    # The lifetime authority of the stream and its batches: the byte region,
+    # or for an `IO` (each body is its own region) an empty one.
+    const region::OwnerRegion
+    st::_StreamState
+    missing::Set{Int64}                # dictionaries promised by all-null batches
+    done::Bool
+    failed::Bool                       # a read threw; the stream stops there
+    const limits::Limits
+    const lock::ReentrantLock
+end
+
+function _StreamReader(messages, limits::Limits)
+    _validatelimits(limits)
+    fm = _nextmessage!(messages, limits, _framebudget(limits))
+    fm === nothing && throw(ValidationError(_emptystream(messages.pos)))
+    st = _StreamState(fm, limits)
+    region = messages isa _RegionMessages ? messages.blob.region : heapregion(UInt8[])
+    return _StreamReader(
+        messages,
+        messages.pos,
+        region,
+        st,
+        Set{Int64}(),
+        false,
+        false,
+        limits,
+        ReentrantLock(),
+    )
+end
+
+# Start over from the first batch (a byte region or a byte-range source).
+function _restart!(r::_StreamReader)
+    # A reader that has not read past its schema is at the start already.
+    r.messages.pos == r.start && isempty(r.missing) && !r.done && !r.failed && return r
+    m = r.messages
+    if m isa _IOMessages{_SourceIO}
+        empty!(m.head)
+        m.io.pos = r.start
+    elseif !(m isa _RegionMessages)
+        throw(
+            ArgumentError(
+                "an Arrow.Stream over an IO reads its batches once; " *
+                "read the IO into a byte vector to iterate it again",
+            ),
+        )
+    end
+    m.pos = r.start
+    st = r.st
+    r.st = _StreamState(
+        st.schema,
+        st.fields,
+        st.dictids,
+        st.fielddictids,
+        st.dictvaluefields,
+        Dict{Int64,ArrayData}(),
+        AC._ValidatedDictionaries(),
+        st.version,
+        st.limits,
+    )
+    empty!(r.missing)
+    r.done = false
+    r.failed = false
+    return r
+end
+
+"""
+The next record batch of the stream, planned against the dictionaries in
+effect for it, and the allowance it decodes under; `nothing` at its end.
+Messages are read until the next batch in stream order is decodable.
+"""
+function _nextrecord!(r::_StreamReader)
+    r.failed && throw(
+        ArgumentError(
+            "this Arrow.Stream stopped at an error; open a new one to read the source again",
+        ),
+    )
+    try
+        return _readrecord!(r)
+    catch
+        r.failed = true
+        rethrow()
+    end
+end
+
+function _readrecord!(r::_StreamReader)
+    while true
+        if r.done
+            isempty(r.missing) && return nothing
+            throw(
+                ValidationError("stream ended before required dictionary batches arrived"),
+            )
+        end
+        fm = _nextmessage!(r.messages, r.limits, _framebudget(r.limits))
+        if fm === nothing
+            r.done = true
+            continue
+        end
+        _checkstreammessage(r.st, fm)
+        budget = _readbudget(r.limits, fm.body.len)
+        header = fm.msg.header
+        if header isa Meta.DictionaryBatch
+            state = DecodeState(budget)
+            try
+                id, _, _ = _applydictionary!(r.st, fm, budget, state)
+                delete!(r.missing, id)
+            finally
+                close(state)
+            end
+        elseif header isa Meta.RecordBatch
+            p = _pendingrecord(r.st, fm, budget)
+            # An all-null batch needs no pool values. Yield it now, even when
+            # its dictionary has not arrived, without retaining later batches.
+            union!(r.missing, p.missing)
+            for id in p.missing
+                p.dictionaries[id] = _dictionaryconcat(
+                    r.st.dictvaluefields[id],
+                    _DictionaryRange[],
+                    r.limits,
+                    budget,
+                )
+            end
+            return p, budget
+        else
+            throw(ValidationError("unsupported IPC message header $(typeof(header))"))
+        end
+    end
+end
+
+"The number of record batches of a region stream, from its framing alone."
+function _countrecords(r::_StreamReader{_RegionMessages})
+    m = _RegionMessages(r.messages.blob, r.start)
+    n = 0
+    while true
+        fm = _nextmessage!(m, r.limits, _framebudget(r.limits))
+        fm === nothing && return n
+        fm.msg.header isa Meta.RecordBatch && (n += 1)
+    end
+end
+
+# ---------------------------------------------------------------------------
+# File reader: footer verification + lazy random-access batch handle
+# ---------------------------------------------------------------------------
+
+_blocktuples(blocks) =
+    blocks === nothing ? NTuple{3,Int64}[] :
+    NTuple{3,Int64}[
+        (Int64(b.offset), Int64(b.metaDataLength), Int64(b.bodyLength)) for b in blocks
+    ]
+
+"""
+Footer verification, same wrapper role as `verify_ipc_metadata`: the
+generated walker bounds the whole table graph, then the verified getters
+supply the Block indexes.
+"""
+function verify_footer(
+    bytes::Vector{UInt8},
+    limits::Limits,
+    reserve_limit::Int64=limits.max_total_allocated_bytes,
+)
+    ctx = _verifyctx(limits, reserve_limit)
+    # Staged like verify_ipc_metadata: version gates between the inline and
+    # reference stages, so an unsupported footer rejects in constant time.
+    t = _verified(() -> Meta.verifyrootstart_Footer(bytes, ctx))
+    footer = FB.getrootas(Meta.Footer, bytes, 0)
+    version = Int16(Int64(footer.version))
+    version in (Int16(3), Int16(4)) ||
+        _vfail("unsupported footer version $version (only V4/V5 are accepted)")
+    _verified(() -> Meta.verifyrootrest_Footer(t, ctx))
+    features = _schemafeatures(footer.schema::Meta.Schema, version)
+    return version,
+    features,
+    _blocktuples(footer.dictionaries),
+    _blocktuples(footer.recordBatches),
+    ctx.reserved
+end
+
+"""
+    ArrowFile
+
+The footer's record-batch index as a random-access handle: `length(file)`
+batches, `file[i]` decodes batch `i` on demand. Open decodes only the schema
+and the dictionary batches every record shares. Each `getindex` decodes from
+the mapped bytes with its own allocation budget and codec contexts, and the
+handle is read-only after open, so concurrent `getindex` calls are safe. The
+region root (heap vector or Mmap array) is the only lifetime anchor, as in
+Core.
+"""
+struct ArrowFile
+    region::OwnerRegion
+    schema::Schema
+    fields::AC.FrozenVector{Field}
+    fielddictids::IdDict{Field,Int64}
+    dictionaries::Dict{Int64,ArrayData}
+    validated::AC._ValidatedDictionaries
+    recordblocks::Vector{NTuple{3,Int64}}
+    dataend::Int64
+    limits::Limits
+    schemaversion::Int16
+end
+
+Base.length(f::ArrowFile) = length(f.recordblocks)
+AC.schema(f::ArrowFile) = f.schema
+
+"""
+Range-check one Footer Block's declared extents against the data section and
+return its `(offset, frameend)` span.
+"""
+function _blockextent(block::NTuple{3,Int64}, dataend::Int64)
+    offset, metalen, bodylen = block
+    # 16 is the smallest legal prefix + metadata: an 8-byte prefix plus at
+    # least one 8-byte-aligned metadata block.
+    (offset >= 0 && metalen >= 16 && bodylen >= 0) ||
+        throw(ValidationError("footer block has invalid extents"))
+    offset % 8 == 0 || throw(ValidationError("footer block is not 8-byte aligned"))
+    metalen % 8 == 0 ||
+        throw(ValidationError("footer block metadata length is not 8-byte aligned"))
+    bodylen % 8 == 0 ||
+        throw(ValidationError("footer block body length is not 8-byte aligned"))
+    # Every extent is nonnegative, so these comparisons cannot overflow.
+    (
+        offset <= dataend &&
+        metalen <= dataend - offset &&
+        bodylen <= dataend - offset - metalen
+    ) || throw(ValidationError("footer block escapes the data section"))
+    frameend = offset + metalen + bodylen
+    return offset, frameend
+end
+
+function _validateblockindex(dictblocks, recordblocks, dataend::Int64; datastart::Int64=0)
+    extents = Tuple{Int64,Int64}[]
+    indexedend = datastart
+    for block in Iterators.flatten((dictblocks, recordblocks))
+        extent = _blockextent(block, dataend)
+        extent[1] >= datastart ||
+            throw(ValidationError("footer block overlaps the file schema"))
+        push!(extents, extent)
+        indexedend = max(indexedend, extent[2])
+    end
+    sort!(extents; by=first)
+    for i = 2:length(extents)
+        extents[i - 1][2] <= extents[i][1] ||
+            throw(ValidationError("footer blocks overlap"))
+    end
+    return indexedend
+end
+
+"""
+Verify the message footer Block `block` points at, from `meta`, the Block's
+prefix and metadata bytes: the continuation marker, the metadata length the
+Block declares, the verified metadata, and the body length the Block
+declares. Returns the message, its metadata version, header type, and
+features.
+"""
+function _blockmeta(
+    meta::BufferSlice,
+    block::NTuple{3,Int64},
+    limits::Limits,
+    budget::AllocationBudget,
+)
+    _, metalen, bodylen = block
+    AC.loadat(meta, UInt32, Int64(0)) == CONTINUATION ||
+        throw(ValidationError("footer block does not point at a message"))
+    declared = Int64(AC.loadat(meta, Int32, Int64(4)))
+    declared == metalen - 8 ||
+        throw(ValidationError("footer block metadata length does not match the message"))
+    _checkblocklengths(declared, bodylen, limits)
+    _chargevector!(budget, UInt8, declared, "metadata allocation")
+    metabytes = AC.slicebytes(AC.subslice(meta, 8, declared))
+    version, header_type, features, _ =
+        _verify_ipc_metadata_budgeted(metabytes, limits, budget)
+    msg = FB.getrootas(Meta.Message, metabytes, 0)
+    Int64(msg.bodyLength) == bodylen ||
+        throw(ValidationError("footer block body length does not match the message"))
+    return msg, version, header_type, features
+end
+
+"The message footer Block `block` points at in `region`, framed and verified."
+function _blockmessage(
+    region::OwnerRegion,
+    block::NTuple{3,Int64},
+    dataend::Int64,
+    limits::Limits,
+    budget::AllocationBudget,
+)
+    offset, _ = _blockextent(block, dataend)
+    _, metalen, bodylen = block
+    blob = BufferSlice(region, 0, region.len)
+    msg, version, header_type, features =
+        _blockmeta(AC.subslice(blob, offset, metalen), block, limits, budget)
+    return FramedMessage(
+        msg,
+        AC.subslice(blob, offset + metalen, bodylen),
+        version,
+        header_type,
+        features,
+    )
+end
+
+"""
+    readfile(bytes::Vector{UInt8}; limits=Limits()) -> ArrowFile
+    readfile(region::OwnerRegion; limits=Limits()) -> ArrowFile
+
+Open an IPC-format file: verify both magics, the footer length, the footer
+flatbuffer and its schema, and the frame of every message the footer
+indexes; eagerly decode the dictionary blocks (shared by every record batch);
+expose record batches lazily through the Block index. The schema comes from
+the footer; the leading Schema message is not read.
+Pass `mmapregion(path)` to read a file through Core's mmap path. The file
+format permits one base dictionary per id, followed by deltas.
+Full dictionary replacement remains a format error.
+
+`Arrow.Table(handle)` and `Arrow.Stream(handle)` copy a region that can be
+released eagerly, so their columns remain valid after release. Pass the path
+directly to those constructors for memory-mapped views without this copy.
+"""
+readfile(bytes::Vector{UInt8}; limits::Limits=Limits()) =
+    _readfile(heapregion(bytes), limits, _readbudget(limits, length(bytes)))
+
+readfile(region::OwnerRegion; limits::Limits=Limits()) =
+    _readfile(region, limits, _readbudget(limits, region.len))
+
+# C++ WriteFileFooter uses its current metadata version even when the
+# writer emits V4 messages, and Arrow.jl before 2.6 wrote a V4 footer over V5
+# messages. The footer must not select the message layout.
+function _filemetadataversion(footer::Int16, message::Int16, expected::Int16=message)
+    message == expected ||
+        throw(ValidationError("IPC metadata version changes within the file"))
+    (
+        footer == message ||
+        (footer in (Int16(3), Int16(4)) && message in (Int16(3), Int16(4)))
+    ) || throw(ValidationError("IPC message and footer metadata versions differ"))
+    return message
+end
+
+"""
+The verified footer of the IPC file in `src`, a region or a byte-range source:
+its schema, dictionary ids, metadata version, and Block index. The Footer is
+authoritative, as in Arrow C++: the schema comes from it and every message is
+reached through its Blocks, so the leading Schema message is never read.
+(Polars writes that message without its stream framing.) Blocks start after
+the padded leading magic (`ARROW1` plus two bytes), end before the Footer,
+and do not overlap; each message is verified against its Block when it is
+read.
+"""
+function _readfooter(src, limits::Limits, budget::AllocationBudget)
+    _requirelittleendian()
+    _validatelimits(limits)
+    # leading magic + pad (8), smallest footer flatbuffer (8), footer length
+    # (4), trailing magic (6).
+    src.len >= Int64(8 + 8 + 4 + 6) ||
+        throw(ValidationError("file is too short to be an IPC file"))
+    # The trailer is <footer><Int32 footer length><ARROW1>.
+    trailer = _lastbytes(src, 10, budget)
+    trailer[5:10] == FILE_MAGIC || throw(
+        ValidationError(
+            "missing trailing ARROW1 magic: the file is incomplete, as when a write was " *
+            "cut off or an Arrow.Writer was not closed",
+        ),
+    )
+    footerlen = Int64(ltoh(reinterpret(Int32, trailer[1:4])[1]))
+    footerlen > 0 || throw(ValidationError("footer length $footerlen is not positive"))
+    footerlen <= limits.max_metadata_bytes || _limiterror(
+        "footer length $footerlen",
+        "max_metadata_bytes",
+        limits.max_metadata_bytes,
+    )
+    footerstart = src.len - 10 - footerlen
+    footerstart >= 8 || throw(ValidationError("footer escapes the file"))
+    footerbytes = _footerbytes(src, footerstart, footerlen, budget)
+    version, features, dictblocks, recordblocks, _ =
+        _verify_footer_budgeted(footerbytes, limits, budget)
+    Int64(1) in features &&
+        throw(ValidationError("dictionary replacement is forbidden in the IPC file format"))
+    nmessages = AC.checked_add(
+        Int64(1),
+        AC.checked_add(Int64(length(dictblocks)), Int64(length(recordblocks))),
+    )
+    nmessages <= limits.max_messages ||
+        _limiterror("message count $nmessages", "max_messages", limits.max_messages)
+    metaschema = FB.getrootas(Meta.Footer, footerbytes, 0).schema
+    metaschema === nothing && throw(ValidationError("file footer carries no schema"))
+    something(metaschema.endianness, Meta.Endianness.Little) == Meta.Endianness.Little ||
+        throw(
+            ValidationError(
+                "big-endian IPC is not supported (no endianness normalization)",
+            ),
+        )
+    _validateblockindex(dictblocks, recordblocks, footerstart; datastart=Int64(8))
+    dictids = Dict{Int64,Meta.Field}()
+    fielddictids = IdDict{Field,Int64}()
+    fields = Field[
+        corefield(f, dictids, fielddictids) for
+        f in something(metaschema.fields, Meta.Field[])
+    ]
+    foreach(validateschemafield, fields)
+    dictvaluefields = validatedictionaryids(fields, fielddictids)
+    sch = Schema(
+        fields;
+        metadata=coremetadata(metaschema.custom_metadata),
+        endianness=AC.LittleEndian,
+    )
+    return (;
+        sch,
+        fields,
+        dictids,
+        fielddictids,
+        dictvaluefields,
+        version,
+        dictblocks,
+        recordblocks,
+        footerstart,
+    )
+end
+
+_lastbytes(region::OwnerRegion, n::Int, _) =
+    AC.slicebytes(AC.subslice(BufferSlice(region, 0, region.len), region.len - n, n))
+
+function _footerbytes(region::OwnerRegion, start::Int64, len::Int64, budget)
+    _chargevector!(budget, UInt8, len, "footer allocation")
+    return AC.slicebytes(AC.subslice(BufferSlice(region, 0, region.len), start, len))
+end
+
+function _readfile(region::OwnerRegion, limits::Limits, budget::AllocationBudget)
+    region.len >= 6 &&
+    AC.slicebytes(AC.subslice(BufferSlice(region, 0, region.len), 0, 6)) == FILE_MAGIC ||
+        throw(ValidationError("missing leading ARROW1 magic"))
+    ft = _readfooter(region, limits, budget)
+    framed(_, block) =
+        let fm = _blockmessage(region, block, ft.footerstart, limits, budget)
+            _filemetadataversion(ft.version, fm.version)
+            fm
+        end
+    dicts, validated = _filedictionaries(
+        framed,
+        ft.dictblocks,
+        ft.dictids,
+        ft.dictvaluefields,
+        ft.fielddictids,
+        limits,
+        budget,
+    )
+    # Every id a record batch may reference must be resolvable now unless
+    # that batch proves all-null use — checked per batch at decode.
+    return ArrowFile(
+        region,
+        ft.sch,
+        AC.FrozenVector{Field}(ft.fields),
+        ft.fielddictids,
+        dicts,
+        validated,
+        ft.recordblocks,
+        ft.footerstart,
+        limits,
+        ft.version,
+    )
+end
+
+"""
+Decode a file's dictionary batches in footer order; `framed(i, block)` returns
+block `i`'s framed message with its metadata version checked.
+"""
+function _filedictionaries(
+    framed,
+    dictblocks,
+    dictids,
+    dictvaluefields,
+    fielddictids,
+    limits::Limits,
+    budget::AllocationBudget,
+)
+    dicts = Dict{Int64,ArrayData}()
+    validated = AC._ValidatedDictionaries()
+    state = DecodeState(budget)
+    try
+        for (i, block) in enumerate(dictblocks)
+            fm = framed(i, block)
+            rejectexperimentalcompression(fm)
+            header = fm.msg.header
+            header isa Meta.DictionaryBatch ||
+                throw(ValidationError("footer dictionary block is not a dictionary batch"))
+            haskey(dictids, header.id) ||
+                throw(ValidationError("dictionary batch has unknown id $(header.id)"))
+            _dictionarytransition(
+                header.id,
+                header.isDelta,
+                haskey(dicts, header.id);
+                file=true,
+            )
+            vf = dictvaluefields[header.id]
+            decoded = _decodedictionary(
+                header.data,
+                fm.body,
+                fm.version,
+                vf,
+                dicts,
+                fielddictids,
+                limits,
+                state,
+            )
+            _updatedictionary!(
+                dicts,
+                validated,
+                header.id,
+                header.isDelta,
+                vf,
+                decoded,
+                limits,
+                budget;
+                file=true,
+            )
+        end
+        return dicts, validated
+    finally
+        close(state)
+    end
+end
+
+# Frame and check record batch `i` of `f` and plan its decode. With `mask`,
+# only the fields it selects need their dictionaries (a scan).
+function _fileplan(f::ArrowFile, i::Integer, budget::AllocationBudget, mask=nothing)
+    1 <= i <= length(f.recordblocks) || throw(BoundsError(f, i))
+    fm = _blockmessage(f.region, f.recordblocks[i], f.dataend, f.limits, budget)
+    _filemetadataversion(f.schemaversion, fm.version)
+    rejectexperimentalcompression(fm)
+    header = fm.msg.header
+    header isa Meta.RecordBatch ||
+        throw(ValidationError("footer record block is not a record batch"))
+    if mask === nothing
+        for id in missingdicts(f.fields, header.nodes, f.dictionaries, f.fielddictids)
+            throw(
+                ValidationError(
+                    "record batch references dictionary id $id " *
+                    "with no dictionary batch in the file",
+                ),
+            )
+        end
+    else
+        _recordbatchmeta(header, f.fields, f.limits, fm.body.len)
+        _scanmissingdicts(f.fields, header.nodes, f.dictionaries, f.fielddictids, mask)
+    end
+    return _recordplan(header, fm.body, fm.version, f.fields, f.limits)
+end
+
+_decodefilefield(f::ArrowFile, p::_RecordPlan, j::Int, state::DecodeState) = _decodeplanned(
+    p,
+    j,
+    f.fields[j],
+    f.dictionaries,
+    f.fielddictids,
+    f.limits,
+    f.validated,
+    state,
+)
+
+function _filebatch(f::ArrowFile, i::Integer, state::DecodeState)
+    p = _fileplan(f, i, state.budget)
+    cols = ArrayData[_decodefilefield(f, p, j, state) for j = 1:length(f.fields)]
+    return AC.RecordBatch(f.schema, cols, p.rblen, f.validated)
+end
+
+function Base.getindex(f::ArrowFile, i::Integer)
+    budget = _readbudget(f.limits, f.region.len)
+    state = DecodeState(budget)
+    try
+        return _filebatch(f, i, state)
+    finally
+        close(state)
+    end
+end
diff --git a/src/ipc_write.jl b/src/ipc_write.jl
new file mode 100644
index 00000000..be5236d0
--- /dev/null
+++ b/src/ipc_write.jl
@@ -0,0 +1,1795 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# The IPC writer, plus the file-format reader (`readfile`), over ArrowCore.
+#
+#   * Batch encode is the inverse of decode, one implementation: ONE generic
+#     `encodefield!` walks the SAME `layoutspec` registry the decoder walks —
+#     node, registry buffers in registry order, children in declared order.
+#     There are no per-layout write methods to skew against the read side.
+#
+#   * Dictionary state machine, replacement-on-change: each batch's pools
+#     are captured by identity. A dictionary batch is emitted before the
+#     first record batch that references its id and again ONLY when a later
+#     batch's pool for that id is a different snapshot. Replacement streams
+#     declare Feature.DICTIONARY_REPLACEMENT in the schema.
+#
+#   * Compression at encode: per-buffer LZ4_FRAME/ZSTD with the Int64
+#     uncompressed-length prefix, the `-1` stored-raw fallback when
+#     compression does not help, codec objects owned per writer and
+#     explicitly finalized. Compressed streams declare Feature.COMPRESSED_BODY;
+#     the reader accepts compressed batches with or without the declaration.
+#
+#   * File format = stream framing + a Block index + a Footer: the writer
+#     isolates footer bookkeeping from generic message writing; `readfile`
+#     exposes the footer's record-batch index as a lazy random-access handle
+#     (`length`/`getindex`) over one borrowed or mmapped region.
+# =============================================================================
+
+# ---------------------------------------------------------------------------
+# Encode-side codec state: per-writer objects, explicitly finalized (both
+# codecs share TranscodingStreams' one streams API)
+# ---------------------------------------------------------------------------
+
+mutable struct EncodeState
+    zstd::Ptr{ZSTD.ZSTD_CCtx}   # created on first use
+    const level::Union{Nothing,Int}   # codec compression level; nothing = codec default
+    # Compressed frames this state wrote for messages not yet published, and
+    # the published ones' vectors, reused for later frames: fresh memory
+    # faults its pages in, which several threads cannot do at once.
+    const inuse::Vector{Vector{UInt8}}
+    const free::Vector{Vector{UInt8}}
+end
+EncodeState(level::Union{Nothing,Integer}=nothing) = EncodeState(
+    Ptr{ZSTD.ZSTD_CCtx}(C_NULL),
+    level === nothing ? nothing : Int(level),
+    Vector{UInt8}[],
+    Vector{UInt8}[],
+)
+
+"""
+Vectors the writer's columns rebuild for each record batch (string offsets and
+bytes, validity bitmaps), taken here while the batch builds and returned once
+it is published, so a write holds about one batch of them instead of every
+batch until the GC runs; reused memory also skips the page faults that fresh
+memory takes, which several threads cannot take at once.
+"""
+struct _BufferPool
+    lock::ReentrantLock
+    bytes::Vector{Vector{UInt8}}
+    i32::Vector{Vector{Int32}}
+    i64::Vector{Vector{Int64}}
+    # Handed out since the last `_handoff!`: the batch being built.
+    taken::Vector{Any}
+end
+_BufferPool() =
+    _BufferPool(ReentrantLock(), Vector{UInt8}[], Vector{Int32}[], Vector{Int64}[], Any[])
+
+_freelist(p::_BufferPool, ::Type{UInt8}) = p.bytes
+_freelist(p::_BufferPool, ::Type{Int32}) = p.i32
+_freelist(p::_BufferPool, ::Type{Int64}) = p.i64
+
+"""
+A `Vector{T}` of length `n`, from `pool` (or new without one): the shortest
+free vector at least that long, else the longest one, grown.
+"""
+function _takevector(pool, ::Type{T}, n::Int) where {T}
+    pool === nothing && return Vector{T}(undef, n)
+    p = pool::_BufferPool
+    @lock p.lock begin
+        free = _freelist(p, T)
+        k = 0
+        for (i, v) in enumerate(free)
+            m, best = length(v), k == 0 ? 0 : length(free[k])
+            if k == 0 || (m >= n ? (best < n || m < best) : (best < n && m > best))
+                k = i
+            end
+        end
+        v = k == 0 ? Vector{T}(undef, n) : resize!(popat!(free, k), n)
+        push!(p.taken, v)
+        v
+    end
+end
+
+"The vectors taken for the batch just built, to return once it is published."
+function _handoff!(pool)
+    pool === nothing && return nothing
+    p = pool::_BufferPool
+    @lock p.lock begin
+        out = copy(p.taken)
+        empty!(p.taken)
+        (p, out)
+    end
+end
+
+"Return a published batch's vectors, except those a kept dictionary still uses."
+function _recycle!(st, recycle)
+    recycle === nothing && return nothing
+    p, vectors = recycle
+    kept = Base.IdSet{Any}()
+    for d in values(st.current)
+        _bufferroots!(kept, d)
+    end
+    @lock p.lock for v in vectors
+        AC._storageroot(v) in kept || push!(_freelist(p, eltype(v)), v)
+    end
+    return nothing
+end
+
+function _bufferroots!(roots, d::ArrayData)
+    for b in d.buffers
+        b.region === nothing || push!(roots, b.region.root)
+    end
+    foreach(c -> _bufferroots!(roots, c), d.children)
+    d.dictionary === nothing || _bufferroots!(roots, d.dictionary)
+    return roots
+end
+
+"Return the frames of published messages to their states for reuse."
+function _recycleframes!(states::Vector{EncodeState})
+    for s in states
+        append!(s.free, s.inuse)
+        empty!(s.inuse)
+    end
+    return nothing
+end
+
+# One LZ4 frame of `raw` from a fresh context (about half a microsecond). A
+# reused context keeps its previous input's hash table (LZ4's fast reset),
+# which changes the output, so which task compressed which buffer would show
+# in the bytes.
+function _lz4frame(s::EncodeState, raw::TS.Buffer, out::Vector{UInt8})
+    c =
+        s.level === nothing ? LZ4FrameCompressor() :
+        LZ4FrameCompressor(; compressionlevel=s.level)
+    TS.initialize(c)
+    try
+        return transcode(c, raw, out)
+    finally
+        TS.finalize(c)
+    end
+end
+
+# One Zstandard frame of the `len` bytes at `ptr`, which records its content
+# size. Compressing a whole buffer at once takes about 10% less time than a
+# stream, and gives the same bytes whatever the context compressed before.
+function _zstdframe(s::EncodeState, ptr::Ptr{UInt8}, len::Int, out::Vector{UInt8})
+    if s.zstd == C_NULL
+        s.zstd = ZSTD.ZSTD_createCCtx()
+        s.zstd == C_NULL && throw(OutOfMemoryError())
+        # A writer abandoned without `close` must not leak the context.
+        finalizer(close, s)
+    end
+    level = s.level === nothing ? CZSTD.DEFAULT_COMPRESSION_LEVEL : s.level
+    n = GC.@preserve out ZSTD.ZSTD_compressCCtx(
+        s.zstd,
+        pointer(out),
+        length(out),
+        ptr,
+        len,
+        level,
+    )
+    ZSTD.ZSTD_isError(n) == 0 ||
+        error("Zstandard compression failed: ", unsafe_string(ZSTD.ZSTD_getErrorName(n)))
+    return resize!(out, Int(n))
+end
+
+function Base.close(s::EncodeState)
+    zstd = s.zstd
+    s.zstd = Ptr{ZSTD.ZSTD_CCtx}(C_NULL)
+    zstd == C_NULL || ZSTD.ZSTD_freeCCtx(zstd)
+    return nothing
+end
+
+# ---------------------------------------------------------------------------
+# Metadata building: Core descriptors -> Meta tables (inverse of `coretype`)
+# ---------------------------------------------------------------------------
+
+_metatimeunit(u) =
+    u == AC.SECOND ? Meta.TimeUnit.SECOND :
+    u == AC.MILLISECOND ? Meta.TimeUnit.MILLISECOND :
+    u == AC.MICROSECOND ? Meta.TimeUnit.MICROSECOND : Meta.TimeUnit.NANOSECOND
+
+"""
+Build the flatbuffer TYPE table for one Core descriptor. Returns
+`(tag type, table offset)` for `fieldAddTypeType`/`fieldAddType`. The isa
+ladder is the encode half of `coretype`; a descriptor outside the mapped set
+is a clean writer refusal, mirroring the reader's refusal of unmapped tags.
+"""
+function metatype!(b::FB.Builder, t::ArrowType)
+    if t isa IntType
+        Meta.intStart(b)
+        Meta.intAddBitWidth(b, Int32(t.bits))
+        Meta.intAddIsSigned(b, t.signed)
+        return Meta.Int, Meta.intEnd(b)
+    elseif t isa FloatType
+        Meta.floatingPointStart(b)
+        Meta.floatingPointAddPrecision(
+            b,
+            t.bits == 16 ? Meta.Precision.HALF :
+            t.bits == 32 ? Meta.Precision.SINGLE : Meta.Precision.DOUBLE,
+        )
+        return Meta.FloatingPoint, Meta.floatingPointEnd(b)
+    elseif t isa BoolType
+        Meta.boolStart(b)
+        return Meta.Bool, Meta.boolEnd(b)
+    elseif t isa Utf8Type
+        if t.large
+            Meta.largeUtf8Start(b)
+            return Meta.LargeUtf8, Meta.largeUtf8End(b)
+        end
+        Meta.utf8Start(b)
+        return Meta.Utf8, Meta.utf8End(b)
+    elseif t isa BinaryType
+        if t.large
+            Meta.largeBinaryStart(b)
+            return Meta.LargeBinary, Meta.largeBinaryEnd(b)
+        end
+        Meta.binaryStart(b)
+        return Meta.Binary, Meta.binaryEnd(b)
+    elseif t isa FixedSizeBinaryType
+        Meta.fixedSizeBinaryStart(b)
+        Meta.fixedSizeBinaryAddByteWidth(b, Int32(t.nbytes))
+        return Meta.FixedSizeBinary, Meta.fixedSizeBinaryEnd(b)
+    elseif t isa ListType
+        if t.large
+            Meta.largeListStart(b)
+            return Meta.LargeList, Meta.largeListEnd(b)
+        end
+        Meta.listStart(b)
+        return Meta.List, Meta.listEnd(b)
+    elseif t isa FixedSizeListType
+        Meta.fixedSizeListStart(b)
+        Meta.fixedSizeListAddListSize(b, Int32(t.listsize))
+        return Meta.FixedSizeList, Meta.fixedSizeListEnd(b)
+    elseif t isa StructType
+        Meta.structStart(b)
+        return Meta.Struct, Meta.structEnd(b)
+    elseif t isa MapType
+        Meta.mapStart(b)
+        t.keyssorted && Meta.mapAddKeysSorted(b, true)
+        return Meta.Map, Meta.mapEnd(b)
+    elseif t isa DateType
+        Meta.dateStart(b)
+        Meta.dateAddUnit(
+            b,
+            t.unit == AC.DAY ? Meta.DateUnit.DAY : Meta.DateUnit.MILLISECOND,
+        )
+        return Meta.Date, Meta.dateEnd(b)
+    elseif t isa TimeType
+        Meta.timeStart(b)
+        Meta.timeAddUnit(b, _metatimeunit(t.unit))
+        Meta.timeAddBitWidth(b, Int32(t.bits))
+        return Meta.Time, Meta.timeEnd(b)
+    elseif t isa TimestampType
+        tz = t.timezone === nothing ? FB.UOffsetT(0) : FB.createstring!(b, t.timezone)
+        Meta.timestampStart(b)
+        Meta.timestampAddUnit(b, _metatimeunit(t.unit))
+        tz == 0 || Meta.timestampAddTimezone(b, tz)
+        return Meta.Timestamp, Meta.timestampEnd(b)
+    elseif t isa DurationType
+        Meta.durationStart(b)
+        Meta.durationAddUnit(b, _metatimeunit(t.unit))
+        return Meta.Duration, Meta.durationEnd(b)
+    elseif t isa DecimalType
+        Meta.decimalStart(b)
+        Meta.decimalAddPrecision(b, Int32(t.precision))
+        Meta.decimalAddScale(b, Int32(t.scale))
+        Meta.decimalAddBitWidth(b, Int32(t.bits))
+        return Meta.Decimal, Meta.decimalEnd(b)
+    elseif t isa IntervalType
+        Meta.intervalStart(b)
+        Meta.intervalAddUnit(
+            b,
+            t.unit == AC.YEAR_MONTH ? Meta.IntervalUnit.YEAR_MONTH :
+            t.unit == AC.DAY_TIME ? Meta.IntervalUnit.DAY_TIME :
+            Meta.IntervalUnit.MONTH_DAY_NANO,
+        )
+        return Meta.Interval, Meta.intervalEnd(b)
+    elseif t isa UnionType
+        # The builder writes last-first, so every vector is prepended in
+        # reverse. A zero UOffsetT means "absent": the slot is left out and
+        # the getter returns the schema default.
+        Meta.unionStartTypeIdsVector(b, length(t.typeids))
+        foreach(x -> FB.prepend!(b, Int32(x)), Iterators.reverse(t.typeids))
+        idvec = FB.endvector!(b, length(t.typeids))
+        Meta.unionStart(b)
+        Meta.unionAddMode(
+            b,
+            t.mode == AC.DenseMode ? Meta.UnionMode.Dense : Meta.UnionMode.Sparse,
+        )
+        Meta.unionAddTypeIds(b, idvec)
+        return Meta.Union, Meta.unionEnd(b)
+    elseif t isa ViewType
+        if t.utf8
+            Meta.utf8ViewStart(b)
+            return Meta.Utf8View, Meta.utf8ViewEnd(b)
+        end
+        Meta.binaryViewStart(b)
+        return Meta.BinaryView, Meta.binaryViewEnd(b)
+    elseif t isa ListViewType
+        if t.large
+            Meta.largeListViewStart(b)
+            return Meta.LargeListView, Meta.largeListViewEnd(b)
+        end
+        Meta.listViewStart(b)
+        return Meta.ListView, Meta.listViewEnd(b)
+    elseif t isa RunEndEncodedType
+        Meta.runEndEncodedStart(b)
+        return Meta.RunEndEncoded, Meta.runEndEncodedEnd(b)
+    elseif t isa NullType
+        Meta.nullStart(b)
+        return Meta.Null, Meta.nullEnd(b)
+    else
+        throw(
+            ValidationError(
+                "IPC writer does not map descriptor " * "$(AC.descriptorname(t))",
+            ),
+        )
+    end
+end
+
+function _metakeyvalues!(b::FB.Builder, metadata)
+    metadata === nothing && return FB.UOffsetT(0)
+    # Core metadata is an ordered Pair sequence. Preserve both that order and
+    # duplicate keys; callers that want canonical ordering can supply it.
+    pairs = collect(metadata)
+    kvs = FB.UOffsetT[]
+    for (k, v) in pairs
+        key = FB.createstring!(b, k)
+        val = FB.createstring!(b, v)
+        Meta.keyValueStart(b)
+        Meta.keyValueAddKey(b, key)
+        Meta.keyValueAddValue(b, val)
+        push!(kvs, Meta.keyValueEnd(b))
+    end
+    FB.startvector!(b, 4, length(kvs), 4)
+    foreach(x -> FB.prependoffset!(b, x), Iterators.reverse(kvs))
+    return FB.endvector!(b, length(kvs))
+end
+
+"""
+Build the flatbuffer Field table for one Core Field (inverse of `corefield`).
+A `DictionaryType` field writes its VALUE type into the type slots and its
+index/id/ordering into a DictionaryEncoding table; the id comes from the
+writer's side table — Core fields still never carry one.
+"""
+function metafield!(b::FB.Builder, f::Field, fielddictids::IdDict{Field,Int64})
+    t = f.type
+    valuetype = t
+    dictoff = FB.UOffsetT(0)
+    if t isa DictionaryType
+        valuetype = t.valuetype
+        idxtag, idxoff = metatype!(b, t.indextype)
+        idxtag === Meta.Int ||
+            throw(ValidationError("dictionary index type must be an integer"))
+        Meta.dictionaryEncodingStart(b)
+        Meta.dictionaryEncodingAddId(b, fielddictids[f])
+        Meta.dictionaryEncodingAddIndexType(b, idxoff)
+        t.ordered && Meta.dictionaryEncodingAddIsOrdered(b, true)
+        dictoff = Meta.dictionaryEncodingEnd(b)
+    end
+    children = FB.UOffsetT[metafield!(b, c, fielddictids) for c in f.children]
+    Meta.fieldStartChildrenVector(b, length(children))
+    foreach(x -> FB.prependoffset!(b, x), Iterators.reverse(children))
+    childvec = FB.endvector!(b, length(children))
+    kvvec = _metakeyvalues!(b, f.metadata)
+    name = FB.createstring!(b, f.name)
+    tag, typeoff = metatype!(b, valuetype)
+    Meta.fieldStart(b)
+    Meta.fieldAddName(b, name)
+    Meta.fieldAddNullable(b, f.nullable)
+    Meta.fieldAddTypeType(b, tag)
+    Meta.fieldAddType(b, typeoff)
+    dictoff == 0 || Meta.fieldAddDictionary(b, dictoff)
+    Meta.fieldAddChildren(b, childvec)
+    kvvec == 0 || Meta.fieldAddCustomMetadata(b, kvvec)
+    return Meta.fieldEnd(b)
+end
+
+_pad8!(bytes::Vector{UInt8}) = append!(bytes, zeros(UInt8, mod(-length(bytes), 8)))
+
+"""
+The framing prefix of a message: continuation marker, padded metadata length,
+then the padded metadata. Its body (`bodylen` bytes, already padded) follows.
+"""
+function _messageheader(b::FB.Builder, msg, bodylen::Int64)
+    FB.finish!(b, msg)
+    meta = collect(FB.finishedbytes(b))
+    _pad8!(meta)
+    bodylen % 8 == 0 || throw(ArgumentError("message body must be padded"))
+    header = UInt8[]
+    sizehint!(header, 8 + length(meta))
+    append!(header, reinterpret(UInt8, UInt32[CONTINUATION, UInt32(length(meta))]))
+    append!(header, meta)
+    return header
+end
+
+function _metaschema!(
+    b::FB.Builder,
+    sch::Schema,
+    fielddictids::IdDict{Field,Int64},
+    features::Vector{Int64},
+)
+    fields = FB.UOffsetT[metafield!(b, f, fielddictids) for f in sch.fields]
+    Meta.schemaStartFieldsVector(b, length(fields))
+    foreach(x -> FB.prependoffset!(b, x), Iterators.reverse(fields))
+    fieldvec = FB.endvector!(b, length(fields))
+    kvvec = _metakeyvalues!(b, sch.metadata)
+    featurevec = FB.UOffsetT(0)
+    if !isempty(features)
+        FB.startvector!(b, 8, length(features), 8)
+        foreach(x -> FB.prepend!(b, x), Iterators.reverse(features))
+        featurevec = FB.endvector!(b, length(features))
+    end
+    Meta.schemaStart(b)
+    Meta.schemaAddEndianness(b, Meta.Endianness.Little)
+    Meta.schemaAddFields(b, fieldvec)
+    kvvec == 0 || Meta.schemaAddCustomMetadata(b, kvvec)
+    featurevec == 0 || Meta.schemaAddFeatures(b, featurevec)
+    return Meta.schemaEnd(b)
+end
+
+function _schemamessage!(
+    out::Vector{UInt8},
+    sch::Schema,
+    fielddictids::IdDict{Field,Int64},
+    features::Vector{Int64},
+)
+    b = FB.Builder(1024)
+    schoff = _metaschema!(b, sch, fielddictids, features)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(b, Meta.Schema)
+    Meta.messageAddHeader(b, schoff)
+    return append!(out, _messageheader(b, Meta.messageEnd(b), Int64(0)))
+end
+
+# ---------------------------------------------------------------------------
+# THE generic encoder: registry-driven node/buffer emission
+# ---------------------------------------------------------------------------
+
+# A message body is the list of its pieces, each followed by zero padding to
+# a multiple of 8 bytes. Uncompressed pieces are the column buffers
+# themselves, so `_writebody` streams them to the sink without a body copy.
+mutable struct EncodeCursor
+    nodes::Vector{NTuple{2,Int64}}       # (length, null_count), forward order
+    buffers::Vector{NTuple{2,Int64}}     # (offset, length), forward order
+    body::Vector{AC.BufferSlice}         # body pieces, in order
+    bodylen::Int64                       # padded body length
+    codec::Int8
+    # A compressed body's buffers in order, compressed together by
+    # `_compressbody!` once the walk is done.
+    raw::Vector{AC.BufferSlice}
+    variadics::Vector{Int64}             # per view field, depth-first order
+end
+EncodeCursor(codec::Int8) = EncodeCursor(
+    NTuple{2,Int64}[],
+    NTuple{2,Int64}[],
+    AC.BufferSlice[],
+    Int64(0),
+    codec,
+    AC.BufferSlice[],
+    Int64[],
+)
+
+# One frame of the `len` bytes at `ptr`: LZ4 from a fresh context
+# (`_lz4frame`), Zstandard with `state`'s (`_zstdframe`).
+function _compressbytes(state::EncodeState, codec::Int8, ptr::Ptr{UInt8}, len::Int)
+    out = isempty(state.free) ? UInt8[] : pop!(state.free)
+    # Room for the codec's worst case (LZ4 and Zstandard frames stay under
+    # this), so a reused vector is never too small for one compression call.
+    need = len + (len >> 7) + 1024
+    length(out) < need && resize!(out, need)
+    frame =
+        codec == CODEC_LZ4_FRAME ?
+        _lz4frame(state, TS.Buffer(unsafe_wrap(Array, ptr, len)), out) :
+        _zstdframe(state, ptr, len, out)
+    push!(state.inuse, frame)
+    return frame
+end
+
+function _addpiece!(c::EncodeCursor, b::AC.BufferSlice)
+    push!(c.body, b)
+    c.bodylen = AC.checked_add(c.bodylen, (b.len + 7) & ~Int64(7))
+    return nothing
+end
+
+"""
+Append one buffer to the message body: raw bytes for uncompressed batches;
+for compressed batches, the spec's Int64 uncompressed-length prefix plus the
+frame, falling back to `-1` + raw whenever compression does not shrink the
+payload (see `_compressbody!`). Zero-length buffers write no body bytes in
+either mode. The recorded Buffer length is the wire length; 8-byte alignment
+padding sits between buffers and belongs to neither.
+"""
+encodebuffer!(c::EncodeCursor, bytes::Vector{UInt8}) =
+    encodebuffer!(c, AC.BufferSlice(AC.heapregion(bytes), 0, length(bytes)))
+
+function encodebuffer!(c::EncodeCursor, b::AC.BufferSlice)
+    b.len == 0 || b.region !== nothing || throw(ArgumentError("empty buffer has no data"))
+    c.codec == CODEC_NONE || (push!(c.raw, b); return nothing)
+    offset = c.bodylen
+    push!(c.buffers, (offset, Int64(b.len)))
+    b.len == 0 || _addpiece!(c, b)
+    return nothing
+end
+
+# Bodies under this many raw bytes compress on one task.
+const _PARALLEL_BODY_BYTES = 1 << 20
+
+"""
+Compress a compressed message's buffers (`c.raw`), on up to `ntasks` tasks
+with one codec context each, and lay out the body in buffer order. Each
+buffer is its own frame, so the bytes do not depend on the task count.
+"""
+function _compressbody!(c::EncodeCursor, states::Vector{EncodeState}, ntasks::Int)
+    c.codec == CODEC_NONE && return nothing
+    raw = c.raw
+    total = sum(b -> Int64(b.len), raw; init=Int64(0))
+    k = total < _PARALLEL_BODY_BYTES ? 1 : ntasks
+    # Largest buffers first, so the last task to finish has a small one.
+    order = k == 1 ? (1:length(raw)) : sortperm(raw; by=b -> b.len, rev=true)
+    done = _tasksmap(length(raw), k) do i, w
+        b = raw[order[i]]
+        b.len == 0 && return nothing
+        frame = GC.@preserve b _compressbytes(
+            states[w],
+            c.codec,
+            AC.sliceptr(b),
+            Int(b.len),
+        )
+        return length(frame) < b.len ? frame : nothing
+    end
+    frames = Vector{Union{Nothing,Vector{UInt8}}}(undef, length(raw))
+    for (i, j) in enumerate(order)
+        frames[j] = done[i]
+    end
+    for (j, b) in enumerate(raw)
+        offset = c.bodylen
+        if b.len == 0
+            push!(c.buffers, (offset, Int64(0)))
+            continue
+        end
+        frame = frames[j]
+        prefix = Int64[frame === nothing ? -1 : b.len]
+        payload =
+            frame === nothing ? b : AC.BufferSlice(AC.heapregion(frame), 0, length(frame))
+        _addpiece!(c, AC.BufferSlice(AC.heapregion(prefix), 0, 8))
+        _addpiece!(c, payload)
+        push!(c.buffers, (offset, Int64(8 + payload.len)))
+    end
+    empty!(raw)
+    return nothing
+end
+
+"""
+`f(j, w)` for `j` in `1:n` on up to `ntasks` tasks (`_foreach`), results in
+index order; `w` numbers the task, for per-task state. A failure rethrows the
+lowest failing index's error, so it does not depend on scheduling.
+"""
+function _tasksmap(f::F, n::Int, ntasks::Int) where {F}
+    results = Vector{Any}(undef, n)
+    _foreach(n, ntasks) do j, w
+        results[j] = f(j, w)
+        return nothing
+    end
+    return results
+end
+
+const _PADDING = ntuple(k -> zeros(UInt8, k), 7)
+
+"Write a message body: each piece, then its zero padding to 8 bytes."
+function _writebody(io::IO, c::EncodeCursor)
+    for b in c.body
+        # An uncopied array over the piece; preserving the piece keeps its
+        # owner alive across the write.
+        GC.@preserve b Base.write(io, unsafe_wrap(Array, AC.sliceptr(b), Int(b.len)))
+        pad = Int((-b.len) & 7)
+        pad > 0 && Base.write(io, _PADDING[pad])
+    end
+    return nothing
+end
+
+"Encode view entries and the union of their referenced byte ranges."
+function _encodeviewbuffers!(c::EncodeCursor, d::ArrayData)
+    # In-memory views may borrow a whole parser input or a larger column.
+    # IPC must not persist those unrelated bytes, null entries, or padding.
+    views = AC.rolebuffer(d, AC.VIEWS)
+    inputvalidity = AC.validitybuffer(d)
+    entries = zeros(UInt8, AC.checked_mul(d.len, Int64(16)))
+    payloads = reinterpret(UInt128, entries)
+    words = reinterpret(Int32, entries)
+    validity = AC.nullcount(d) == 0 ? UInt8[] : zeros(UInt8, cld(d.len, 8))
+    # Prove that valid long entries cover a prefix of every source buffer.
+    # Such columns need neither row sorting nor per-entry data copies.
+    coverage = zeros(Int64, length(d.buffers) - 2)
+    compact = true
+    for i = 1:(d.len)
+        (AC.isempty_buffer(inputvalidity) || AC.getbit(inputvalidity, i - 1)) || continue
+        isempty(validity) || (validity[(i - 1) ÷ 8 + 1] |= UInt8(1) << ((i - 1) % 8))
+        base = 16 * (i - 1)
+        payload = AC.loadat(views, UInt128, base)
+        len = reinterpret(Int32, payload % UInt32)
+        # The writer requires little-endian storage. Mask inline padding;
+        # long entries keep their source coordinates until remapped below.
+        payloads[i] =
+            len <= AC.VIEW_INLINE_MAX ? payload & (typemax(UInt128) >> (8 * (12 - len))) :
+            payload
+        if compact && len > AC.VIEW_INLINE_MAX
+            bufidx, off = words[4 * i - 1], words[4 * i]
+            extent = coverage[bufidx + 1]
+            if off > extent
+                compact = false
+            else
+                coverage[bufidx + 1] = max(extent, Int64(off) + len)
+            end
+        end
+    end
+    if compact && all(>(0), coverage)
+        encodebuffer!(c, validity)
+        encodebuffer!(c, entries)
+        push!(c.variadics, Int64(length(coverage)))
+        for (i, extent) in enumerate(coverage)
+            # Only the proven prefix is copied; trailing bytes are unused.
+            encodebuffer!(c, AC.subslice(d.buffers[i + 2], 0, extent))
+        end
+        return nothing
+    end
+    refs = Int64[i for i = 1:(d.len) if words[4 * i - 3] > AC.VIEW_INLINE_MAX]
+    # Sort by source position so duplicate and overlapping views share the
+    # same output bytes. Already ordered producer columns need no sort.
+    sourcepos(i) = (words[4 * i - 1], words[4 * i])
+    issorted(refs; by=sourcepos) || sort!(refs; by=sourcepos)
+    buffers = Vector{UInt8}[]
+    firstref = 1
+    while firstref <= length(refs)
+        bufidx = words[4 * refs[firstref] - 1]
+        lastref = firstref
+        extent = Int64(0)
+        nbytes = Int64(0)
+        while lastref <= length(refs) && words[4 * refs[lastref] - 1] == bufidx
+            row = refs[lastref]
+            off, len = words[4 * row], words[4 * row - 3]
+            stop = Int64(off) + len
+            nbytes += max(0, stop - max(Int64(off), extent))
+            extent = max(extent, stop)
+            lastref += 1
+        end
+        # One compact buffer per referenced source buffer keeps rewritten
+        # offsets <= their original Int32 offsets, including large buffers.
+        packed = Vector{UInt8}(undef, nbytes)
+        source = AC._viewdatabuffer(d, bufidx)
+        outputidx = Int32(length(buffers))
+        pos = Int64(0)
+        extent = Int64(0)
+        GC.@preserve source packed begin
+            for j = firstref:(lastref - 1)
+                row = refs[j]
+                off, len = words[4 * row], words[4 * row - 3]
+                words[4 * row - 1] = outputidx
+                words[4 * row] = Int32(pos - max(0, extent - off))
+                stop = Int64(off) + len
+                start = max(Int64(off), extent)
+                count = max(0, stop - start)
+                if count > 0
+                    unsafe_copyto!(
+                        pointer(packed, pos + 1),
+                        AC.sliceptr(source) + start,
+                        count,
+                    )
+                    pos += count
+                end
+                extent = max(extent, stop)
+            end
+        end
+        push!(buffers, packed)
+        firstref = lastref
+    end
+    encodebuffer!(c, validity)
+    encodebuffer!(c, entries)
+    push!(c.variadics, Int64(length(buffers)))
+    for bytes in buffers
+        encodebuffer!(c, bytes)
+    end
+    return nothing
+end
+
+"""
+    encodefield!(cursor, f, d)
+
+The write half of the registry walk — the exact mirror of `decodefield`:
+one node, then the layout's buffers in registry order, then children in
+declared order. Dictionary-encoded fields emit their INDEX buffers here;
+their pool travels in a dictionary batch. View layouts compact referenced
+content at this persistence boundary; other layouts emit their `ArrayData`
+slices verbatim, apart from the empty terminal offset below.
+"""
+function encodefield!(c::EncodeCursor, f::Field, d::ArrayData)
+    t = f.type
+    AC.typeequal(t, d.type) ||
+        throw(ValidationError("column data type does not match its schema field"))
+    d.offset == 0 || throw(
+        ValidationError(
+            "IPC encode of sliced (nonzero-offset) arrays is not supported; materialize first",
+        ),
+    )
+    push!(c.nodes, (d.len, AC.nullcount(d)))
+    spec = layoutspec(t)
+    if spec.variadic
+        length(d.buffers) >= length(spec.buffers) ||
+            throw(ValidationError("column buffer count does not match its layout"))
+    else
+        length(d.buffers) == length(spec.buffers) ||
+            throw(ValidationError("column buffer count does not match its layout"))
+    end
+    if t isa AC.ViewType
+        _encodeviewbuffers!(c, d)
+        return nothing
+    end
+    for (role, b) in zip(spec.buffers, d.buffers)
+        if role == AC.OFFSETS && d.len == 0 && b.len == 0
+            # Core canonicalizes an empty offset array without allocating its
+            # otherwise-unused physical buffer. IPC still requires the one
+            # terminal zero offset (length + 1 entries).
+            encodebuffer!(c, zeros(UInt8, spec.offsetwidth))
+        else
+            encodebuffer!(c, b)
+        end
+    end
+    if spec.variadic
+        # View layouts append their variadic data buffers after the fixed
+        # validity/views pair; the count travels in the header's
+        # variadicBufferCounts vector, depth-first (format 1.4).
+        push!(c.variadics, Int64(length(d.buffers) - length(spec.buffers)))
+        for b in Iterators.drop(d.buffers, length(spec.buffers))
+            encodebuffer!(c, b)
+        end
+    end
+    t isa DictionaryType && return nothing
+    nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+    length(d.children) == nchildren ||
+        throw(ValidationError("column child count does not match its schema field"))
+    if t isa UnionType && t.mode == AC.SparseMode
+        all(child -> child.len == d.len, d.children) ||
+            throw(ValidationError("IPC sparse-union children must equal the union length"))
+    end
+    for i = 1:nchildren
+        encodefield!(c, f.children[i], d.children[i])
+    end
+    return nothing
+end
+
+function _batchheader!(b::FB.Builder, c::EncodeCursor, nrows::Int64)
+    Meta.recordBatchStartNodesVector(b, length(c.nodes))
+    for (len, nulls) in Iterators.reverse(c.nodes)
+        Meta.createFieldNode(b, len, nulls)
+    end
+    nodes = FB.endvector!(b, length(c.nodes))
+    Meta.recordBatchStartBuffersVector(b, length(c.buffers))
+    for (off, len) in Iterators.reverse(c.buffers)
+        Meta.createBuffer(b, off, len)
+    end
+    buffers = FB.endvector!(b, length(c.buffers))
+    compression = FB.UOffsetT(0)
+    if c.codec != CODEC_NONE
+        Meta.bodyCompressionStart(b)
+        Meta.bodyCompressionAddCodec(
+            b,
+            c.codec == CODEC_LZ4_FRAME ? Meta.CompressionType.LZ4_FRAME :
+            Meta.CompressionType.ZSTD,
+        )
+        compression = Meta.bodyCompressionEnd(b)
+    end
+    varvec = FB.UOffsetT(0)
+    if !isempty(c.variadics)
+        Meta.recordBatchStartVariadicBufferCountsVector(b, length(c.variadics))
+        foreach(x -> FB.prepend!(b, x), Iterators.reverse(c.variadics))
+        varvec = FB.endvector!(b, length(c.variadics))
+    end
+    Meta.recordBatchStart(b)
+    Meta.recordBatchAddLength(b, nrows)
+    Meta.recordBatchAddNodes(b, nodes)
+    Meta.recordBatchAddBuffers(b, buffers)
+    compression == 0 || Meta.recordBatchAddCompression(b, compression)
+    varvec == 0 || Meta.recordBatchAddVariadicBufferCounts(b, varvec)
+    return Meta.recordBatchEnd(b)
+end
+
+# Padded byte size of a column's buffers, children included and dictionary
+# pools excluded (they travel in their own messages): the uncompressed body
+# size.
+function _bodybytes(d::ArrayData)
+    n = Int64(0)
+    for b in d.buffers
+        n = AC.checked_add(n, (Int64(b.len) + 7) & ~Int64(7))
+    end
+    for child in d.children
+        n = AC.checked_add(n, _bodybytes(child))
+    end
+    return n
+end
+
+# Capacity for an eager writer's output: the uncompressed record bodies plus
+# slack for metadata and dictionaries, so the staging buffer rarely regrows.
+function _outputhint(batches, codec::Int8)
+    codec == CODEC_NONE || return 0
+    n = Int64(4096)
+    for batch in batches
+        n = AC.checked_add(n, sum(_bodybytes, batch.columns; init=Int64(1024)))
+    end
+    return Int(n)
+end
+
+"A record batch message as its header and its body's `EncodeCursor`."
+function _recordmessage(
+    batch::AC.RecordBatch,
+    fields,
+    codec::Int8,
+    states::Vector{EncodeState},
+    ntasks::Int=1,
+)
+    c = EncodeCursor(codec)
+    for (f, col) in zip(fields, batch.columns)
+        encodefield!(c, f, col)
+    end
+    _compressbody!(c, states, ntasks)
+    b = FB.Builder(1024)
+    rb = _batchheader!(b, c, batch.nrows)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(b, Meta.RecordBatch)
+    Meta.messageAddHeader(b, rb)
+    Meta.messageAddBodyLength(b, c.bodylen)
+    return _messageheader(b, Meta.messageEnd(b), c.bodylen), c
+end
+
+"A dictionary batch message as its header and its body's `EncodeCursor`."
+function _dictionarymessage(
+    id::Int64,
+    vf::Field,
+    pool::ArrayData,
+    codec::Int8,
+    states::Vector{EncodeState},
+    ntasks::Int=1;
+    isdelta::Bool=false,
+)
+    c = EncodeCursor(codec)
+    encodefield!(c, vf, pool)
+    _compressbody!(c, states, ntasks)
+    b = FB.Builder(1024)
+    rb = _batchheader!(b, c, pool.len)
+    Meta.dictionaryBatchStart(b)
+    Meta.dictionaryBatchAddId(b, id)
+    Meta.dictionaryBatchAddData(b, rb)
+    isdelta && Meta.dictionaryBatchAddIsDelta(b, true)
+    dictbatch = Meta.dictionaryBatchEnd(b)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(b, Meta.DictionaryBatch)
+    Meta.messageAddHeader(b, dictbatch)
+    Meta.messageAddBodyLength(b, c.bodylen)
+    return _messageheader(b, Meta.messageEnd(b), c.bodylen), c
+end
+
+# ---------------------------------------------------------------------------
+# Stream writer driver
+# ---------------------------------------------------------------------------
+
+const CODEC_NAMES =
+    Dict{Symbol,Int8}(:none => CODEC_NONE, :lz4 => CODEC_LZ4_FRAME, :zstd => CODEC_ZSTD)
+
+function _requirelittleendian(host_endian_bom::UInt32=Base.ENDIAN_BOM)
+    host_endian_bom == UInt32(0x04030201) ||
+        throw(ValidationError("the IPC writer requires a little-endian host"))
+    return nothing
+end
+
+"""
+Assign one IPC dictionary id per dictionary-typed field, depth-first over the
+schema — the writer-side half of the adapter id table (ids are adapter
+bookkeeping; Core fields never carry them).
+"""
+function assigndictids(fields, given::IdDict{Field,Int64}=IdDict{Field,Int64}())
+    # `given` lets a caller preserve ids from a source (a reader's table): two
+    # fields sharing one id then share one dictionary batch, exactly as the
+    # source did (the arrow-testing 4.0.0-shareddict integration case). Fresh
+    # ids fill the lowest unoccupied values so they never collide with given
+    # ones — including given ids at the top of the signed-long domain, where
+    # `max + 1` would wrap.
+    ids = IdDict{Field,Int64}(given)
+    seen = IdDict{Field,Nothing}()
+    used = Set{Int64}(values(ids))
+    next = Ref(Int64(0))
+    function freshid()
+        while next[] in used
+            next[] < typemax(Int64) ||
+                throw(ValidationError("IPC dictionary id space is exhausted"))
+            next[] += 1
+        end
+        push!(used, next[])
+        return next[]
+    end
+    function walk(f::Field)
+        haskey(seen, f) && throw(
+            ValidationError(
+                "IPC writer schema reuses one Field object in multiple positions",
+            ),
+        )
+        seen[f] = nothing
+        if f.type isa DictionaryType && !haskey(ids, f)
+            ids[f] = freshid()
+        end
+        foreach(walk, f.children)
+    end
+    foreach(walk, fields)
+    return ids
+end
+
+"""
+Collect `(field, pool)` pairs for every dictionary-typed field in one batch,
+paired with the schema walk (nested dictionaries included).
+"""
+function dictionarypools(fields, cols)
+    pairs = Tuple{Field,ArrayData}[]
+    function walk(f::Field, d::ArrayData)
+        if f.type isa DictionaryType
+            d.dictionary === nothing &&
+                throw(ValidationError("dictionary column carries no pool"))
+            # Post-order: pools nested INSIDE this pool's values are collected
+            # (and therefore emitted) before it — the dependency order the
+            # IPC spec requires for nested dictionary encoding.
+            walk(AC.dictvaluefield(f, f.type), d.dictionary)
+            push!(pairs, (f, d.dictionary))
+            return
+        end
+        for (cf, cd) in zip(f.children, d.children)
+            walk(cf, cd)
+        end
+    end
+    for (f, d) in zip(fields, cols)
+        walk(f, d)
+    end
+    return pairs
+end
+
+function _checkbatches(sch::Schema, batches)
+    for batch in batches
+        length(batch.columns) == length(sch.fields) ||
+            throw(ValidationError("batch column count does not match the schema"))
+        for (f, bf) in zip(sch.fields, batch.schema.fields)
+            AC.typeequal(f.type, bf.type) && f.name == bf.name ||
+                throw(ValidationError("batch schema does not match the stream schema"))
+        end
+    end
+    return nothing
+end
+
+function _validatewriterschema(sch::Schema)
+    AC._validate_schema(sch)
+    function walk(f::Field)
+        isvalid(f.name) || throw(ValidationError("field name is not valid UTF-8"))
+        foreach(walk, f.children)
+        return nothing
+    end
+    foreach(walk, sch.fields)
+    foreach(validateschemafield, sch.fields)
+    return nothing
+end
+
+function _validatewriterbatch!(
+    validated::AC._ValidatedDictionaries,
+    sch::Schema,
+    batch::AC.RecordBatch,
+    ids::IdDict{Field,Int64},
+)
+    empty!(validated)
+    # A shared immutable pool must satisfy every value-field contract
+    # through which the schema refers to it. Identity caching is safe only
+    # after those field-specific checks have run.
+    current = Dict{Int64,ArrayData}()
+    for (f, pool) in dictionarypools(sch.fields, batch.columns)
+        # One id names ONE pool within a record batch: every dictionary
+        # message precedes the record message on the wire, so an
+        # intra-batch pool change is not temporal replacement — it would
+        # silently retarget the earlier field to the later pool.
+        id = ids[f]
+        haskey(current, id) &&
+            current[id] !== pool &&
+            throw(
+                ValidationError(
+                    "dictionary id $id carries two different pools in one record batch",
+                ),
+            )
+        current[id] = pool
+        validate_semantic(AC.dictvaluefield(f, f.type::DictionaryType), pool)
+        validated[pool] = nothing
+    end
+    for (f, col) in zip(sch.fields, batch.columns)
+        AC._validate_semantic(f, col, validated)
+    end
+    return nothing
+end
+
+function _validatewriterbatches(sch::Schema, batches, ids::IdDict{Field,Int64})
+    validated = AC._ValidatedDictionaries()
+    for batch in batches
+        _validatewriterbatch!(validated, sch, batch, ids)
+    end
+    return nothing
+end
+
+const FEATURE_DICTIONARY_REPLACEMENT = Int64(1)
+const FEATURE_COMPRESSED_BODY = Int64(2)
+
+"""
+Which features must the schema declare for these batches? Replacement is
+detected by pool-identity change per id across the batch sequence
+(replacement-on-change); compression declares COMPRESSED_BODY.
+"""
+function _streamfeatures(
+    sch::Schema,
+    batches,
+    ids::IdDict{Field,Int64},
+    codec::Int8,
+    deltas=nothing,
+)
+    features = Int64[]
+    current = Dict{Int64,ArrayData}()
+    replacement = false
+    for (k, batch) in enumerate(batches)
+        for (f, pool) in dictionarypools(sch.fields, batch.columns)
+            id = ids[f]
+            old = get(current, id, nothing)
+            old === pool ||
+                old === nothing ||
+                (deltas !== nothing && haskey(deltas[k], id)) ||
+                (replacement = true)
+            current[id] = pool
+        end
+    end
+    replacement && push!(features, FEATURE_DICTIONARY_REPLACEMENT)
+    isempty(batches) || codec == CODEC_NONE || push!(features, FEATURE_COMPRESSED_BODY)
+    return features
+end
+
+# ---------------------------------------------------------------------------
+# Incremental writer core: begin/writebatch/finish over one IO
+# ---------------------------------------------------------------------------
+
+"""
+One in-progress IPC output. `beginwrite!` emits the schema message (and the
+file-format preamble), `writebatch!` validates and publishes one record batch
+(with any dictionary messages it needs), and `finishwrite!` emits the
+end-of-stream marker (and the file-format Footer). A batch's messages are
+encoded before any of them is published, so a validation or encoding failure
+publishes nothing; each message is then written as its header followed by its
+body, uncompressed buffers straight from the columns. The SINK gains bytes
+batch by batch, and an abandoned state leaves a torn stream or an unfooted
+file.
+
+The eager `writestream`/`writefile` drive this same state over an in-memory
+sink, validating every batch up front (`validate=false` per batch) and
+declaring only the features their whole batch sequence uses.
+"""
+mutable struct IPCWriteState
+    const io::IO
+    const file::Bool
+    const schema::Schema
+    const fielddictids::IdDict{Field,Int64}
+    const ids::IdDict{Field,Int64}
+    const features::Vector{Int64}
+    const codec::Int8
+    # One codec context per compression task (none when uncompressed).
+    const states::Vector{EncodeState}
+    const ntasks::Int
+    # How a pool that extends the one written before is written: `:delta`
+    # (a delta dictionary batch), `:replace` (stream: the whole pool again),
+    # or `:defer` (file: each id's final pool, once, by `finishwrite!`).
+    const growth::Symbol
+    # `:defer`: the dictionary fields to write at the end, in the order
+    # nested pools need (inner before outer), each id once.
+    const deferred::Vector{Tuple{Field,Int64}}
+    const validated::AC._ValidatedDictionaries
+    const current::Dict{Int64,ArrayData}  # last pool per id, for replacement
+    const dictblocks::Vector{NTuple{3,Int64}}    # file format Footer Blocks
+    const recordblocks::Vector{NTuple{3,Int64}}
+    written::Int64                       # bytes published to `io`
+    finished::Bool
+    failed::Bool   # a batch failed to encode and later ones were discarded
+    # A compressed batch encodes on its own task while the next one builds;
+    # batches publish in order. Each pending entry is the encoding task and
+    # the codec states it uses; `statesets` holds idle sets for reuse.
+    const pending::Vector{Tuple{Task,Vector{EncodeState},Any}}
+    const statesets::Vector{Vector{EncodeState}}
+end
+
+# Compressed batches encoding at once: two keep the tasks busy while one
+# batch waits for its largest buffer, and two sets of frames are reused.
+const _INFLIGHT = 2
+
+function _checkgrowth(growth::Symbol, file::Bool)
+    growth in (:delta, :replace, :defer) ||
+        throw(ArgumentError("dictionary growth must be :delta, :replace, or :defer"))
+    growth === (file ? :replace : :defer) && throw(
+        ArgumentError(
+            "dictionary growth :$growth needs the " *
+            (file ? "stream" : "file") *
+            " format",
+        ),
+    )
+    return growth
+end
+
+# Batch sequences are unknown up front. A declared feature is a demand on
+# readers (nanoarrow refuses any stream declaring one it does not support),
+# so nothing is declared speculatively: pool replacement needs the caller's
+# explicit opt-in, and a codec declares compressed bodies because every
+# batch this state writes will use it.
+function _incrementalfeatures(
+    ids::IdDict{Field,Int64},
+    codec::Int8,
+    file::Bool,
+    dictreplacement::Bool,
+)
+    features = Int64[]
+    dictreplacement &&
+        !file &&
+        !isempty(ids) &&
+        push!(features, FEATURE_DICTIONARY_REPLACEMENT)
+    codec == CODEC_NONE || push!(features, FEATURE_COMPRESSED_BODY)
+    return features
+end
+
+# Codec contexts are created on first use, so unused ones cost nothing.
+_encodestates(codec::Int8, level, ntasks::Integer) =
+    codec == CODEC_NONE ? EncodeState[] : EncodeState[EncodeState(level) for _ = 1:ntasks]
+
+function _publish!(st::IPCWriteState, out::Vector{UInt8})
+    Base.write(st.io, out)
+    st.written += length(out)
+    return nothing
+end
+
+function beginwrite!(
+    io::IO,
+    sch::Schema;
+    file::Bool,
+    compress::Symbol=:none,
+    dictids::IdDict{Field,Int64}=IdDict{Field,Int64}(),
+    features::Union{Nothing,Vector{Int64}}=nothing,
+    dictreplacement::Bool=false,
+    compresslevel::Union{Nothing,Integer}=nothing,
+    ntasks::Integer=1,
+    growth::Symbol=:delta,
+)
+    _requirelittleendian()
+    haskey(CODEC_NAMES, compress) ||
+        throw(ArgumentError("compress must be :none, :lz4, or :zstd"))
+    codec = CODEC_NAMES[compress]
+    _checkgrowth(growth, file)
+    _validatewriterschema(sch)
+    ids = assigndictids(sch.fields, dictids)
+    fielddictids = IdDict{Field,Int64}(ids)
+    validatedictionaryids(sch.fields, fielddictids)
+    feats =
+        features === nothing ? _incrementalfeatures(ids, codec, file, dictreplacement) :
+        features
+    st = IPCWriteState(
+        io,
+        file,
+        sch,
+        fielddictids,
+        ids,
+        feats,
+        codec,
+        _encodestates(codec, compresslevel, ntasks),
+        Int(ntasks),
+        growth,
+        Tuple{Field,Int64}[],
+        AC._ValidatedDictionaries(),
+        Dict{Int64,ArrayData}(),
+        NTuple{3,Int64}[],
+        NTuple{3,Int64}[],
+        Int64(0),
+        false,
+        false,
+        Tuple{Task,Vector{EncodeState},Any}[],
+        Vector{EncodeState}[],
+    )
+    out = UInt8[]
+    if file
+        append!(out, FILE_MAGIC)
+        append!(out, zeros(UInt8, 2))    # pad to 8 before the first message
+    end
+    _schemamessage!(out, sch, fielddictids, feats)
+    _publish!(st, out)
+    return st
+end
+
+# Publish staged messages in order: each header, then its body straight
+# from the column buffers. A file-format Block records the global offset,
+# the header length (prefix + metadata), and the body length.
+function _publishmessages!(st::IPCWriteState, messages, states=st.states)
+    for (header, body, blocks) in messages
+        blocks === nothing ||
+            push!(blocks, (st.written, Int64(length(header)), body.bodylen))
+        Base.write(st.io, header)
+        _writebody(st.io, body)
+        st.written += length(header) + body.bodylen
+    end
+    # The sink holds the bytes now, so the frames can hold the next ones.
+    _recycleframes!(states)
+    return nothing
+end
+
+# Encode staged messages: each builder makes one (header, body) with `states`.
+_buildmessages(builders, states, ntasks) = Tuple{Vector{UInt8},EncodeCursor,Any}[
+    (build(states, ntasks)..., blocks) for (build, blocks) in builders
+]
+
+"Publish the oldest pending batch, after its encoding task finishes."
+function _publishnext!(st::IPCWriteState)
+    task, states, recycle = popfirst!(st.pending)
+    try
+        messages = try
+            fetch(task)
+        catch err
+            _recycleframes!(states)
+            # Later batches were staged on this one's dictionary state: none
+            # may publish after it, and no new batch may build on it.
+            _discardpending!(st)
+            st.failed = true
+            err isa TaskFailedException && throw(err.task.exception)
+            rethrow()
+        end
+        _publishmessages!(st, messages, states)
+        _recycle!(st, recycle)
+    finally
+        # Failed sink writes must leave every codec reachable by abortwrite!.
+        push!(st.statesets, states)
+    end
+    return nothing
+end
+
+"Publish every pending batch, in order."
+function drainwrite!(st::IPCWriteState)
+    while !isempty(st.pending)
+        _publishnext!(st)
+    end
+    return nothing
+end
+
+"Order-sensitive pool equality, including Union routes inside nested values."
+function _poolsequal(vf::Field, a::ArrayData, b::ArrayData)
+    a === b && return true
+    a.len == b.len || return false
+    return _poolrangeequal(vf, a, Int64(0), b, Int64(0), a.len)
+end
+
+_poolrangeequal(f::Field, a::ArrayData, lo::Int64, b::ArrayData, bo::Int64, n::Int64) =
+    _poolrangeequal(f.type, f, a, lo, b, bo, n)
+
+function _poolrangeequal(
+    t::T,
+    f::Field,
+    a::ArrayData,
+    lo::Int64,
+    b::ArrayData,
+    bo::Int64,
+    n::Int64,
+) where {T<:ArrowType}
+    for i = 1:n
+        _poolvalueequal(t, f, a, lo + i, b, bo + i) || return false
+    end
+    return true
+end
+
+_poolvalueequal(f::Field, a::ArrayData, ia::Int64, b::ArrayData, ib::Int64) =
+    _poolvalueequal(f.type, f, a, ia, b, ib)
+
+function _poolvalueequal(
+    t::T,
+    f::Field,
+    a::ArrayData,
+    ia::Int64,
+    b::ArrayData,
+    ib::Int64,
+) where {T<:ArrowType}
+    if t isa NullType
+        return true
+    elseif t isa UnionType
+        atag = AC.loadat(AC.rolebuffer(a, AC.TYPE_IDS), Int8, AC._slotindex0(a, ia))
+        btag = AC.loadat(AC.rolebuffer(b, AC.TYPE_IDS), Int8, AC._slotindex0(b, ib))
+        atag == btag || return false
+        cf, ca, ja = AC._union_child(f, a, ia)
+        _, cb, jb = AC._union_child(f, b, ib)
+        return _poolvalueequal(cf, ca, ja, cb, jb)
+    elseif t isa RunEndEncodedType
+        return _poolvalueequal(
+            f.children[2],
+            a.children[2],
+            AC._ree_runindex(a, ia),
+            b.children[2],
+            AC._ree_runindex(b, ib),
+        )
+    end
+    present = AC.isvalid_at(a, ia)
+    present == AC.isvalid_at(b, ib) || return false
+    present || return true
+    if t isa DictionaryType
+        w = AC.primwidth(t.indextype)
+        ja = AC._load_int(AC.rolebuffer(a, AC.DATA), t.indextype, AC._slotbyteoff(a, ia, w))
+        jb = AC._load_int(AC.rolebuffer(b, AC.DATA), t.indextype, AC._slotbyteoff(b, ib, w))
+        return _poolvalueequal(
+            AC.dictvaluefield(f, t),
+            a.dictionary,
+            Int64(ja) + 1,
+            b.dictionary,
+            Int64(jb) + 1,
+        )
+    elseif t isa StructType
+        for j in eachindex(f.children)
+            _poolvalueequal(
+                f.children[j],
+                a.children[j],
+                a.offset + ia,
+                b.children[j],
+                b.offset + ib,
+            ) || return false
+        end
+        return true
+    elseif t isa Union{ListType,MapType,FixedSizeListType,ListViewType}
+        if t isa FixedSizeListType
+            lo, n = AC._slotindex0(a, ia) * t.listsize, Int64(t.listsize)
+            bo, bn = AC._slotindex0(b, ib) * t.listsize, n
+        elseif t isa ListViewType
+            lo, n = AC._listview_range(t, a, ia)
+            bo, bn = AC._listview_range(t, b, ib)
+        else
+            wide = AC.layoutspec_of(t).offsetwidth == 8
+            lo, hi = AC._offsets_at(a, ia, wide)
+            bo, bh = AC._offsets_at(b, ib, wide)
+            n, bn = hi - lo, bh - bo
+        end
+        n == bn || return false
+        return _poolrangeequal(f.children[1], a.children[1], lo, b.children[1], bo, n)
+    end
+    avalue = AC._value(t, f, a, ia)
+    bvalue = AC._value(t, f, b, ib)
+    return t isa FloatType ? _poolkey(avalue) == _poolkey(bvalue) : isequal(avalue, bvalue)
+end
+
+"""
+    writebatch!(st, batch; validate=true, deltas=nothing)
+
+Publish one record batch, preceded by any dictionary batches it needs. A pool
+whose id has `deltas[id]` extends the pool written before by those values:
+it is written as `st.growth` says (a delta dictionary batch, the whole pool
+again in a stream, or nothing until `finishwrite!` writes each file
+dictionary once). Any other changed pool is a replacement (stream format,
+declared) or refused.
+"""
+function writebatch!(
+    st::IPCWriteState,
+    batch::AC.RecordBatch;
+    validate::Bool=true,
+    deltas::Union{Nothing,Dict{Int64,ArrayData}}=nothing,
+    recycle=nothing,
+)
+    st.finished && throw(ArgumentError("this IPC writer is already finished"))
+    st.failed && throw(
+        ArgumentError(
+            "this IPC writer stopped at a batch that failed to encode; close it to keep " *
+            "the batches written before, or abandon it",
+        ),
+    )
+    if validate
+        _checkbatches(st.schema, (batch,))
+        _validatewriterbatch!(st.validated, st.schema, batch, st.ids)
+    end
+    # Stage every message (dictionaries first, then the record batch) and the
+    # pool updates, so a failure publishes nothing and changes no state. A
+    # shared or nested dictionary id occurs more than once in a batch, always
+    # with one pool: its first occurrence stages the pool, the rest see it.
+    builders = Tuple{Any,Any}[]
+    staged = Dict{Int64,ArrayData}()
+    deferred = Tuple{Field,Int64}[]
+    dictblocks = st.file ? st.dictblocks : nothing
+    for (f, pool) in dictionarypools(st.schema.fields, batch.columns)
+        id = st.ids[f]
+        old = haskey(staged, id) ? staged[id] : get(st.current, id, nothing)
+        old === pool && continue
+        vf = AC.dictvaluefield(f, f.type::DictionaryType)
+        delta = deltas === nothing || old === nothing ? nothing : get(deltas, id, nothing)
+        if st.growth === :defer
+            # Batches index into the pool as far as it has grown; the final
+            # pool covers them all.
+            old === nothing ||
+                delta !== nothing ||
+                _poolsequal(vf, old, pool) ||
+                throw(
+                    ValidationError(
+                        "column $(f.name) changed its existing dictionary " *
+                        "categories; the IPC file format carries one dictionary " *
+                        "per column, which can only gain categories — use the " *
+                        "stream format for replacement",
+                    ),
+                )
+            old === nothing && push!(deferred, (f, id))
+            staged[id] = pool
+            continue
+        end
+        if delta !== nothing && st.growth === :replace
+            # A stream re-sends a grown pool whole, which every reader accepts.
+            push!(builders, (_dictbuilder(st, id, vf, pool, false), dictblocks))
+            staged[id] = pool
+            continue
+        end
+        if delta !== nothing
+            old.len + delta.len == pool.len || throw(
+                ArgumentError("delta dictionary does not complete the pool for id $id"),
+            )
+            validate_semantic(vf, delta)
+            push!(builders, (_dictbuilder(st, id, vf, delta, true), dictblocks))
+            staged[id] = pool
+            continue
+        end
+        if old !== nothing
+            if st.file
+                # The file format carries one dictionary per id, extended
+                # only by deltas. A new pool object with identical content
+                # references the emitted batches; anything else is
+                # replacement, which files cannot say.
+                _poolsequal(vf, old, pool) || throw(
+                    ValidationError(
+                        "column $(f.name) changed its existing dictionary " *
+                        "categories; the IPC file format carries one dictionary " *
+                        "per column (new categories are appended as deltas) — use " *
+                        "the stream format for replacement",
+                    ),
+                )
+                staged[id] = pool
+                continue
+            end
+            if !(FEATURE_DICTIONARY_REPLACEMENT in st.features)
+                # Require an explicit replacement declaration on output;
+                # the reader also accepts undeclared replacements from peers.
+                _poolsequal(vf, old, pool) || throw(
+                    ValidationError(
+                        "column $(f.name) changed its existing dictionary " *
+                        "categories, but the stream's schema message does not " *
+                        "declare the DictionaryReplacement feature (create the " *
+                        "stream with Arrow.Writer(...; dictreplacement=true))",
+                    ),
+                )
+                staged[id] = pool
+                continue
+            end
+        end
+        push!(builders, (_dictbuilder(st, id, vf, pool, false), dictblocks))
+        staged[id] = pool
+    end
+    fields, codec = st.schema.fields, st.codec
+    record = (states, k) -> _recordmessage(batch, fields, codec, states, k)
+    push!(builders, (record, st.file ? st.recordblocks : nothing))
+    if st.ntasks > 1 && codec != CODEC_NONE
+        states =
+            isempty(st.statesets) ? _encodestates(codec, st.states[1].level, st.ntasks) :
+            pop!(st.statesets)
+        task = errormonitor(Threads.@spawn _buildmessages(builders, states, st.ntasks))
+        push!(st.pending, (task, states, recycle))
+        merge!(st.current, staged)
+        length(st.pending) > _INFLIGHT - 1 && _publishnext!(st)
+    else
+        _publishmessages!(st, _buildmessages(builders, st.states, st.ntasks))
+        merge!(st.current, staged)
+        _recycle!(st, recycle)
+    end
+    append!(st.deferred, deferred)
+    return nothing
+end
+
+_dictbuilder(st::IPCWriteState, id, vf, pool, isdelta::Bool) =
+    (states, k) -> _dictionarymessage(id, vf, pool, st.codec, states, k; isdelta)
+
+# The file-format trailer: Footer flatbuffer (schema again, then the two
+# Block struct-vectors), the Int32 footer length, and the trailing magic.
+function _filefooter!(
+    out::Vector{UInt8},
+    sch::Schema,
+    fielddictids::IdDict{Field,Int64},
+    features::Vector{Int64},
+    dictblocks::Vector{NTuple{3,Int64}},
+    recordblocks::Vector{NTuple{3,Int64}},
+)
+    b = FB.Builder(1024)
+    schoff = _metaschema!(b, sch, fielddictids, features)
+    Meta.footerStartDictionariesVector(b, length(dictblocks))
+    for (off, metalen, bodylen) in Iterators.reverse(dictblocks)
+        Meta.createBlock(b, off, Int32(metalen), bodylen)
+    end
+    dictvec = FB.endvector!(b, length(dictblocks))
+    Meta.footerStartRecordBatchesVector(b, length(recordblocks))
+    for (off, metalen, bodylen) in Iterators.reverse(recordblocks)
+        Meta.createBlock(b, off, Int32(metalen), bodylen)
+    end
+    recordvec = FB.endvector!(b, length(recordblocks))
+    Meta.footerStart(b)
+    Meta.footerAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.footerAddSchema(b, schoff)
+    Meta.footerAddDictionaries(b, dictvec)
+    Meta.footerAddRecordBatches(b, recordvec)
+    FB.finish!(b, Meta.footerEnd(b))
+    footer = collect(FB.finishedbytes(b))
+    append!(out, footer)
+    append!(out, reinterpret(UInt8, Int32[Int32(length(footer))]))
+    append!(out, FILE_MAGIC)
+    return nothing
+end
+
+function finishwrite!(st::IPCWriteState)
+    st.finished && return nothing
+    drainwrite!(st)
+    if st.growth === :defer && !isempty(st.current)
+        # Each id's final pool once, after the record batches that use it (the
+        # file format allows a dictionary anywhere before the footer).
+        messages = Tuple{Vector{UInt8},EncodeCursor,Any}[]
+        for (f, id) in st.deferred
+            vf = AC.dictvaluefield(f, f.type::DictionaryType)
+            header, body =
+                _dictionarymessage(id, vf, st.current[id], st.codec, st.states, st.ntasks)
+            push!(messages, (header, body, st.dictblocks))
+        end
+        _publishmessages!(st, messages)
+    end
+    out = UInt8[]
+    append!(out, reinterpret(UInt8, UInt32[CONTINUATION, UInt32(0)]))
+    st.file && _filefooter!(
+        out,
+        st.schema,
+        st.fielddictids,
+        st.features,
+        st.dictblocks,
+        st.recordblocks,
+    )
+    _publish!(st, out)
+    st.finished = true
+    _closestates!(st)
+    return nothing
+end
+
+"Wait for every pending batch and drop it unpublished."
+function _discardpending!(st::IPCWriteState)
+    for (task, states, _) in st.pending
+        # A failure here follows from the caller's error.
+        try
+            wait(task)
+        catch
+        end
+        _recycleframes!(states)
+        push!(st.statesets, states)
+    end
+    empty!(st.pending)
+    return nothing
+end
+
+"Release the codec state without emitting anything; for error cleanup."
+function abortwrite!(st::IPCWriteState)
+    st.finished && return nothing
+    st.finished = true
+    _discardpending!(st)
+    _closestates!(st)
+    return nothing
+end
+
+function _closestates!(st::IPCWriteState)
+    foreach(close, st.states)
+    foreach(states -> foreach(close, states), st.statesets)
+    empty!(st.statesets)
+    return nothing
+end
+
+"""
+Resume a STREAM whose schema message is already on the wire: a state that
+emits no preamble. `features` must be the features that schema message
+declared, and `current` the last pool each dictionary id has emitted —
+`writebatch!` then skips content-identical pools and gates replacement on
+the declared features exactly as it does mid-stream.
+"""
+function resumestream!(
+    io::IO,
+    sch::Schema,
+    dictids::IdDict{Field,Int64},
+    features::Vector{Int64};
+    compress::Symbol=:none,
+    compresslevel::Union{Nothing,Integer}=nothing,
+    current::Dict{Int64,ArrayData}=Dict{Int64,ArrayData}(),
+    ntasks::Integer=1,
+    growth::Symbol=:delta,
+)
+    _requirelittleendian()
+    haskey(CODEC_NAMES, compress) ||
+        throw(ArgumentError("compress must be :none, :lz4, or :zstd"))
+    codec = CODEC_NAMES[compress]
+    ids = assigndictids(sch.fields, dictids)
+    return IPCWriteState(
+        io,
+        false,
+        sch,
+        IdDict{Field,Int64}(ids),
+        ids,
+        features,
+        codec,
+        _encodestates(codec, compresslevel, ntasks),
+        Int(ntasks),
+        _checkgrowth(growth, false),
+        Tuple{Field,Int64}[],
+        AC._ValidatedDictionaries(),
+        current,
+        NTuple{3,Int64}[],
+        NTuple{3,Int64}[],
+        Int64(0),
+        false,
+        false,
+        Tuple{Task,Vector{EncodeState},Any}[],
+        Vector{EncodeState}[],
+    )
+end
+
+"""
+    writestream(sch, batches; compress=:none, compresslevel=nothing, dictids=IdDict{Field,Int64}()) -> Vector{UInt8}
+    writestream(stream::IPCStream; compress=:none) -> Vector{UInt8}
+
+Encode a complete IPC stream: schema message, dictionary batches emitted
+before the first record batch that references them (and again on
+pool-identity change), record batches, end-of-stream marker. Every column is
+semantically validated before any of its bytes are emitted — the writer
+refuses to publish data Core would refuse to read. `dictids` preserves ids
+from a source table (the `IPCStream` form passes the reader's), so fields
+sharing one id keep sharing one dictionary batch, exactly as the source did.
+"""
+function writestream(
+    sch::Schema,
+    batches::AbstractVector{AC.RecordBatch};
+    compress::Symbol=:none,
+    compresslevel::Union{Nothing,Integer}=nothing,
+    dictids::IdDict{Field,Int64}=IdDict{Field,Int64}(),
+)
+    _requirelittleendian()
+    haskey(CODEC_NAMES, compress) ||
+        throw(ArgumentError("compress must be :none, :lz4, or :zstd"))
+    codec = CODEC_NAMES[compress]
+    _checkbatches(sch, batches)
+    _validatewriterschema(sch)
+    # `beginwrite!` recomputes the same ids from `dictids` (assignment is
+    # deterministic); this pass exists so the whole batch sequence is
+    # validated — and its EXACT features computed — before any bytes exist.
+    # A declared feature is a demand on readers, so an eager stream declares
+    # only what these batches actually use.
+    ids = assigndictids(sch.fields, dictids)
+    validatedictionaryids(sch.fields, IdDict{Field,Int64}(ids))
+    _validatewriterbatches(sch, batches, ids)
+    io = IOBuffer(; sizehint=_outputhint(batches, codec))
+    st = beginwrite!(
+        io,
+        sch;
+        file=false,
+        compress=compress,
+        compresslevel=compresslevel,
+        dictids=dictids,
+        features=_streamfeatures(sch, batches, ids, codec),
+    )
+    try
+        for batch in batches
+            writebatch!(st, batch; validate=false)
+        end
+        finishwrite!(st)
+    finally
+        abortwrite!(st)
+    end
+    return take!(io)
+end
+
+writestream(s::IPCStream; compress::Symbol=:none) =
+    writestream(s.schema, s.batches; compress=compress, dictids=s.fielddictids)
+
+# ---------------------------------------------------------------------------
+# File format: magic + stream messages + Block index + Footer
+# ---------------------------------------------------------------------------
+
+const FILE_MAGIC = b"ARROW1"
+
+"""
+    writefile(sch, batches; compress=:none, compresslevel=nothing, dictids=IdDict{Field,Int64}()) -> Vector{UInt8}
+    writefile(stream::IPCStream; compress=:none) -> Vector{UInt8}
+
+The file variant: leading magic, the same stream messages, an end-of-stream
+marker, then the Footer with its dictionary and record-batch Block indexes,
+the Int32 footer length, and the trailing magic. Footer bookkeeping is
+isolated here; message writing is the stream code above. The file format
+carries one dictionary per id: a later pool that extends the previous one
+value by value is written as a delta dictionary batch, and any other pool
+change is a clean refusal (the stream format handles replacement).
+`dictids` preserves ids from a source table (the `IPCStream` form passes the
+reader's), so fields sharing one id keep sharing one dictionary batch,
+exactly as the source did.
+"""
+function writefile(
+    sch::Schema,
+    batches::AbstractVector{AC.RecordBatch};
+    compress::Symbol=:none,
+    compresslevel::Union{Nothing,Integer}=nothing,
+    dictids::IdDict{Field,Int64}=IdDict{Field,Int64}(),
+)
+    _requirelittleendian()
+    haskey(CODEC_NAMES, compress) ||
+        throw(ArgumentError("compress must be :none, :lz4, or :zstd"))
+    codec = CODEC_NAMES[compress]
+    _checkbatches(sch, batches)
+    _validatewriterschema(sch)
+    ids = assigndictids(sch.fields, dictids)
+    # Same shared-id contract as the stream writer: compatible value schemas,
+    # one nested id topology, one pool per id within each batch.
+    validatedictionaryids(sch.fields, IdDict{Field,Int64}(ids))
+    _validatewriterbatches(sch, batches, ids)
+    deltas = _batchdeltas(sch, batches, ids)
+    # CODEC_NONE so this refusal sees only DICTIONARY_REPLACEMENT.
+    # COMPRESSED_BODY is legal in a file and is declared through the features
+    # below.
+    isempty(_streamfeatures(sch, batches, ids, CODEC_NONE, deltas)) || throw(
+        ValidationError(
+            "the IPC file format carries one dictionary per id, extended only " *
+            "by delta batches; a dictionary whose existing categories change " *
+            "requires the stream format",
+        ),
+    )
+    io = IOBuffer(; sizehint=_outputhint(batches, codec))
+    st = beginwrite!(
+        io,
+        sch;
+        file=true,
+        compress=compress,
+        compresslevel=compresslevel,
+        dictids=dictids,
+        features=_streamfeatures(sch, batches, ids, codec, deltas),
+    )
+    try
+        for (batch, delta) in zip(batches, deltas)
+            writebatch!(st, batch; validate=false, deltas=delta)
+        end
+        finishwrite!(st)
+    finally
+        abortwrite!(st)
+    end
+    return take!(io)
+end
+
+writefile(s::IPCStream; compress::Symbol=:none) =
+    writefile(s.schema, s.batches; compress=compress, dictids=s.fielddictids)
+
+# Each batch's delta dictionaries against the pools the batches before it use.
+function _batchdeltas(sch::Schema, batches, ids)
+    current = Dict{Int64,ArrayData}()
+    return map(batches) do batch
+        deltas = _dictionarydeltas(current, sch.fields, ids, batch)
+        for (f, pool) in dictionarypools(sch.fields, batch.columns)
+            current[ids[f]] = pool
+        end
+        deltas
+    end
+end
diff --git a/src/metadata/File.jl b/src/metadata/File.jl
index 184833c1..79ee9bc8 100644
--- a/src/metadata/File.jl
+++ b/src/metadata/File.jl
@@ -14,6 +14,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# GENERATED by tools/fbsgen.jl from apache/arrow format/File.fbs —
+# do not edit by hand; rerun the generator against the current spec.
+
 struct Footer <: FlatBuffers.Table
     bytes::Vector{UInt8}
     pos::Base.Int
@@ -52,7 +55,7 @@ function Base.getproperty(x::Footer, field::Symbol)
     return nothing
 end
 
-footerStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 4)
+footerStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 5)
 footerAddVersion(b::FlatBuffers.Builder, version::MetadataVersion.T) =
     FlatBuffers.prependslot!(b, 0, version, 0)
 footerAddSchema(b::FlatBuffers.Builder, schema::FlatBuffers.UOffsetT) =
@@ -61,10 +64,14 @@ footerAddDictionaries(b::FlatBuffers.Builder, dictionaries::FlatBuffers.UOffsetT
     FlatBuffers.prependoffsetslot!(b, 2, dictionaries, 0)
 footerStartDictionariesVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 24, numelems, 8)
-footerAddRecordBatches(b::FlatBuffers.Builder, recordbatches::FlatBuffers.UOffsetT) =
-    FlatBuffers.prependoffsetslot!(b, 3, recordbatches, 0)
+footerAddRecordBatches(b::FlatBuffers.Builder, recordBatches::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 3, recordBatches, 0)
 footerStartRecordBatchesVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 24, numelems, 8)
+footerAddCustomMetadata(b::FlatBuffers.Builder, custom_metadata::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 4, custom_metadata, 0)
+footerStartCustomMetadataVector(b::FlatBuffers.Builder, numelems) =
+    FlatBuffers.startvector!(b, 4, numelems, 4)
 footerEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
 struct Block <: FlatBuffers.Struct
@@ -90,13 +97,13 @@ end
 function createBlock(
     b::FlatBuffers.Builder,
     offset::Int64,
-    metadatalength::Int32,
-    bodylength::Int64,
+    metaDataLength::Int32,
+    bodyLength::Int64,
 )
     FlatBuffers.prep!(b, 8, 24)
-    prepend!(b, bodylength)
+    prepend!(b, bodyLength)
     FlatBuffers.pad!(b, 4)
-    prepend!(b, metadatalength)
+    prepend!(b, metaDataLength)
     prepend!(b, offset)
     return FlatBuffers.offset(b)
 end
diff --git a/src/metadata/Message.jl b/src/metadata/Message.jl
index 0e494394..52c7a2eb 100644
--- a/src/metadata/Message.jl
+++ b/src/metadata/Message.jl
@@ -14,6 +14,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+# GENERATED by tools/fbsgen.jl from apache/arrow format/Message.fbs —
+# do not edit by hand; rerun the generator against the current spec.
+
 struct FieldNode <: FlatBuffers.Struct
     bytes::Vector{UInt8}
     pos::Base.Int
@@ -32,16 +35,16 @@ function Base.getproperty(x::FieldNode, field::Symbol)
     return nothing
 end
 
-function createFieldNode(b::FlatBuffers.Builder, length::Int64, nullCount::Int64)
+function createFieldNode(b::FlatBuffers.Builder, length::Int64, null_count::Int64)
     FlatBuffers.prep!(b, 8, 16)
-    prepend!(b, nullCount)
+    prepend!(b, null_count)
     prepend!(b, length)
     return FlatBuffers.offset(b)
 end
 
-@enumx CompressionType::Int8 LZ4_FRAME ZSTD
+@enumx CompressionType::Int8 LZ4_FRAME=0 ZSTD=1
 
-@enumx BodyCompressionMethod::Int8 BUFFER
+@enumx BodyCompressionMethod::Int8 BUFFER=0
 
 struct BodyCompression <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -82,6 +85,7 @@ function Base.getproperty(x::RecordBatch, field::Symbol)
     if field === :length
         o = FlatBuffers.offset(x, 4)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int64)
+        return Int64(0)
     elseif field === :nodes
         o = FlatBuffers.offset(x, 6)
         if o != 0
@@ -101,13 +105,13 @@ function Base.getproperty(x::RecordBatch, field::Symbol)
     elseif field === :variadicBufferCounts
         o = FlatBuffers.offset(x, 12)
         if o != 0
-            return FlatBuffers.Array{Int32}(x, o)
+            return FlatBuffers.Array{Int64}(x, o)
         end
     end
     return nothing
 end
 
-recordBatchStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 4)
+recordBatchStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 5)
 recordBatchAddLength(b::FlatBuffers.Builder, length::Int64) =
     FlatBuffers.prependslot!(b, 0, length, 0)
 recordBatchAddNodes(b::FlatBuffers.Builder, nodes::FlatBuffers.UOffsetT) =
@@ -118,8 +122,14 @@ recordBatchAddBuffers(b::FlatBuffers.Builder, buffers::FlatBuffers.UOffsetT) =
     FlatBuffers.prependoffsetslot!(b, 2, buffers, 0)
 recordBatchStartBuffersVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 16, numelems, 8)
-recordBatchAddCompression(b::FlatBuffers.Builder, c::FlatBuffers.UOffsetT) =
-    FlatBuffers.prependoffsetslot!(b, 3, c, 0)
+recordBatchAddCompression(b::FlatBuffers.Builder, compression::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 3, compression, 0)
+recordBatchAddVariadicBufferCounts(
+    b::FlatBuffers.Builder,
+    variadicBufferCounts::FlatBuffers.UOffsetT,
+) = FlatBuffers.prependoffsetslot!(b, 4, variadicBufferCounts, 0)
+recordBatchStartVariadicBufferCountsVector(b::FlatBuffers.Builder, numelems) =
+    FlatBuffers.startvector!(b, 8, numelems, 8)
 recordBatchEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
 struct DictionaryBatch <: FlatBuffers.Table
@@ -153,10 +163,12 @@ dictionaryBatchAddId(b::FlatBuffers.Builder, id::Int64) =
     FlatBuffers.prependslot!(b, 0, id, 0)
 dictionaryBatchAddData(b::FlatBuffers.Builder, data::FlatBuffers.UOffsetT) =
     FlatBuffers.prependoffsetslot!(b, 1, data, 0)
-dictionaryBatchAddIsDelta(b::FlatBuffers.Builder, isdelta::Base.Bool) =
-    FlatBuffers.prependslot!(b, 2, isdelta, false)
+dictionaryBatchAddIsDelta(b::FlatBuffers.Builder, isDelta::Base.Bool) =
+    FlatBuffers.prependslot!(b, 2, isDelta, false)
 dictionaryBatchEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
+function MessageHeader end
+
 function MessageHeader(b::UInt8)
     b == 1 && return Schema
     b == 2 && return DictionaryBatch
@@ -186,6 +198,7 @@ function Base.getproperty(x::Message, field::Symbol)
     if field === :version
         o = FlatBuffers.offset(x, 4)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), MetadataVersion.T)
+        return MetadataVersion.V1
     elseif field === :header
         o = FlatBuffers.offset(x, 6)
         if o != 0
@@ -218,8 +231,8 @@ messageAddHeader(b::FlatBuffers.Builder, header::FlatBuffers.UOffsetT) =
     FlatBuffers.prependoffsetslot!(b, 2, header, 0)
 messageAddBodyLength(b::FlatBuffers.Builder, bodyLength::Int64) =
     FlatBuffers.prependslot!(b, 3, bodyLength, 0)
-messageAddCustomMetadata(b::FlatBuffers.Builder, meta::FlatBuffers.UOffsetT) =
-    FlatBuffers.prependoffsetslot!(b, 4, meta, 0)
+messageAddCustomMetadata(b::FlatBuffers.Builder, custom_metadata::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 4, custom_metadata, 0)
 messageStartCustomMetadataVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 4, numelems, 4)
 messageEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
diff --git a/src/metadata/Schema.jl b/src/metadata/Schema.jl
index 625f172e..70af34ef 100644
--- a/src/metadata/Schema.jl
+++ b/src/metadata/Schema.jl
@@ -14,7 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-@enumx MetadataVersion::Int16 V1 V2 V3 V4 V5
+# GENERATED by tools/fbsgen.jl from apache/arrow format/Schema.fbs —
+# do not edit by hand; rerun the generator against the current spec.
+
+@enumx MetadataVersion::Int16 V1=0 V2=1 V3=2 V4=3 V5=4
+
+@enumx Feature::Int64 UNUSED=0 DICTIONARY_REPLACEMENT=1 COMPRESSED_BODY=2
 
 struct Null <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -56,6 +61,26 @@ Base.propertynames(x::LargeList) = ()
 largeListStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 largeListEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
+struct ListView <: FlatBuffers.Table
+    bytes::Vector{UInt8}
+    pos::Base.Int
+end
+
+Base.propertynames(x::ListView) = ()
+
+listViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
+listViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
+
+struct LargeListView <: FlatBuffers.Table
+    bytes::Vector{UInt8}
+    pos::Base.Int
+end
+
+Base.propertynames(x::LargeListView) = ()
+
+largeListViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
+largeListViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
+
 struct FixedSizeList <: FlatBuffers.Table
     bytes::Vector{UInt8}
     pos::Base.Int
@@ -88,16 +113,17 @@ function Base.getproperty(x::Map, field::Symbol)
     if field === :keysSorted
         o = FlatBuffers.offset(x, 4)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Base.Bool)
+        return false
     end
     return nothing
 end
 
 mapStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
-mapAddKeysSorted(b::FlatBuffers.Builder, keyssorted::Base.Bool) =
-    FlatBuffers.prependslot!(b, 0, keyssorted, 0)
+mapAddKeysSorted(b::FlatBuffers.Builder, keysSorted::Base.Bool) =
+    FlatBuffers.prependslot!(b, 0, keysSorted, false)
 mapEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-@enumx UnionMode::Int16 Sparse Dense
+@enumx UnionMode::Int16 Sparse=0 Dense=1
 
 struct Union <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -113,7 +139,9 @@ function Base.getproperty(x::Union, field::Symbol)
         return UnionMode.Sparse
     elseif field === :typeIds
         o = FlatBuffers.offset(x, 6)
-        o != 0 && return FlatBuffers.Array{Int32}(x, o)
+        if o != 0
+            return FlatBuffers.Array{Int32}(x, o)
+        end
     end
     return nothing
 end
@@ -138,6 +166,7 @@ function Base.getproperty(x::Int, field::Symbol)
     if field === :bitWidth
         o = FlatBuffers.offset(x, 4)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
+        return Int32(0)
     elseif field === :is_signed
         o = FlatBuffers.offset(x, 6)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Base.Bool)
@@ -147,13 +176,13 @@ function Base.getproperty(x::Int, field::Symbol)
 end
 
 intStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 2)
-intAddBitWidth(b::FlatBuffers.Builder, bitwidth::Int32) =
-    FlatBuffers.prependslot!(b, 0, bitwidth, 0)
-intAddIsSigned(b::FlatBuffers.Builder, issigned::Base.Bool) =
-    FlatBuffers.prependslot!(b, 1, issigned, 0)
+intAddBitWidth(b::FlatBuffers.Builder, bitWidth::Int32) =
+    FlatBuffers.prependslot!(b, 0, bitWidth, 0)
+intAddIsSigned(b::FlatBuffers.Builder, is_signed::Base.Bool) =
+    FlatBuffers.prependslot!(b, 1, is_signed, false)
 intEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-@enumx Precision::Int16 HALF SINGLE DOUBLE
+@enumx Precision::Int16 HALF=0 SINGLE=1 DOUBLE=2
 
 struct FloatingPoint <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -203,8 +232,8 @@ end
 
 Base.propertynames(x::LargeUtf8) = ()
 
-largUtf8Start(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
-largUtf8End(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
+largeUtf8Start(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
+largeUtf8End(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
 struct LargeBinary <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -216,6 +245,26 @@ Base.propertynames(x::LargeBinary) = ()
 largeBinaryStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 largeBinaryEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
+struct Utf8View <: FlatBuffers.Table
+    bytes::Vector{UInt8}
+    pos::Base.Int
+end
+
+Base.propertynames(x::Utf8View) = ()
+
+utf8ViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
+utf8ViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
+
+struct BinaryView <: FlatBuffers.Table
+    bytes::Vector{UInt8}
+    pos::Base.Int
+end
+
+Base.propertynames(x::BinaryView) = ()
+
+binaryViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
+binaryViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
+
 struct FixedSizeBinary <: FlatBuffers.Table
     bytes::Vector{UInt8}
     pos::Base.Int
@@ -227,13 +276,14 @@ function Base.getproperty(x::FixedSizeBinary, field::Symbol)
     if field === :byteWidth
         o = FlatBuffers.offset(x, 4)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
+        return Int32(0)
     end
     return nothing
 end
 
 fixedSizeBinaryStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 1)
-fixedSizeBinaryAddByteWidth(b::FlatBuffers.Builder, bytewidth::Int32) =
-    FlatBuffers.prependslot!(b, 0, bytewidth, 0)
+fixedSizeBinaryAddByteWidth(b::FlatBuffers.Builder, byteWidth::Int32) =
+    FlatBuffers.prependslot!(b, 0, byteWidth, 0)
 fixedSizeBinaryEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
 struct Bool <: FlatBuffers.Table
@@ -246,6 +296,16 @@ Base.propertynames(x::Bool) = ()
 boolStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
 boolEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
+struct RunEndEncoded <: FlatBuffers.Table
+    bytes::Vector{UInt8}
+    pos::Base.Int
+end
+
+Base.propertynames(x::RunEndEncoded) = ()
+
+runEndEncodedStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
+runEndEncodedEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
+
 struct Decimal <: FlatBuffers.Table
     bytes::Vector{UInt8}
     pos::Base.Int
@@ -276,10 +336,10 @@ decimalAddPrecision(b::FlatBuffers.Builder, precision::Int32) =
 decimalAddScale(b::FlatBuffers.Builder, scale::Int32) =
     FlatBuffers.prependslot!(b, 1, scale, 0)
 decimalAddBitWidth(b::FlatBuffers.Builder, bitWidth::Int32) =
-    FlatBuffers.prependslot!(b, 2, bitWidth, Int32(128))
+    FlatBuffers.prependslot!(b, 2, bitWidth, 128)
 decimalEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-@enumx DateUnit::Int16 DAY MILLISECOND
+@enumx DateUnit::Int16 DAY=0 MILLISECOND=1
 
 struct Date <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -302,7 +362,7 @@ dateAddUnit(b::FlatBuffers.Builder, unit::DateUnit.T) =
     FlatBuffers.prependslot!(b, 0, unit, 1)
 dateEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-@enumx TimeUnit::Int16 SECOND MILLISECOND MICROSECOND NANOSECOND
+@enumx TimeUnit::Int16 SECOND=0 MILLISECOND=1 MICROSECOND=2 NANOSECOND=3
 
 struct Time <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -319,7 +379,7 @@ function Base.getproperty(x::Time, field::Symbol)
     elseif field === :bitWidth
         o = FlatBuffers.offset(x, 6)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Int32)
-        return 32
+        return Int32(32)
     end
     return nothing
 end
@@ -327,8 +387,8 @@ end
 timeStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 2)
 timeAddUnit(b::FlatBuffers.Builder, unit::TimeUnit.T) =
     FlatBuffers.prependslot!(b, 0, unit, 1)
-timeAddBitWidth(b::FlatBuffers.Builder, bitwidth::Int32) =
-    FlatBuffers.prependslot!(b, 1, bitwidth, 32)
+timeAddBitWidth(b::FlatBuffers.Builder, bitWidth::Int32) =
+    FlatBuffers.prependslot!(b, 1, bitWidth, 32)
 timeEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
 struct Timestamp <: FlatBuffers.Table
@@ -357,7 +417,7 @@ timestampAddTimezone(b::FlatBuffers.Builder, timezone::FlatBuffers.UOffsetT) =
     FlatBuffers.prependoffsetslot!(b, 1, timezone, 0)
 timestampEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-@enumx IntervalUnit::Int16 YEAR_MONTH DAY_TIME
+@enumx IntervalUnit::Int16 YEAR_MONTH=0 DAY_TIME=1 MONTH_DAY_NANO=2
 
 struct Interval <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -401,94 +461,6 @@ durationAddUnit(b::FlatBuffers.Builder, unit::TimeUnit.T) =
     FlatBuffers.prependslot!(b, 0, unit, 1)
 durationEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-# /// Contains two child arrays, run_ends and values.
-# /// The run_ends child array must be a 16/32/64-bit integer array
-# /// which encodes the indices at which the run with the value in 
-# /// each corresponding index in the values child array ends.
-# /// Like list/struct types, the value array can be of any type.
-# table RunEndEncoded {
-# }
-struct RunEndEncoded <: FlatBuffers.Table
-    bytes::Vector{UInt8}
-    pos::Base.Int
-end
-
-Base.propertynames(x::RunEndEncoded) = ()
-
-runEndEncodedStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
-runEndEncodedEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
-
-# /// Logically the same as Binary, but the internal representation uses a view
-# /// struct that contains the string length and either the string's entire data
-# /// inline (for small strings) or an inlined prefix, an index of another buffer,
-# /// and an offset pointing to a slice in that buffer (for non-small strings).
-# ///
-# /// Since it uses a variable number of data buffers, each Field with this type
-# /// must have a corresponding entry in `variadicBufferCounts`.
-# table BinaryView {
-# }
-struct BinaryView <: FlatBuffers.Table
-    bytes::Vector{UInt8}
-    pos::Base.Int
-end
-
-Base.propertynames(x::BinaryView) = ()
-
-binaryViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
-binaryViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
-
-# /// Logically the same as Utf8, but the internal representation uses a view
-# /// struct that contains the string length and either the string's entire data
-# /// inline (for small strings) or an inlined prefix, an index of another buffer,
-# /// and an offset pointing to a slice in that buffer (for non-small strings).
-# ///
-# /// Since it uses a variable number of data buffers, each Field with this type
-# /// must have a corresponding entry in `variadicBufferCounts`.
-# table Utf8View {
-# }
-struct Utf8View <: FlatBuffers.Table
-    bytes::Vector{UInt8}
-    pos::Base.Int
-end
-
-Base.propertynames(x::Utf8View) = ()
-
-utf8ViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
-utf8ViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
-
-# /// Represents the same logical types that List can, but contains offsets and
-# /// sizes allowing for writes in any order and sharing of child values among
-# /// list values.
-# table ListView {
-# }
-struct ListView <: FlatBuffers.Table
-    bytes::Vector{UInt8}
-    pos::Base.Int
-end
-
-Base.propertynames(x::ListView) = ()
-
-listViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
-listViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
-
-# /// Represents the same logical types that LargeList can, but contains offsets
-# /// and sizes allowing for writes in any order and sharing of child values among
-# /// list values.
-# table LargeListView {
-# }
-struct LargeListView <: FlatBuffers.Table
-    bytes::Vector{UInt8}
-    pos::Base.Int
-end
-
-Base.propertynames(x::LargeListView) = ()
-
-largeListViewStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 0)
-largeListViewEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
-
-# Ensure this binding is distinct from `Base.Type` by forward-declaring it. Otherwise, in
-# Julia 1.12, defining a function called `Type` by simply defining methods ends up actually
-# defining methods for `Base.Type`.
 function Type end
 
 function Type(b::UInt8)
@@ -543,6 +515,11 @@ function Type(::Base.Type{T})::Int16 where {T}
     T == LargeBinary && return 19
     T == LargeUtf8 && return 20
     T == LargeList && return 21
+    T == RunEndEncoded && return 22
+    T == BinaryView && return 23
+    T == Utf8View && return 24
+    T == ListView && return 25
+    T == LargeListView && return 26
     return 0
 end
 
@@ -571,7 +548,7 @@ keyValueAddValue(b::FlatBuffers.Builder, value::FlatBuffers.UOffsetT) =
     FlatBuffers.prependoffsetslot!(b, 1, value, 0)
 keyValueEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-@enumx DictionaryKind::Int16 DenseArray
+@enumx DictionaryKind::Int16 DenseArray=0
 
 struct DictionaryEncoding <: FlatBuffers.Table
     bytes::Vector{UInt8}
@@ -598,17 +575,22 @@ function Base.getproperty(x::DictionaryEncoding, field::Symbol)
     elseif field === :dictionaryKind
         o = FlatBuffers.offset(x, 10)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), DictionaryKind.T)
+        return DictionaryKind.DenseArray
     end
     return nothing
 end
 
-dictionaryEncodingStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 3)
+dictionaryEncodingStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 4)
 dictionaryEncodingAddId(b::FlatBuffers.Builder, id::Int64) =
     FlatBuffers.prependslot!(b, 0, id, 0)
-dictionaryEncodingAddIndexType(b::FlatBuffers.Builder, indextype::FlatBuffers.UOffsetT) =
-    FlatBuffers.prependoffsetslot!(b, 1, indextype, 0)
-dictionaryEncodingAddIsOrdered(b::FlatBuffers.Builder, isordered::Base.Bool) =
-    FlatBuffers.prependslot!(b, 1, isordered, 0)
+dictionaryEncodingAddIndexType(b::FlatBuffers.Builder, indexType::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 1, indexType, 0)
+dictionaryEncodingAddIsOrdered(b::FlatBuffers.Builder, isOrdered::Base.Bool) =
+    FlatBuffers.prependslot!(b, 2, isOrdered, false)
+dictionaryEncodingAddDictionaryKind(
+    b::FlatBuffers.Builder,
+    dictionaryKind::DictionaryKind.T,
+) = FlatBuffers.prependslot!(b, 3, dictionaryKind, 0)
 dictionaryEncodingEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
 struct Field <: FlatBuffers.Table
@@ -672,13 +654,13 @@ fieldAddChildren(b::FlatBuffers.Builder, children::FlatBuffers.UOffsetT) =
     FlatBuffers.prependoffsetslot!(b, 5, children, 0)
 fieldStartChildrenVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 4, numelems, 4)
-fieldAddCustomMetadata(b::FlatBuffers.Builder, custommetadata::FlatBuffers.UOffsetT) =
-    FlatBuffers.prependoffsetslot!(b, 6, custommetadata, 0)
+fieldAddCustomMetadata(b::FlatBuffers.Builder, custom_metadata::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 6, custom_metadata, 0)
 fieldStartCustomMetadataVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 4, numelems, 4)
 fieldEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
 
-@enumx Endianness::Int16 Little Big
+@enumx Endianness::Int16 Little=0 Big=1
 
 struct Buffer <: FlatBuffers.Struct
     bytes::Vector{UInt8}
@@ -710,12 +692,13 @@ struct Schema <: FlatBuffers.Table
     pos::Base.Int
 end
 
-Base.propertynames(x::Schema) = (:endianness, :fields, :custom_metadata)
+Base.propertynames(x::Schema) = (:endianness, :fields, :custom_metadata, :features)
 
 function Base.getproperty(x::Schema, field::Symbol)
     if field === :endianness
         o = FlatBuffers.offset(x, 4)
         o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), Endianness.T)
+        return Endianness.Little
     elseif field === :fields
         o = FlatBuffers.offset(x, 6)
         if o != 0
@@ -726,19 +709,28 @@ function Base.getproperty(x::Schema, field::Symbol)
         if o != 0
             return FlatBuffers.Array{KeyValue}(x, o)
         end
+    elseif field === :features
+        o = FlatBuffers.offset(x, 10)
+        if o != 0
+            return FlatBuffers.Array{Feature.T}(x, o)
+        end
     end
     return nothing
 end
 
-schemaStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 3)
+schemaStart(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, 4)
 schemaAddEndianness(b::FlatBuffers.Builder, endianness::Endianness.T) =
     FlatBuffers.prependslot!(b, 0, endianness, 0)
 schemaAddFields(b::FlatBuffers.Builder, fields::FlatBuffers.UOffsetT) =
     FlatBuffers.prependoffsetslot!(b, 1, fields, 0)
 schemaStartFieldsVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 4, numelems, 4)
-schemaAddCustomMetadata(b::FlatBuffers.Builder, custommetadata::FlatBuffers.UOffsetT) =
-    FlatBuffers.prependoffsetslot!(b, 2, custommetadata, 0)
+schemaAddCustomMetadata(b::FlatBuffers.Builder, custom_metadata::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 2, custom_metadata, 0)
 schemaStartCustomMetadataVector(b::FlatBuffers.Builder, numelems) =
     FlatBuffers.startvector!(b, 4, numelems, 4)
+schemaAddFeatures(b::FlatBuffers.Builder, features::FlatBuffers.UOffsetT) =
+    FlatBuffers.prependoffsetslot!(b, 3, features, 0)
+schemaStartFeaturesVector(b::FlatBuffers.Builder, numelems) =
+    FlatBuffers.startvector!(b, 8, numelems, 8)
 schemaEnd(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)
diff --git a/src/metadata/Verifier.jl b/src/metadata/Verifier.jl
new file mode 100644
index 00000000..1686a048
--- /dev/null
+++ b/src/metadata/Verifier.jl
@@ -0,0 +1,608 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# GENERATED by tools/fbsgen.jl from apache/arrow format/{Schema,File,Message}.fbs —
+# do not edit by hand; rerun the generator against the current spec.
+
+# Four functions per table: verifyinline_T proves the table shell and every
+# non-reference field; verifyrefs_T walks the reference graph; verify_T does
+# both; verifyrootstart_T/verifyrootrest_T split the root so a caller can gate
+# the metadata version between the two stages.
+
+function verify_Null(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Null")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_Struct(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Struct")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_List(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "List")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_LargeList(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "LargeList")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_ListView(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "ListView")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_LargeListView(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "LargeListView")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_FixedSizeList(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "FixedSizeList")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vfield(t, 0, 4)
+    return nothing
+end
+
+function verify_Map(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Map")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vbool(t, 0)
+    return nothing
+end
+
+function verify_Union(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Union")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(t, 0, 2, (0x0000000000000000, 0x0000000000000001))
+    _vvector(t, 1, 4, ctx)
+    return nothing
+end
+
+function verify_Int(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Int")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vfield(t, 0, 4)
+    _vbool(t, 1)
+    return nothing
+end
+
+function verify_FloatingPoint(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "FloatingPoint")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(t, 0, 2, (0x0000000000000000, 0x0000000000000001, 0x0000000000000002))
+    return nothing
+end
+
+function verify_Utf8(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Utf8")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_Binary(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Binary")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_LargeUtf8(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "LargeUtf8")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_LargeBinary(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "LargeBinary")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_Utf8View(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Utf8View")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_BinaryView(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "BinaryView")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_FixedSizeBinary(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "FixedSizeBinary")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vfield(t, 0, 4)
+    return nothing
+end
+
+function verify_Bool(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Bool")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_RunEndEncoded(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "RunEndEncoded")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    return nothing
+end
+
+function verify_Decimal(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Decimal")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vfield(t, 0, 4)
+    _vfield(t, 1, 4)
+    _vfield(t, 2, 4)
+    return nothing
+end
+
+function verify_Date(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Date")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(t, 0, 2, (0x0000000000000000, 0x0000000000000001))
+    return nothing
+end
+
+function verify_Time(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Time")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(
+        t,
+        0,
+        2,
+        (0x0000000000000000, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003),
+    )
+    _vfield(t, 1, 4)
+    return nothing
+end
+
+function verify_Timestamp(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Timestamp")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(
+        t,
+        0,
+        2,
+        (0x0000000000000000, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003),
+    )
+    _vstring(t, 1, ctx)
+    return nothing
+end
+
+function verify_Interval(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Interval")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(t, 0, 2, (0x0000000000000000, 0x0000000000000001, 0x0000000000000002))
+    return nothing
+end
+
+function verify_Duration(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Duration")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(
+        t,
+        0,
+        2,
+        (0x0000000000000000, 0x0000000000000001, 0x0000000000000002, 0x0000000000000003),
+    )
+    return nothing
+end
+
+function verify_KeyValue(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "KeyValue")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vstring(t, 0, ctx; required=true, utf8=false)
+    _vstring(t, 1, ctx; required=true, utf8=false)
+    return nothing
+end
+
+function verify_DictionaryEncoding(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "DictionaryEncoding")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vfield(t, 0, 8)
+    _vbool(t, 2)
+    _venum(t, 3, 2, (0x0000000000000000,))
+    p = _vref(t, 1)
+    p === nothing || verify_Int(bytes, p, ctx, depth + 1)
+    return nothing
+end
+
+function verify_Field(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Field")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vbool(t, 1)
+    _vstring(t, 0, ctx)
+    tagp = _vfield(t, 2, 1; required=true)
+    tag = tagp === nothing ? 0x00 : _vu8(bytes, tagp)
+    tag != 0x00 || _vfail("Field.type union tag is required")
+    valp = _vref(t, 3; required=true)
+    if tag == 0x00
+        valp === nothing || _vfail("Field.type union has a value but no tag")
+    elseif tag == 0x01
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Null(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x02
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Int(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x03
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_FloatingPoint(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x04
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Binary(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x05
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Utf8(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x06
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Bool(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x07
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Decimal(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x08
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Date(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x09
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Time(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x0a
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Timestamp(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x0b
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Interval(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x0c
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_List(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x0d
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Struct(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x0e
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Union(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x0f
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_FixedSizeBinary(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x10
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_FixedSizeList(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x11
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Map(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x12
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Duration(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x13
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_LargeBinary(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x14
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_LargeUtf8(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x15
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_LargeList(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x16
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_RunEndEncoded(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x17
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_BinaryView(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x18
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_Utf8View(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x19
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_ListView(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x1a
+        valp === nothing && _vfail("Field.type union has a tag but no value")
+        verify_LargeListView(bytes, valp, ctx, depth + 1)
+    else
+        _vfail("Field.type union has unknown tag")
+    end
+    p = _vref(t, 4)
+    p === nothing || verify_DictionaryEncoding(bytes, p, ctx, depth + 1)
+    _vtablevector(t, 5, verify_Field, ctx, depth)
+    _vtablevector(t, 6, verify_KeyValue, ctx, depth)
+    return nothing
+end
+
+function verify_Schema(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "Schema")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(t, 0, 2, (0x0000000000000000, 0x0000000000000001))
+    _vtablevector(t, 1, verify_Field, ctx, depth; required=true)
+    _vtablevector(t, 2, verify_KeyValue, ctx, depth)
+    _venumvector(
+        t,
+        3,
+        8,
+        (0x0000000000000000, 0x0000000000000001, 0x0000000000000002),
+        ctx,
+        "Schema.features",
+    )
+    return nothing
+end
+
+function verifyrootstart_Footer(bytes::Vector{UInt8}, ctx::VerifyContext)
+    length(bytes) >= 4 || _vfail("missing root offset")
+    root = Int64(_vu32(bytes, Int64(0)))
+    root >= 4 || _vfail("invalid root offset")
+    t = _vtable(bytes, root)
+    _vvisit!(ctx, "Footer")
+    _venum(
+        t,
+        0,
+        2,
+        (
+            0x0000000000000000,
+            0x0000000000000001,
+            0x0000000000000002,
+            0x0000000000000003,
+            0x0000000000000004,
+        ),
+    )
+    return t
+end
+
+function verifyrootrest_Footer(t::VTable, ctx::VerifyContext)
+    bytes = t.bytes
+    depth = 0
+    p = _vref(t, 1; required=true)
+    p === nothing || verify_Schema(bytes, p, ctx, depth + 1)
+    _vvector(t, 2, 24, ctx)
+    _vvector(t, 3, 24, ctx)
+    _vtablevector(t, 4, verify_KeyValue, ctx, depth)
+    return nothing
+end
+
+function verify_BodyCompression(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "BodyCompression")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _venum(t, 0, 1, (0x0000000000000000, 0x0000000000000001))
+    _venum(t, 1, 1, (0x0000000000000000,))
+    return nothing
+end
+
+function verify_RecordBatch(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "RecordBatch")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vfield(t, 0, 8)
+    _vvector(t, 1, 16, ctx)
+    _vvector(t, 2, 16, ctx)
+    p = _vref(t, 3)
+    p === nothing || verify_BodyCompression(bytes, p, ctx, depth + 1)
+    _vvector(t, 4, 8, ctx)
+    return nothing
+end
+
+function verify_DictionaryBatch(
+    bytes::Vector{UInt8},
+    pos::Int64,
+    ctx::VerifyContext,
+    depth::Base.Int,
+)
+    t = _vtable(bytes, pos)
+    _vvisit!(ctx, "DictionaryBatch")
+    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)
+    _vfield(t, 0, 8)
+    _vbool(t, 2)
+    p = _vref(t, 1; required=true)
+    p === nothing || verify_RecordBatch(bytes, p, ctx, depth + 1)
+    return nothing
+end
+
+function verifyrootstart_Message(bytes::Vector{UInt8}, ctx::VerifyContext)
+    length(bytes) >= 4 || _vfail("missing root offset")
+    root = Int64(_vu32(bytes, Int64(0)))
+    root >= 4 || _vfail("invalid root offset")
+    t = _vtable(bytes, root)
+    _vvisit!(ctx, "Message")
+    _venum(
+        t,
+        0,
+        2,
+        (
+            0x0000000000000000,
+            0x0000000000000001,
+            0x0000000000000002,
+            0x0000000000000003,
+            0x0000000000000004,
+        ),
+    )
+    _vfield(t, 3, 8)
+    return t
+end
+
+function verifyrootrest_Message(t::VTable, ctx::VerifyContext)
+    bytes = t.bytes
+    depth = 0
+    tagp = _vfield(t, 1, 1; required=true)
+    tag = tagp === nothing ? 0x00 : _vu8(bytes, tagp)
+    tag != 0x00 || _vfail("Message.header union tag is required")
+    valp = _vref(t, 2; required=true)
+    if tag == 0x00
+        valp === nothing || _vfail("Message.header union has a value but no tag")
+    elseif tag == 0x01
+        valp === nothing && _vfail("Message.header union has a tag but no value")
+        verify_Schema(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x02
+        valp === nothing && _vfail("Message.header union has a tag but no value")
+        verify_DictionaryBatch(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x03
+        valp === nothing && _vfail("Message.header union has a tag but no value")
+        verify_RecordBatch(bytes, valp, ctx, depth + 1)
+    elseif tag == 0x04
+        _vfail("Message.header union member Tensor is outside the generated schemas")
+    elseif tag == 0x05
+        _vfail("Message.header union member SparseTensor is outside the generated schemas")
+    else
+        _vfail("Message.header union has unknown tag")
+    end
+    _vtablevector(t, 4, verify_KeyValue, ctx, depth)
+    return nothing
+end
diff --git a/src/metadata/VerifierRuntime.jl b/src/metadata/VerifierRuntime.jl
new file mode 100644
index 00000000..4c8bfcc3
--- /dev/null
+++ b/src/metadata/VerifierRuntime.jl
@@ -0,0 +1,317 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# FlatBuffers verifier RUNTIME — the schema-independent primitives the
+# GENERATED walkers (Verifier.jl, emitted by tools/fbsgen.jl) call.
+# Hand-maintained, but deliberately schema-blind: every fact about which
+# tables have which fields lives in the generated file, so schema drift can
+# never hide here. Positions are zero-based; loads are assembled
+# byte-by-byte, so they cannot escape the verified byte vector or depend on
+# host alignment.
+#
+# The runtime owns the resource-accounting policy: an object-count ceiling,
+# a nesting-depth ceiling, and a conservative reserve charge for every Julia
+# object the getters may later materialize from this metadata. Failures are
+# module-local exception types; adapters translate them into their own error
+# vocabulary at the wrapper boundary.
+# =============================================================================
+
+using Base.Checked: checked_add, checked_mul, checked_sub
+
+# The verified bytes violate FlatBuffers shape or a declared domain.
+struct VerifyError <: Exception
+    msg::String
+end
+
+# The metadata-directed allocation reserve was exhausted during verification.
+struct VerifyBudgetError <: Exception
+    msg::String
+end
+
+# Verification passed the context's `max_objects` ceiling (`ceiling === :objects`)
+# or its `maxdepth` ceiling (`:depth`), whose value is `limit`.
+struct VerifyLimitError <: Exception
+    ceiling::Symbol
+    limit::Int64
+end
+
+_vfail(msg) = throw(VerifyError(msg))
+@noinline _vlimit(ceiling::Symbol, limit::Integer) = throw(VerifyLimitError(ceiling, limit))
+
+mutable struct VerifyContext
+    objects::Int64
+    max_objects::Int64
+    maxdepth::Base.Int
+    reserved::Int64
+    reserve_limit::Int64
+end
+VerifyContext(max_objects::Int64, maxdepth::Base.Int, reserve_limit::Int64) =
+    VerifyContext(0, max_objects, maxdepth, 0, reserve_limit)
+# Permissive context for callers that only need positional traversal
+# (e.g. test fixtures locating bytes to corrupt), never for real input.
+VerifyContext() = VerifyContext(typemax(Int64), typemax(Base.Int), typemax(Int64))
+
+# Conservative charges for Julia objects and containers whose sizes are
+# directed by verified metadata. String payload bytes are charged on every
+# logical getter occurrence. Message bodies remain zero-copy and have their
+# own body/buffer byte limits at the adapter.
+# Deliberate over-estimates of the Julia object a getter may later
+# materialize per table, per vector, per vector element, and per string. They
+# only need to be upper bounds; a tighter figure would buy nothing.
+const METADATA_OBJECT_RESERVE = Int64(2048)
+const METADATA_VECTOR_BASE_RESERVE = Int64(256)
+const METADATA_VECTOR_ELEMENT_RESERVE = Int64(1024)
+const METADATA_STRING_BASE_RESERVE = Int64(128)
+
+function _vcharge!(ctx::VerifyContext, bytes::Int64, what::AbstractString)
+    bytes >= 0 || _vfail("negative allocation charge for $what")
+    ctx.reserved = try
+        checked_add(ctx.reserved, bytes)
+    catch e
+        e isa OverflowError || rethrow()
+        _vfail("allocation charge overflow for $what")
+    end
+    ctx.reserved <= ctx.reserve_limit || throw(
+        VerifyBudgetError(
+            "metadata-directed allocation budget exceeded while visiting $what",
+        ),
+    )
+    return nothing
+end
+
+# Count one logical table occurrence. Occurrences, not unique byte
+# positions: FlatBuffers may alias a table, while getters and downstream
+# mapping expand it once per parent occurrence. Forward UOffsets make the
+# graph acyclic.
+function _vvisit!(ctx::VerifyContext, what::AbstractString)
+    ctx.objects = try
+        checked_add(ctx.objects, Int64(1))
+    catch e
+        e isa OverflowError || rethrow()
+        _vfail("metadata object count overflow")
+    end
+    ctx.objects <= ctx.max_objects || _vlimit(:objects, ctx.max_objects)
+    _vcharge!(ctx, METADATA_OBJECT_RESERVE, what)
+    return nothing
+end
+
+function _vcount!(ctx::VerifyContext, n::Int64, what::AbstractString)
+    n >= 0 || _vfail("negative metadata object count for $what")
+    ctx.objects = try
+        checked_add(ctx.objects, n)
+    catch e
+        e isa OverflowError || rethrow()
+        _vfail("metadata object count overflow")
+    end
+    ctx.objects <= ctx.max_objects || _vlimit(:objects, ctx.max_objects)
+    return nothing
+end
+
+function _vrange(bytes::Vector{UInt8}, pos::Int64, len::Int64, what::AbstractString)
+    _vinrange(bytes, pos, len) || _vfail("$what is outside metadata")
+    return pos
+end
+
+@inline _vinrange(bytes::Vector{UInt8}, pos::Int64, len::Int64) =
+    pos >= 0 && len >= 0 && len <= length(bytes) && pos <= length(bytes) - len
+
+function _vu(bytes, pos::Int64, width::Base.Int)
+    _vrange(bytes, pos, Int64(width), "scalar")
+    x = UInt64(0)
+    for i = 0:(width - 1)
+        x |= UInt64(bytes[pos + i + 1]) << (8i)
+    end
+    return x
+end
+_vu8(bytes, pos) = UInt8(_vu(bytes, pos, 1))
+_vu16(bytes, pos) = UInt16(_vu(bytes, pos, 2))
+_vu32(bytes, pos) = UInt32(_vu(bytes, pos, 4))
+_vi32(bytes, pos) = reinterpret(Int32, _vu32(bytes, pos))
+_vi64(bytes, pos) = reinterpret(Int64, UInt64(_vu(bytes, pos, 8)))
+
+struct VTable
+    bytes::Vector{UInt8}
+    pos::Int64
+    vpos::Int64
+    vlen::Int64
+    olen::Int64
+end
+
+function _vtable(bytes::Vector{UInt8}, pos::Int64)
+    _vrange(bytes, pos, Int64(4), "table")
+    pos % 4 == 0 || _vfail("table at $pos is misaligned")
+    back = Int64(_vi32(bytes, pos))
+    back != 0 || _vfail("table at $pos has a zero vtable offset")
+    vpos = checked_sub(pos, back)
+    _vrange(bytes, vpos, Int64(4), "vtable header")
+    vpos % 2 == 0 || _vfail("vtable at $vpos is misaligned")
+    vlen = Int64(_vu16(bytes, vpos))
+    olen = Int64(_vu16(bytes, vpos + 2))
+    vlen >= 4 && iseven(vlen) || _vfail("invalid vtable length $vlen")
+    olen >= 4 || _vfail("invalid table object length $olen")
+    _vrange(bytes, vpos, vlen, "vtable")
+    _vrange(bytes, pos, olen, "table object")
+    return VTable(bytes, pos, vpos, vlen, olen)
+end
+
+# vtable layout: [vlen][olen][slot offset]*. Slot i's entry is at vpos+4+2i;
+# an entry past vlen, or a zero entry, means the field is absent and the
+# getter returns its default. A field offset below 4 would overlap the
+# table's own soffset back-pointer.
+function _vfield(t::VTable, slot::Base.Int, width::Base.Int=1; required::Base.Bool=false)
+    ep = t.vpos + 4 + 2slot
+    if ep + 2 > t.vpos + t.vlen
+        required && _vfail("required table slot $slot is absent")
+        return nothing
+    end
+    off = Int64(_vu16(t.bytes, ep))
+    if off == 0
+        required && _vfail("required table slot $slot is absent")
+        return nothing
+    end
+    # Do not bound inline fields by the vtable's declared object length:
+    # builders in the Go lineage (including Arrow.jl 2.x) deduplicate vtables
+    # comparing slot offsets only, so a reused vtable can understate olen for
+    # a wider field (e.g. a DictionaryEncoding id sharing a two-ref KeyValue
+    # vtable). The reference verifier bounds inline fields by the buffer,
+    # which the range check below enforces.
+    off >= 4 || _vfail("table slot $slot overlaps the table header")
+    p = t.pos + off
+    # Build the message only on failure: this runs for every verified slot.
+    _vinrange(t.bytes, p, Int64(width)) || _vfail("table slot $slot is outside metadata")
+    width > 1 && p % min(width, 8) != 0 && _vfail("table slot $slot is misaligned")
+    return p
+end
+
+function _vref(t::VTable, slot::Base.Int; required::Base.Bool=false)
+    p = _vfield(t, slot, 4; required=required)
+    p === nothing && return nothing
+    rel = Int64(_vu32(t.bytes, p))
+    rel > 0 || _vfail("reference slot $slot has a null/backward offset")
+    target = checked_add(p, rel)
+    _vinrange(t.bytes, target, Int64(1)) ||
+        _vfail("reference slot $slot target is outside metadata")
+    return target
+end
+
+function _vbool(t::VTable, slot::Base.Int)
+    p = _vfield(t, slot, 1)
+    p === nothing && return nothing
+    _vu8(t.bytes, p) in (0x00, 0x01) || _vfail("invalid boolean in slot $slot")
+    return nothing
+end
+
+function _venum(t::VTable, slot::Base.Int, width::Base.Int, valid)
+    p = _vfield(t, slot, width)
+    p === nothing && return nothing
+    _vu(t.bytes, p, width) in valid || _vfail("invalid enum in slot $slot")
+    return nothing
+end
+
+function _vstring(
+    t::VTable,
+    slot::Base.Int,
+    ctx::VerifyContext;
+    required::Base.Bool=false,
+    utf8::Base.Bool=true,
+)
+    p = _vref(t, slot; required=required)
+    p === nothing && return nothing
+    p % 4 == 0 || _vfail("string length is misaligned")
+    _vrange(t.bytes, p, Int64(4), "string length")
+    n = Int64(_vu32(t.bytes, p))
+    start = checked_add(p, Int64(4))
+    _vrange(t.bytes, start, checked_add(n, Int64(1)), "string")
+    t.bytes[start + n + 1] == 0 || _vfail("string has no NUL terminator")
+    _vcharge!(ctx, checked_add(METADATA_STRING_BASE_RESERVE, n), "string")
+    if utf8
+        payload = @view t.bytes[(start + 1):(start + n)]
+        isvalid(String, payload) || _vfail("string is not valid UTF-8")
+    end
+    return nothing
+end
+
+function _vvector(
+    t::VTable,
+    slot::Base.Int,
+    elemsize::Base.Int,
+    ctx::VerifyContext=VerifyContext();
+    required::Base.Bool=false,
+)
+    p = _vref(t, slot; required=required)
+    p === nothing && return nothing
+    _vrange(t.bytes, p, Int64(4), "vector length")
+    p % 4 == 0 || _vfail("vector length is misaligned")
+    n = Int64(_vu32(t.bytes, p))
+    n <= ctx.max_objects || _vfail("vector count $n exceeds metadata object limit")
+    _vcount!(ctx, n, "vector entries")
+    start = checked_add(p, Int64(4))
+    _vrange(t.bytes, start, checked_mul(n, Int64(elemsize)), "vector data")
+    n > 0 &&
+        elemsize > 1 &&
+        start % min(elemsize, 8) != 0 &&
+        _vfail("vector data is misaligned")
+    _vcharge!(
+        ctx,
+        checked_add(
+            METADATA_VECTOR_BASE_RESERVE,
+            checked_mul(n, METADATA_VECTOR_ELEMENT_RESERVE),
+        ),
+        "vector",
+    )
+    return start, Base.Int(n)
+end
+
+function _vtablevector(
+    t::VTable,
+    slot::Base.Int,
+    verifyone::F,
+    ctx::VerifyContext,
+    depth::Base.Int;
+    required::Base.Bool=false,
+) where {F}
+    vec = _vvector(t, slot, 4, ctx; required=required)
+    vec === nothing && return 0
+    start, n = vec
+    for i = 0:(n - 1)
+        ep = start + 4i
+        rel = Int64(_vu32(t.bytes, ep))
+        rel > 0 || _vfail("table vector has null entry")
+        verifyone(t.bytes, checked_add(ep, rel), ctx, depth + 1)
+    end
+    return n
+end
+
+# Every element of an enum-typed vector must sit in the declared domain.
+function _venumvector(
+    t::VTable,
+    slot::Base.Int,
+    elemsize::Base.Int,
+    valid,
+    ctx::VerifyContext,
+    what::AbstractString;
+    required::Base.Bool=false,
+)
+    vec = _vvector(t, slot, elemsize, ctx; required=required)
+    vec === nothing && return nothing
+    start, n = vec
+    for i = 0:(n - 1)
+        _vu(t.bytes, start + elemsize * i, elemsize) in valid ||
+            _vfail("$what has an out-of-domain enum value")
+    end
+    return nothing
+end
diff --git a/src/metadata/fbs/File.fbs b/src/metadata/fbs/File.fbs
new file mode 100644
index 00000000..568b5482
--- /dev/null
+++ b/src/metadata/fbs/File.fbs
@@ -0,0 +1,52 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+include "Schema.fbs";
+
+namespace org.apache.arrow.flatbuf;
+
+/// ----------------------------------------------------------------------
+/// Arrow File metadata
+///
+
+table Footer {
+  version: org.apache.arrow.flatbuf.MetadataVersion;
+
+  schema: org.apache.arrow.flatbuf.Schema;
+
+  dictionaries: [ Block ];
+
+  recordBatches: [ Block ];
+
+  /// User-defined metadata
+  custom_metadata: [ KeyValue ];
+}
+
+struct Block {
+
+  /// Index to the start of the RecordBatch (note this is past the Message header)
+  offset: long;
+
+  /// Length of the metadata
+  metaDataLength: int;
+
+  /// Length of the data (this is aligned so there can be a gap between this and
+  /// the metadata).
+  bodyLength: long;
+}
+
+root_type Footer;
diff --git a/src/metadata/fbs/Message.fbs b/src/metadata/fbs/Message.fbs
new file mode 100644
index 00000000..6361a382
--- /dev/null
+++ b/src/metadata/fbs/Message.fbs
@@ -0,0 +1,159 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+include "Schema.fbs";
+include "SparseTensor.fbs";
+include "Tensor.fbs";
+
+namespace org.apache.arrow.flatbuf;
+
+/// ----------------------------------------------------------------------
+/// Data structures for describing a table row batch (a collection of
+/// equal-length Arrow arrays)
+
+/// Metadata about a field at some level of a nested type tree (but not
+/// its children).
+///
+/// For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6], null]`
+/// would have {length: 5, null_count: 2} for its List node, and {length: 6,
+/// null_count: 0} for its Int16 node, as separate FieldNode structs
+struct FieldNode {
+  /// The number of value slots in the Arrow array at this level of a nested
+  /// tree
+  length: long;
+
+  /// The number of observed nulls. Fields with null_count == 0 may choose not
+  /// to write their physical validity bitmap out as a materialized buffer,
+  /// instead setting the length of the bitmap buffer to 0.
+  null_count: long;
+}
+
+enum CompressionType: byte {
+  // LZ4 frame format, for portability, as provided by lz4frame.h or wrappers
+  // thereof. Not to be confused with "raw" (also called "block") format
+  // provided by lz4.h
+  LZ4_FRAME,
+
+  // Zstandard
+  ZSTD
+}
+
+/// Provided for forward compatibility in case we need to support different
+/// strategies for compressing the IPC message body (like whole-body
+/// compression rather than buffer-level) in the future
+enum BodyCompressionMethod: byte {
+  /// Each constituent buffer is first compressed with the indicated
+  /// compressor, and then written with the uncompressed length in the first 8
+  /// bytes as a 64-bit little-endian signed integer followed by the compressed
+  /// buffer bytes (and then padding as required by the protocol). The
+  /// uncompressed length may be set to -1 to indicate that the data that
+  /// follows is not compressed, which can be useful for cases where
+  /// compression does not yield appreciable savings.
+  /// Also, empty buffers can optionally be written out as 0-byte compressed
+  /// buffers, thereby omitting the 8-bytes length header.
+  BUFFER
+}
+
+/// Optional compression for the memory buffers constituting IPC message
+/// bodies. Intended for use with RecordBatch but could be used for other
+/// message types
+table BodyCompression {
+  /// Compressor library.
+  /// For LZ4_FRAME, each compressed buffer must consist of a single frame.
+  codec: CompressionType = LZ4_FRAME;
+
+  /// Indicates the way the record batch body was compressed
+  method: BodyCompressionMethod = BUFFER;
+}
+
+/// A data header describing the shared memory layout of a "record" or "row"
+/// batch. Some systems call this a "row batch" internally and others a "record
+/// batch".
+table RecordBatch {
+  /// number of records / rows. The arrays in the batch should all have this
+  /// length
+  length: long;
+
+  /// Nodes correspond to the pre-ordered flattened logical schema
+  nodes: [FieldNode];
+
+  /// Buffers correspond to the pre-ordered flattened buffer tree
+  ///
+  /// The number of buffers appended to this list depends on the schema. For
+  /// example, most primitive arrays will have 2 buffers, 1 for the validity
+  /// bitmap and 1 for the values. For struct arrays, there will only be a
+  /// single buffer for the validity (nulls) bitmap
+  buffers: [Buffer];
+
+  /// Optional compression of the message body
+  compression: BodyCompression;
+
+  /// Some types such as Utf8View are represented using a variable number of buffers.
+  /// For each such Field in the pre-ordered flattened logical schema, there will be
+  /// an entry in variadicBufferCounts to indicate the number of variadic
+  /// buffers which belong to that Field in the current RecordBatch.
+  ///
+  /// For example, the schema
+  ///     col1: Struct<alpha: Int32, beta: BinaryView, gamma: Float64>
+  ///     col2: Utf8View
+  /// contains two Fields with variadic buffers so variadicBufferCounts will have
+  /// two entries, the first counting the variadic buffers of `col1.beta` and the
+  /// second counting `col2`'s.
+  ///
+  /// This field may be omitted if and only if the schema contains no Fields with
+  /// a variable number of buffers, such as BinaryView and Utf8View.
+  variadicBufferCounts: [long];
+}
+
+/// For sending dictionary encoding information. Any Field can be
+/// dictionary-encoded, but in this case none of its children may be
+/// dictionary-encoded.
+/// There is one vector / column per dictionary, but that vector / column
+/// may be spread across multiple dictionary batches by using the isDelta
+/// flag
+
+table DictionaryBatch {
+  id: long;
+  data: RecordBatch;
+
+  /// If isDelta is true the values in the dictionary are to be appended to a
+  /// dictionary with the indicated id. If isDelta is false this dictionary
+  /// should replace the existing dictionary.
+  isDelta: bool = false;
+}
+
+/// ----------------------------------------------------------------------
+/// The root Message type
+
+/// This union enables us to easily send different message types without
+/// redundant storage, and in the future we can easily add new message types.
+///
+/// Arrow implementations do not need to implement all of the message types,
+/// which may include experimental metadata types. For maximum compatibility,
+/// it is best to send data using RecordBatch
+union MessageHeader {
+  Schema, DictionaryBatch, RecordBatch, Tensor, SparseTensor
+}
+
+table Message {
+  version: org.apache.arrow.flatbuf.MetadataVersion;
+  header: MessageHeader;
+  bodyLength: long;
+  custom_metadata: [ KeyValue ];
+}
+
+root_type Message;
diff --git a/src/metadata/fbs/Schema.fbs b/src/metadata/fbs/Schema.fbs
new file mode 100644
index 00000000..933b7696
--- /dev/null
+++ b/src/metadata/fbs/Schema.fbs
@@ -0,0 +1,571 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License.  You may obtain a copy of the License at
+//
+//   http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied.  See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+/// Logical types, vector layouts, and schemas
+
+/// Format Version History.
+/// Version 1.0 - Forward and backwards compatibility guaranteed.
+/// Version 1.1 - Add Decimal256.
+/// Version 1.2 - Add Interval MONTH_DAY_NANO.
+/// Version 1.3 - Add Run-End Encoded.
+/// Version 1.4 - Add BinaryView, Utf8View, variadicBufferCounts, ListView, and
+/// LargeListView.
+/// Version 1.5 - Add 32-bit and 64-bit as allowed bit widths for Decimal
+
+namespace org.apache.arrow.flatbuf;
+
+enum MetadataVersion:short {
+  /// 0.1.0 (October 2016).
+  V1,
+
+  /// 0.2.0 (February 2017). Non-backwards compatible with V1.
+  V2,
+
+  /// 0.3.0 -> 0.7.1 (May - December 2017). Non-backwards compatible with V2.
+  V3,
+
+  /// >= 0.8.0 (December 2017). Non-backwards compatible with V3.
+  V4,
+
+  /// >= 1.0.0 (July 2020). Backwards compatible with V4 (V5 readers can read V4
+  /// metadata and IPC messages). Implementations are recommended to provide a
+  /// V4 compatibility mode with V5 format changes disabled.
+  ///
+  /// Incompatible changes between V4 and V5:
+  /// - Union buffer layout has changed. In V5, Unions don't have a validity
+  ///   bitmap buffer.
+  V5,
+}
+
+/// Represents Arrow Features that might not have full support
+/// within implementations. This is intended to be used in
+/// two scenarios:
+///  1.  A mechanism for readers of Arrow Streams
+///      and files to understand that the stream or file makes
+///      use of a feature that isn't supported or unknown to
+///      the implementation (and therefore can meet the Arrow
+///      forward compatibility guarantees).
+///  2.  A means of negotiating between a client and server
+///      what features a stream is allowed to use. The enums
+///      values here are intended to represent higher level
+///      features, additional details may be negotiated
+///      with key-value pairs specific to the protocol.
+///
+/// Enums added to this list should be assigned power-of-two values
+/// to facilitate exchanging and comparing bitmaps for supported
+/// features.
+enum Feature : long {
+  /// Needed to make flatbuffers happy.
+  UNUSED = 0,
+  /// The stream makes use of multiple full dictionaries with the
+  /// same ID and assumes clients implement dictionary replacement
+  /// correctly.
+  DICTIONARY_REPLACEMENT = 1,
+  /// The stream makes use of compressed bodies as described
+  /// in Message.fbs.
+  COMPRESSED_BODY = 2
+}
+
+/// These are stored in the flatbuffer in the Type union below
+
+table Null {
+}
+
+/// A Struct_ in the flatbuffer metadata is the same as an Arrow Struct
+/// (according to the physical memory layout). We used Struct_ here as
+/// Struct is a reserved word in Flatbuffers
+table Struct_ {
+}
+
+table List {
+}
+
+/// Same as List, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
+table LargeList {
+}
+
+/// Represents the same logical types that List can, but contains offsets and
+/// sizes allowing for writes in any order and sharing of child values among
+/// list values.
+table ListView {
+}
+
+/// Same as ListView, but with 64-bit offsets and sizes, allowing to represent
+/// extremely large data values.
+table LargeListView {
+}
+
+table FixedSizeList {
+  /// Number of list items per value
+  listSize: int;
+}
+
+/// A Map is a logical nested type that is represented as
+///
+/// List<entries: Struct<key: K, value: V>>
+///
+/// In this layout, the keys and values are each respectively contiguous. We do
+/// not constrain the key and value types, so the application is responsible
+/// for ensuring that the keys are hashable and unique. Whether the keys are sorted
+/// may be set in the metadata for this field.
+///
+/// In a field with Map type, the field has a child Struct field, which then
+/// has two children: the key type and the value type. The names of the
+/// child fields may be respectively "entries", "key", and "value", but this is
+/// not enforced.
+///
+/// Map
+/// ```text
+///   - child[0] entries: Struct
+///     - child[0] key: K
+///     - child[1] value: V
+/// ```
+/// Neither the "entries" field nor the "key" field may be nullable.
+///
+/// The metadata is structured so that Arrow systems without special handling
+/// for Map can make Map an alias for List. The "layout" attribute for the Map
+/// field must have the same contents as a List.
+table Map {
+  /// Set to true if the keys within each value are sorted
+  keysSorted: bool;
+}
+
+enum UnionMode:short { Sparse, Dense }
+
+/// A union is a complex type with children in Field
+/// By default ids in the type vector refer to the offsets in the children
+/// optionally typeIds provides an indirection between the child offset and the type id
+/// for each child `typeIds[offset]` is the id used in the type vector
+table Union {
+  mode: UnionMode;
+  typeIds: [ int ]; // optional, describes typeid of each child.
+}
+
+table Int {
+  bitWidth: int; // restricted to 8, 16, 32, and 64 in v1
+  is_signed: bool;
+}
+
+enum Precision:short {HALF, SINGLE, DOUBLE}
+
+table FloatingPoint {
+  precision: Precision;
+}
+
+/// Unicode with UTF-8 encoding
+table Utf8 {
+}
+
+/// Opaque binary data
+table Binary {
+}
+
+/// Same as Utf8, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
+table LargeUtf8 {
+}
+
+/// Same as Binary, but with 64-bit offsets, allowing to represent
+/// extremely large data values.
+table LargeBinary {
+}
+
+/// Logically the same as Utf8, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+table Utf8View {
+}
+
+/// Logically the same as Binary, but the internal representation uses a view
+/// struct that contains the string length and either the string's entire data
+/// inline (for small strings) or an inlined prefix, an index of another buffer,
+/// and an offset pointing to a slice in that buffer (for non-small strings).
+///
+/// Since it uses a variable number of data buffers, each Field with this type
+/// must have a corresponding entry in `variadicBufferCounts`.
+table BinaryView {
+}
+
+
+table FixedSizeBinary {
+  /// Number of bytes per value
+  byteWidth: int;
+}
+
+table Bool {
+}
+
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in 
+/// each corresponding index in the values child array ends.
+/// Like list/struct types, the value array can be of any type.
+table RunEndEncoded {
+}
+
+/// Exact decimal value represented as an integer value in two's
+/// complement. Currently 32-bit (4-byte), 64-bit (8-byte), 
+/// 128-bit (16-byte) and 256-bit (32-byte) integers are used.
+/// The representation uses the endianness indicated in the Schema.
+table Decimal {
+  /// Total number of decimal digits
+  precision: int;
+
+  /// Number of digits after the decimal point "."
+  scale: int;
+
+  /// Number of bits per value. The accepted widths are 32, 64, 128 and 256.
+  /// We use bitWidth for consistency with Int::bitWidth.
+  bitWidth: int = 128;
+}
+
+enum DateUnit: short {
+  DAY,
+  MILLISECOND
+}
+
+/// Date is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
+///
+/// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
+///   leap seconds), where the values are evenly divisible by 86400000
+/// * Days (32 bits) since the UNIX epoch
+table Date {
+  unit: DateUnit = MILLISECOND;
+}
+
+enum TimeUnit: short { SECOND, MILLISECOND, MICROSECOND, NANOSECOND }
+
+/// Time is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since midnight, stored in either of four units: seconds,
+/// milliseconds, microseconds or nanoseconds.
+///
+/// The integer `bitWidth` depends on the `unit` and must be one of the following:
+/// * SECOND and MILLISECOND: 32 bits
+/// * MICROSECOND and NANOSECOND: 64 bits
+///
+/// The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds
+/// (exclusive), adjusted for the time unit (for example, up to 86400000
+/// exclusive for the MILLISECOND unit).
+/// This definition doesn't allow for leap seconds. Time values from
+/// measurements with leap seconds will need to be corrected when ingesting
+/// into Arrow (for example by replacing the value 86400 with 86399).
+table Time {
+  unit: TimeUnit = MILLISECOND;
+  bitWidth: int = 32;
+}
+
+/// Timestamp is a 64-bit signed integer representing an elapsed time since a
+/// fixed epoch, stored in either of four units: seconds, milliseconds,
+/// microseconds or nanoseconds, and is optionally annotated with a timezone.
+///
+/// Timestamp values do not include any leap seconds (in other words, all
+/// days are considered 86400 seconds long).
+///
+/// Timestamps with a non-empty timezone
+/// ------------------------------------
+///
+/// If a Timestamp column has a non-empty timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
+/// (the Unix epoch), regardless of the Timestamp's own timezone.
+///
+/// Therefore, timestamp values with a non-empty timezone correspond to
+/// physical points in time together with some additional information about
+/// how the data was obtained and/or how to display it (the timezone).
+///
+///   For example, the timestamp value 0 with the timezone string "Europe/Paris"
+///   corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
+///   application may prefer to display it as "January 1st 1970, 01h00" in
+///   the Europe/Paris timezone (which is the same physical point in time).
+///
+/// One consequence is that timestamp values with a non-empty timezone
+/// can be compared and ordered directly, since they all share the same
+/// well-known point of reference (the Unix epoch).
+///
+/// Timestamps with an unset / empty timezone
+/// -----------------------------------------
+///
+/// If a Timestamp column has no timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
+///
+/// Therefore, timestamp values without a timezone cannot be meaningfully
+/// interpreted as physical points in time, but only as calendar / clock
+/// indications ("wall clock time") in an unspecified timezone.
+///
+///   For example, the timestamp value 0 with an empty timezone string
+///   corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
+///   is not enough information to interpret it as a well-defined physical
+///   point in time.
+///
+/// One consequence is that timestamp values without a timezone cannot
+/// be reliably compared or ordered, since they may have different points of
+/// reference.  In particular, it is *not* possible to interpret an unset
+/// or empty timezone as the same as "UTC".
+///
+/// Conversion between timezones
+/// ----------------------------
+///
+/// If a Timestamp column has a non-empty timezone, changing the timezone
+/// to a different non-empty value is a metadata-only operation:
+/// the timestamp values need not change as their point of reference remains
+/// the same (the Unix epoch).
+///
+/// However, if a Timestamp column has no timezone value, changing it to a
+/// non-empty value requires to think about the desired semantics.
+/// One possibility is to assume that the original timestamp values are
+/// relative to the epoch of the timezone being set; timestamp values should
+/// then adjusted to the Unix epoch (for example, changing the timezone from
+/// empty to "Europe/Paris" would require converting the timestamp values
+/// from "Europe/Paris" to "UTC", which seems counter-intuitive but is
+/// nevertheless correct).
+///
+/// Guidelines for encoding data from external libraries
+/// ----------------------------------------------------
+///
+/// Date & time libraries often have multiple different data types for temporal
+/// data. In order to ease interoperability between different implementations the
+/// Arrow project has some recommendations for encoding these types into a Timestamp
+/// column.
+///
+/// An "instant" represents a physical point in time that has no relevant timezone
+/// (for example, astronomical data). To encode an instant, use a Timestamp with
+/// the timezone string set to "UTC", and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+/// A "zoned date-time" represents a physical point in time annotated with an
+/// informative timezone (for example, the timezone in which the data was
+/// recorded).  To encode a zoned date-time, use a Timestamp with the timezone
+/// string set to the name of the timezone, and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+///  (There is some ambiguity between an instant and a zoned date-time with the
+///   UTC timezone.  Both of these are stored the same in Arrow.  Typically,
+///   this distinction does not matter.  If it does, then an application should
+///   use custom metadata or an extension type to distinguish between the two cases.)
+///
+/// An "offset date-time" represents a physical point in time combined with an
+/// explicit offset from UTC.  To encode an offset date-time, use a Timestamp
+/// with the timezone string set to the numeric timezone offset string
+/// (e.g. "+03:00"), and make sure the Timestamp values are relative to
+/// the UTC epoch (January 1st 1970, midnight).
+///
+/// A "naive date-time" (also called "local date-time" in some libraries)
+/// represents a wall clock time combined with a calendar date, but with
+/// no indication of how to map this information to a physical point in time.
+/// Naive date-times must be handled with care because of this missing
+/// information, and also because daylight saving time (DST) may make
+/// some values ambiguous or nonexistent. A naive date-time may be
+/// stored as a struct with Date and Time fields. However, it may also be
+/// encoded into a Timestamp column with an empty timezone. The timestamp
+/// values should be computed "as if" the timezone of the date-time values
+/// was UTC; for example, the naive date-time "January 1st 1970, 00h00" would
+/// be encoded as timestamp value 0.
+table Timestamp {
+  unit: TimeUnit;
+
+  /// The timezone is an optional string indicating the name of a timezone,
+  /// one of:
+  ///
+  /// * As used in the Olson timezone database (the "tz database" or
+  ///   "tzdata"), such as "America/New_York".
+  /// * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
+  ///   such as "+07:30".
+  ///
+  /// Whether a timezone string is present indicates different semantics about
+  /// the data (see above).
+  timezone: string;
+}
+
+enum IntervalUnit: short { YEAR_MONTH, DAY_TIME, MONTH_DAY_NANO}
+// A "calendar" interval which models types that don't necessarily
+// have a precise duration without the context of a base timestamp (e.g.
+// days can differ in length during day light savings time transitions).
+// All integers in the types below are stored in the endianness indicated
+// by the schema.
+//
+// YEAR_MONTH - Indicates the number of elapsed whole months, stored as
+//   4-byte signed integers.
+// DAY_TIME - Indicates the number of elapsed days and milliseconds (no leap seconds),
+//   stored as 2 contiguous 32-bit signed integers (8-bytes in total). Support
+//   of this IntervalUnit is not required for full arrow compatibility.
+// MONTH_DAY_NANO - A triple of the number of elapsed months, days, and nanoseconds.
+//  The values are stored contiguously in 16-byte blocks. Months and days are
+//  encoded as 32-bit signed integers and nanoseconds is encoded as a 64-bit
+//  signed integer. Nanoseconds does not allow for leap seconds. Each field is
+//  independent (e.g. there is no constraint that nanoseconds have the same
+//  sign as days or that the quantity of nanoseconds represents less than a
+//  day's worth of time).
+table Interval {
+  unit: IntervalUnit;
+}
+
+// An absolute length of time unrelated to any calendar artifacts.
+//
+// For the purposes of Arrow Implementations, adding this value to a Timestamp
+// ("t1") naively (i.e. simply summing the two numbers) is acceptable even
+// though in some cases the resulting Timestamp (t2) would not account for
+// leap-seconds during the elapsed time between "t1" and "t2".  Similarly,
+// representing the difference between two Unix timestamps is acceptable, but
+// would yield a value that is possibly a few seconds off from the true elapsed
+// time.
+//
+//  The resolution defaults to millisecond, but can be any of the other
+//  supported TimeUnit values as with Timestamp and Time types.  This type is
+//  always represented as an 8-byte integer.
+table Duration {
+  unit: TimeUnit = MILLISECOND;
+}
+
+/// ----------------------------------------------------------------------
+/// Top-level Type value, enabling extensible type-specific metadata. We can
+/// add new logical types to Type without breaking backwards compatibility
+
+union Type {
+  Null,
+  Int,
+  FloatingPoint,
+  Binary,
+  Utf8,
+  Bool,
+  Decimal,
+  Date,
+  Time,
+  Timestamp,
+  Interval,
+  List,
+  Struct_,
+  Union,
+  FixedSizeBinary,
+  FixedSizeList,
+  Map,
+  Duration,
+  LargeBinary,
+  LargeUtf8,
+  LargeList,
+  RunEndEncoded,
+  BinaryView,
+  Utf8View,
+  ListView,
+  LargeListView,
+}
+
+/// ----------------------------------------------------------------------
+/// user defined key value pairs to add custom metadata to arrow
+/// key namespacing is the responsibility of the user
+
+table KeyValue {
+  key: string;
+  value: string;
+}
+
+/// ----------------------------------------------------------------------
+/// Dictionary encoding metadata
+/// Maintained for forwards compatibility, in the future
+/// Dictionaries might be explicit maps between integers and values
+/// allowing for non-contiguous index values
+enum DictionaryKind : short { DenseArray }
+table DictionaryEncoding {
+  /// The known dictionary id in the application where this data is used. In
+  /// the file or streaming formats, the dictionary ids are found in the
+  /// DictionaryBatch messages
+  id: long;
+
+  /// The dictionary indices are constrained to be non-negative integers. If
+  /// this field is null, the indices must be signed int32. To maximize
+  /// cross-language compatibility and performance, implementations are
+  /// recommended to prefer signed integer types over unsigned integer types
+  /// and to avoid uint64 indices unless they are required by an application.
+  indexType: Int;
+
+  /// By default, dictionaries are not ordered, or the order does not have
+  /// semantic meaning. In some statistical applications, dictionary-encoding
+  /// is used to represent ordered categorical data, and we provide a way to
+  /// preserve that metadata here
+  isOrdered: bool;
+
+  dictionaryKind: DictionaryKind;
+}
+
+/// ----------------------------------------------------------------------
+/// A field represents a named column in a record / row batch or child of a
+/// nested type.
+
+table Field {
+  /// Name is not required (e.g., in a List)
+  name: string;
+
+  /// Whether or not this field can contain nulls. Should be true in general.
+  nullable: bool;
+
+  /// This is the type of the decoded value if the field is dictionary encoded.
+  type: Type;
+
+  /// Present only if the field is dictionary encoded.
+  dictionary: DictionaryEncoding;
+
+  /// children apply only to nested data types like Struct, List and Union. For
+  /// primitive types children will have length 0.
+  children: [ Field ];
+
+  /// User-defined metadata
+  custom_metadata: [ KeyValue ];
+}
+
+/// ----------------------------------------------------------------------
+/// Endianness of the platform producing the data
+
+enum Endianness:short { Little, Big }
+
+/// ----------------------------------------------------------------------
+/// A Buffer represents a single contiguous memory segment
+struct Buffer {
+  /// The relative offset into the shared memory page where the bytes for this
+  /// buffer starts
+  offset: long;
+
+  /// The absolute length (in bytes) of the memory buffer. The memory is found
+  /// from offset (inclusive) to offset + length (non-inclusive). When building
+  /// messages using the encapsulated IPC message, padding bytes may be written
+  /// after a buffer, but such padding bytes do not need to be accounted for in
+  /// the size here.
+  length: long;
+}
+
+/// ----------------------------------------------------------------------
+/// A Schema describes the columns in a row batch
+
+table Schema {
+
+  /// endianness of the buffer
+  /// it is Little Endian by default
+  /// if endianness doesn't match the underlying system then the vectors need to be converted
+  endianness: Endianness=Little;
+
+  fields: [Field];
+  // User-defined metadata
+  custom_metadata: [ KeyValue ];
+
+  /// Features used in the stream/file.
+  features : [ Feature ];
+}
+
+root_type Schema;
diff --git a/src/precompile.jl b/src/precompile.jl
new file mode 100644
index 00000000..44f07007
--- /dev/null
+++ b/src/precompile.jl
@@ -0,0 +1,190 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Precompile workload: run the common write/read/scan shapes once during
+# package precompilation so first use does not pay their compilation cost.
+# Everything here is deterministic and in memory, except one temporary file
+# that is read by path; no network.
+# This file belongs to the top-level Arrow package only; the JuliaC trim gate
+# includes src/ArrowCore.jl standalone and must not see PrecompileTools.
+import PrecompileTools
+
+PrecompileTools.@setup_workload begin
+    columns = (
+        ints=Int64[1, 2, 3],
+        floats=Float64[1.0, 2.5, 3.5],
+        strings=["a", "bb", "ccc"],
+        bools=[true, false, true],
+        maybe=Union{Missing,Int64}[1, missing, 3],
+        maybefloats=Union{Missing,Float64}[1.5, missing, 3.5],
+        maybestrings=Union{Missing,String}["a", missing, "ccc"],
+        maybesmall=Union{Missing,Int32}[1, missing, 3],
+        maybebools=Union{Missing,Bool}[true, missing, false],
+        maybedates=[Dates.Date(2020, 1, 1), missing, Dates.Date(2020, 1, 3)],
+        lists=[Int64[1, 2], Int64[], Int64[3]],
+        dates=[Dates.Date(2020, 1, 1), Dates.Date(2020, 1, 2), Dates.Date(2020, 1, 3)],
+        stamps=[
+            Dates.DateTime(2020, 1, 1, 12),
+            Dates.DateTime(2020, 1, 2, 12),
+            Dates.DateTime(2020, 1, 3, 12),
+        ],
+        pooled=DictEncode(["lo", "hi", "lo"]),
+    )
+    # pyarrow and Polars declare every field nullable: each flat width both
+    # ways, and the common temporal types (timestamps naive and in UTC,
+    # durations, dates, times), so a first read of their files finds its
+    # column views compiled.
+    widths = (
+        Int8,
+        Int16,
+        Int32,
+        Int64,
+        UInt8,
+        UInt16,
+        UInt32,
+        UInt64,
+        Float16,
+        Float32,
+        Float64,
+        Bool,
+    )
+    units = (Dates.Second, Dates.Millisecond, Dates.Microsecond, Dates.Nanosecond)
+    flat = (;
+        (Symbol(:n, nameof(T)) => Union{Missing,T}[one(T), missing] for T in widths)...,
+        (Symbol(:p, nameof(T)) => T[one(T), zero(T)] for T in widths)...,
+        nstring=Union{Missing,String}["a", missing],
+        ndate=Union{Missing,Dates.Date}[Dates.Date(2020, 1, 1), missing],
+        ndatetime=Union{Missing,Dates.DateTime}[Dates.DateTime(2020, 1, 1), missing],
+        ntime=Union{Missing,Dates.Time}[Dates.Time(12), missing],
+        (
+            Symbol(:n, nameof(P)) => Union{Missing,Durations.Timestamp{P}}[
+                Durations.Timestamp{P}(2020, 1, 1),
+                missing,
+            ] for P in units
+        )...,
+        (
+            Symbol(:u, nameof(P)) => Union{Missing,Durations.ZonedTimestamp{P,:UTC}}[
+                Durations.ZonedTimestamp{P,:UTC}(2020, 1, 1),
+                missing,
+            ] for P in units
+        )...,
+        (Symbol(:d, nameof(P)) => Union{Missing,P}[P(1), missing] for P in units)...,
+        nduration=Union{Missing,Durations.Duration}[Durations.Duration(1, 2, 3), missing],
+        # Nested columns: their per-batch builders compile once for every row
+        # type, so these also leave a first nested read only its row loops.
+        nlist=Union{Missing,Vector{Int64}}[[1], missing],
+        nfloats=Union{Missing,Vector{Float64}}[[1.0], missing],
+        nstrings=Union{Missing,Vector{String}}[["a"], missing],
+        nmap=Union{Missing,Dict{String,Int64}}[Dict("a" => 1), missing],
+        nstruct=Union{Missing,@NamedTuple{a::Int64,b::String}}[(a=1, b="x"), missing],
+        nunion=Union{Int64,String}[1, "a"],
+    )
+    # Units pyarrow writes and this writer does not (it writes dates in days and
+    # times in nanoseconds): date64, time32 in s and ms, and time64 in us,
+    # nullable, in two batches.
+    rawtypes = (
+        AC.DateType(AC.MILLISECOND_DATE),
+        AC.TimeType(AC.SECOND, 32),
+        AC.TimeType(AC.MILLISECOND, 32),
+        AC.TimeType(AC.MICROSECOND, 64),
+    )
+    rawschema = AC.Schema(
+        AC.Field[AC.Field("t$i", t; nullable=true) for (i, t) in enumerate(rawtypes)],
+    )
+    rawdata(t) = AC.ArrayData(
+        t,
+        2,
+        [
+            AC._bitmapbuffer([true, false]),
+            AC._databuffer(t isa AC.TimeType && t.bits == 32 ? Int32[1, 0] : Int64[1, 0]),
+        ];
+        nullcount=1,
+    )
+    rawbatch = AC.RecordBatch(rawschema, AC.ArrayData[rawdata(t) for t in rawtypes])
+    rawbytes = writefile(rawschema, [rawbatch, rawbatch])
+    # Reading a column: iterating, indexing, and copying it.
+    function readall(tbl)
+        for name in Tables.columnnames(tbl)
+            column = Tables.getcolumn(tbl, name)
+            foreach(identity, column)
+            isempty(column) || (column[begin]; column[end])
+            copy(column)
+        end
+        return nothing
+    end
+    # A table to a C data consumer and back, as one record batch and as a
+    # stream, as a PythonCall user hands one to pyarrow and reads one back.
+    function cdataroundtrip(tbl)
+        schemaptr, arrayptr = to_c_data(tbl)
+        readall(Table(schemaptr, arrayptr))
+        stream = Ref{CArrowArrayStream}()
+        GC.@preserve stream begin
+            streamptr = Base.unsafe_convert(Ptr{CArrowArrayStream}, stream)
+            export_stream!(streamptr, tbl)
+            readall(Table(streamptr))
+        end
+        return nothing
+    end
+    PrecompileTools.@compile_workload begin
+        # The flat table goes out as two record batches, so its columns chain.
+        # Reads of the file format, what `Arrow.Table(path)` reads.
+        for table in (columns, Tables.partitioner((flat, flat)))
+            io = IOBuffer()
+            write(io, table; file=true)
+            flatbytes = take!(seekstart(io))
+            tbl = Table(flatbytes)
+            readall(tbl)
+            table === columns && continue
+            # Writing what was read, column by column (a DataFrame of a read
+            # table hands the writer these columns).
+            write(IOBuffer(), Tables.columntable(tbl))
+            # A timestamp filter runs on stored integers.
+            stamp = Tables.colcmp(>=, Tables.col(:nMicrosecond), Dates.DateTime(2020))
+            Table(flatbytes; scan=Tables.Scan(filter=stamp))
+        end
+        readall(Table(rawbytes))
+        mktempdir() do dir
+            path = joinpath(dir, "flat.arrow")
+            write(path, Tables.partitioner((flat, flat)))
+            readall(Table(path))
+        end
+        io = IOBuffer()
+        write(io, columns; file=true)
+        bytes = take!(seekstart(io))
+        tbl = Table(bytes)
+        Tables.columntable(tbl)
+        Table(
+            bytes;
+            scan=Tables.Scan(
+                select=(:ints, :floats),
+                filter=Tables.col(:ints) > 1,
+                limit=2,
+            ),
+        )
+        # Writing what was read: a rewrite, and the read columns as a table,
+        # also when each column is read from several batches.
+        write(IOBuffer(), tbl)
+        write(IOBuffer(), Tables.columntable(tbl))
+        io = IOBuffer()
+        write(io, columns; batchsize=2, file=true)
+        write(IOBuffer(), Tables.columntable(Table(take!(seekstart(io)))); batchsize=2)
+        cdataroundtrip(columns)
+        cdataroundtrip(flat)
+        # Collected and reaped, so the image saves no export.
+        GC.gc(true)
+        _reap!()
+    end
+end
diff --git a/src/scan.jl b/src/scan.jl
new file mode 100644
index 00000000..933e709d
--- /dev/null
+++ b/src/scan.jl
@@ -0,0 +1,2502 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# Tables.Scan pushdown: one planner for IPC files, whose bytes are a region in
+# memory or a byte-range source (`SourceFile` over an `AbstractArrowSource`),
+# and one executor for every source. Design notes:
+# docs/dev/DESIGN-scan-ranges-trim.md.
+#
+# The request is resolved once (`_ScanPlan`); the executor (`_runscan`) then
+# consumes the bound scan exactly, batch by batch:
+#
+#   * the decode set is (selected ∪ filter-referenced) columns; everything
+#     else is SKIPPED by `skipfield!`, a registry walk that consumes the
+#     node/buffer accounting (all buffer-table invariants still checked)
+#     without slicing, decompressing, validating, or materializing anything,
+#     and over a byte-range source no body range is planned for it;
+#   * without a filter `limit`/`offset` are metadata arithmetic:
+#     `RecordBatch.length` is wire metadata, so batches outside the window
+#     are never decoded; a filter is evaluated per batch on public values,
+#     reads the other selected columns only for batches with a qualifying
+#     row, and composes the window over the qualifying rows;
+#   * the returned table holds the selected columns' kept rows under their
+#     output names, in selection order, with type overrides converted.
+# =============================================================================
+
+# ---------------------------------------------------------------------------
+# skipfield!: the decode walk minus the decode
+# ---------------------------------------------------------------------------
+
+"""
+Advance the cursor past one field's node and buffers — the exact traversal
+`decodefield` performs, with every buffer-table invariant still enforced
+(`_buffermeta!`), but no body access: nothing is sliced, decompressed,
+validated, or kept. Over a ranged source, no body range is planned for
+the skipped bytes; tail reads and coalescing may still over-read them.
+"""
+function skipfield!(f::Field, c::DecodeCursor)
+    t = f.type
+    takenode!(c)
+    spec = AC.layoutspec_of(t)
+    for _ in spec.buffers
+        skipbuffer!(c)
+    end
+    if spec.variadic
+        for _ = 1:takevariadic!(c)
+            skipbuffer!(c)
+        end
+    end
+    t isa DictionaryType && return nothing
+    nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+    for i = 1:nchildren
+        skipfield!(f.children[i], c)
+    end
+    return nothing
+end
+
+"FieldNode entries consumed by one field subtree."
+function _fieldnodespan(f::Field)
+    f.type isa DictionaryType && return 1
+    spec = AC.layoutspec_of(f.type)
+    nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+    return 1 + sum(_fieldnodespan(f.children[i]) for i = 1:nchildren; init=0)
+end
+
+"""
+Buffers consumed by one field subtree — the planner's registry arithmetic.
+View fields consume their declared variadic count on top of the fixed
+registry pair, so the walk carries the batch's variadic-count cursor in
+depth-first order (the same order the decode cursor consumes it).
+"""
+function _bufferspan(f::Field, variadics::AbstractVector{Int64}, varidx::Base.RefValue{Int})
+    spec = AC.layoutspec_of(f.type)
+    n = Int64(length(spec.buffers))
+    if spec.variadic
+        varidx[] <= length(variadics) || throw(
+            ValidationError(
+                "metadata declares fewer variadic buffer counts than the schema requires",
+            ),
+        )
+        vc = variadics[varidx[]]
+        varidx[] += 1
+        vc >= 0 || throw(ValidationError("variadic buffer count $vc is invalid"))
+        n = _checkedadd(n, vc, "buffer span")
+    end
+    f.type isa DictionaryType && return n
+    nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+    for i = 1:nchildren
+        n = _checkedadd(n, _bufferspan(f.children[i], variadics, varidx), "buffer span")
+    end
+    return n
+end
+
+"""
+Validate the metadata needed before a RecordBatch length may drive a scan
+window or a buffer table may drive a range fetch. This is the metadata-only
+half of the decode cursor: exact node/buffer counts, every node invariant,
+top-level row-count agreement, and every buffer's geometry.
+"""
+function _recordbatchmeta(
+    header::Meta.RecordBatch,
+    fields,
+    limits::Limits,
+    bodylen::Int64,
+    variadics::AbstractVector{Int64}=variadiccounts(header),
+)
+    rblen = something(header.length, Int64(0))
+    rblen >= 0 || throw(ValidationError("record batch length $rblen is negative"))
+    rblen <= limits.max_array_length || _limiterror(
+        "record batch length $rblen",
+        "max_array_length",
+        limits.max_array_length,
+    )
+
+    nodes = something(header.nodes, Meta.FieldNode[])
+    expectednodes = sum(_fieldnodespan(f) for f in fields; init=0)
+    length(nodes) == expectednodes ||
+        throw(ValidationError("field-node count does not match the schema"))
+    nodeidx = 1
+    for f in fields
+        node = nodes[nodeidx]
+        node.length == rblen || throw(
+            ValidationError("RecordBatch length does not match top-level field nodes"),
+        )
+        nodeidx += _fieldnodespan(f)
+    end
+    for node in nodes
+        node.length >= 0 ||
+            throw(ValidationError("field-node length $(node.length) is negative"))
+        node.length <= limits.max_array_length || _limiterror(
+            "field-node length $(node.length)",
+            "max_array_length",
+            limits.max_array_length,
+        )
+        0 <= node.null_count <= node.length ||
+            throw(ValidationError("invalid field-node null count $(node.null_count)"))
+    end
+
+    buffers = something(header.buffers, Meta.Buffer[])
+    varidx = Ref(1)
+    expectedbuffers = Int64(0)
+    for f in fields
+        expectedbuffers = _checkedadd(
+            expectedbuffers,
+            _bufferspan(f, variadics, varidx),
+            "record-batch buffer span",
+        )
+    end
+    varidx[] == length(variadics) + 1 ||
+        throw(ValidationError("unconsumed variadic buffer counts: schema/batch mismatch"))
+    length(buffers) == expectedbuffers ||
+        throw(ValidationError("buffer count does not match the schema"))
+    last_nonempty_end = Int64(0)
+    for b in buffers
+        offset = Int64(b.offset)
+        len = Int64(b.length)
+        offset >= 0 || throw(ValidationError("negative batch buffer offset $offset"))
+        offset % 8 == 0 ||
+            throw(ValidationError("batch buffer offset $offset is not 8-byte aligned"))
+        len >= 0 || throw(ValidationError("batch buffer length $len is negative"))
+        len <= limits.max_buffer_bytes || _limiterror(
+            "batch buffer length $len",
+            "max_buffer_bytes",
+            limits.max_buffer_bytes,
+        )
+        bufferend = _checkedadd(offset, len, "batch buffer end")
+        bufferend <= bodylen ||
+            throw(ValidationError("batch buffer [$offset, $len] escapes its message body"))
+        if len > 0
+            offset >= last_nonempty_end ||
+                throw(ValidationError("batch buffers overlap or move backwards"))
+            last_nonempty_end = bufferend
+        end
+    end
+    return rblen
+end
+
+function _planminbytes(role, spec, node, len::Int64)
+    if role == AC.VALIDITY
+        len == 0 && node.null_count == 0 && return Int64(0)
+        return node.length ÷ 8 + (node.length % 8 == 0 ? 0 : 1)
+    elseif role == AC.DATA
+        spec.fixedwidth > 0 && return _checkedmul(
+            node.length,
+            Int64(spec.fixedwidth),
+            "planned data-buffer size",
+        )
+        if spec.fixedwidth == -1
+            return node.length ÷ 8 + (node.length % 8 == 0 ? 0 : 1)
+        end
+        return Int64(0)
+    elseif role == AC.OFFSETS
+        count = _checkedadd(node.length, Int64(1), "planned offset count")
+        return _checkedmul(count, Int64(spec.offsetwidth), "planned offsets-buffer size")
+    elseif role == AC.ELEMENT_OFFSETS || role == AC.SIZES
+        return _checkedmul(
+            node.length,
+            Int64(spec.offsetwidth),
+            "planned element-buffer size",
+        )
+    elseif role == AC.TYPE_IDS
+        return node.length
+    elseif role == AC.VIEWS
+        return _checkedmul(node.length, Int64(16), "planned views-buffer size")
+    end
+    return Int64(0)
+end
+
+function _validateplannedfield!(f::Field, c::DecodeCursor, codec::Int8)
+    node = takenode!(c)
+    t = f.type
+    if t isa NullType
+        node.null_count == node.length ||
+            throw(ValidationError("Null field-node null count must equal its length"))
+    elseif t isa UnionType
+        node.null_count == 0 ||
+            throw(ValidationError("Union field-node null count must be zero"))
+    end
+    # Field.nullable is advisory (enforced only by the opt-in validate_full
+    # tier), so a planned scan makes no nullability judgment here — the same
+    # contract the whole-file path applies.
+    spec = AC.layoutspec_of(f.type)
+    for role in spec.buffers
+        _, len = _buffermeta!(c)
+        if codec == CODEC_NONE || len == 0
+            need = _planminbytes(role, spec, node, len)
+            len >= need || throw(
+                ValidationError(
+                    "planned buffer length $len is smaller than required $need",
+                ),
+            )
+        else
+            len >= 8 || throw(
+                ValidationError("compressed buffer of $len bytes lacks its length prefix"),
+            )
+            need = _planminbytes(role, spec, node, Int64(0))
+            need > 0 &&
+                len == 8 &&
+                throw(
+                    ValidationError(
+                        "compressed planned buffer requires a nonempty payload",
+                    ),
+                )
+        end
+    end
+    if spec.variadic
+        # Variadic view-data buffers have no metadata-derivable minimum
+        # (views reference them arbitrarily); geometry and, under
+        # compression, the prefix rule are the plannable invariants.
+        for _ = 1:takevariadic!(c)
+            _, len = _buffermeta!(c)
+            codec == CODEC_NONE ||
+                len == 0 ||
+                len >= 8 ||
+                throw(
+                    ValidationError(
+                        "compressed buffer of $len bytes lacks its length prefix",
+                    ),
+                )
+        end
+    end
+    f.type isa DictionaryType && return node.length
+    nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+    fslextent =
+        t isa FixedSizeListType ?
+        _checkedmul(node.length, Int64(t.listsize), "fixed-size-list child length") :
+        Int64(0)
+    firstchildlen = Int64(-1)
+    for i = 1:nchildren
+        childlen = _validateplannedfield!(f.children[i], c, codec)
+        i == 1 && (firstchildlen = childlen)
+        if t isa FixedSizeListType
+            childlen >= fslextent || throw(
+                ValidationError("fixed-size-list child is shorter than its parent extent"),
+            )
+        elseif t isa StructType
+            childlen >= node.length ||
+                throw(ValidationError("struct child is shorter than its parent extent"))
+        elseif t isa UnionType && t.mode == AC.SparseMode
+            childlen == node.length || throw(
+                ValidationError(
+                    "sparse-union child length does not equal its parent length",
+                ),
+            )
+        elseif t isa RunEndEncodedType && i == 2
+            childlen == firstchildlen ||
+                throw(ValidationError("REE run-end and value child lengths must match"))
+        end
+    end
+    if t isa RunEndEncodedType
+        node.null_count == 0 || throw(ValidationError("REE parent null count must be zero"))
+        node.length == 0 ||
+            firstchildlen > 0 ||
+            throw(
+                ValidationError("a nonempty REE array requires at least one physical run"),
+            )
+        runtype = f.children[1].type::IntType
+        maxrunend =
+            runtype.bits == 16 ? Int64(typemax(Int16)) :
+            runtype.bits == 32 ? Int64(typemax(Int32)) : typemax(Int64)
+        node.length <= maxrunend ||
+            throw(ValidationError("REE logical extent exceeds its run-end range"))
+    end
+    return node.length
+end
+
+"""
+Validate every metadata-only invariant for the subtrees whose bodies are
+planned, and return the number of nonempty masked-in buffers — exactly the
+body ranges the caller will plan.
+"""
+function _validatebodyplan(
+    header::Meta.RecordBatch,
+    fields,
+    limits::Limits,
+    codec::Int8,
+    mask,
+    variadics::AbstractVector{Int64}=variadiccounts(header),
+)
+    cursor = DecodeCursor(
+        header.nodes,
+        header.buffers,
+        BufferSlice(),
+        limits;
+        codec=codec,
+        variadics=variadics,
+    )
+    selected = Int64(0)
+    for (j, f) in enumerate(fields)
+        firstbuffer = cursor.bufidx
+        mask[j] ? _validateplannedfield!(f, cursor, codec) : skipfield!(f, cursor)
+        if mask[j]
+            for i = firstbuffer:(cursor.bufidx - 1)
+                cursor.buffers[i].length > 0 &&
+                    (selected = AC.checked_add(selected, Int64(1)))
+            end
+        end
+    end
+    finishcursor!(cursor)
+    return selected
+end
+
+"""
+Like `missingdicts`, but a missing dictionary only matters when its field is
+in the decode set — a batch may legally reference an id its skipped columns
+never resolve.
+"""
+function _scanmissingdicts(fields, nodes, dicts, fielddictids, mask::AbstractVector{Bool})
+    ns = something(nodes, Meta.FieldNode[])
+    idx = Ref(1)
+    function walk(f::Field, decoded::Bool)
+        idx[] <= length(ns) || throw(
+            ValidationError("metadata declares fewer field nodes than the schema requires"),
+        )
+        node = ns[idx[]]
+        idx[] += 1
+        if f.type isa DictionaryType
+            decoded || return
+            id = fielddictids[f]
+            if !haskey(dicts, id)
+                node.length >= 0 && node.null_count == node.length || throw(
+                    ValidationError(
+                        "record batch uses undefined dictionary id $id for a non-null slot",
+                    ),
+                )
+            end
+            return
+        end
+        spec = AC.layoutspec_of(f.type)
+        nchildren = spec.childcount == -1 ? length(f.children) : spec.childcount
+        for i = 1:nchildren
+            walk(f.children[i], decoded)
+        end
+    end
+    for (j, f) in enumerate(fields)
+        walk(f, mask[j])
+    end
+    return nothing
+end
+
+# ---------------------------------------------------------------------------
+# Masked batch decode over the file's Block index
+# ---------------------------------------------------------------------------
+
+"Row count of batch `i` from Block metadata alone — no body access."
+function _batchrows(f::ArrowFile, i::Int, budget::AllocationBudget)
+    fm = _blockmessage(f.region, f.recordblocks[i], f.dataend, f.limits, budget)
+    _filemetadataversion(f.schemaversion, fm.version)
+    rejectexperimentalcompression(fm)
+    fm.msg.header isa Meta.RecordBatch ||
+        throw(ValidationError("footer record block is not a record batch"))
+    return _recordbatchmeta(fm.msg.header, f.fields, f.limits, fm.body.len)
+end
+
+"""
+Three-valued evaluation of a scan predicate over a ZERO-FIELD row: every
+column reference is an all-missing column, constants evaluate, and the
+result is `true`, `false`, or `missing` (SQL semantics; only `true` keeps
+rows). Row-invariant by construction, so one evaluation covers every row —
+no per-row mask may be allocated from an untrusted row count.
+"""
+function _zerofieldpredicate(e)
+    e === nothing && return true
+    e isa Tables.AlwaysTrue && return true
+    e isa Tables.AlwaysFalse && return false
+    e isa Tables.IsNull && return !e.negated
+    if e isa Tables.AndExpr
+        sawmissing = false
+        for a in e.args
+            r = _zerofieldpredicate(a)
+            r === false && return false
+            r === missing && (sawmissing = true)
+        end
+        return sawmissing ? missing : true
+    end
+    if e isa Tables.OrExpr
+        sawmissing = false
+        for a in e.args
+            r = _zerofieldpredicate(a)
+            r === true && return true
+            r === missing && (sawmissing = true)
+        end
+        return sawmissing ? missing : false
+    end
+    if e isa Tables.NotExpr
+        r = _zerofieldpredicate(e.arg)
+        return r === missing ? missing : !r
+    end
+    return missing   # Cmp/In/StrPred against a missing column
+end
+
+# The field whose values a filter literal compares with: run-end and
+# dictionary encodings are transparent wrappers around their values' field.
+# (Dictionary children live on the type; run-end children on the Field.)
+function _leaffield(f::AC.Field)
+    t = f.type
+    if t isa AC.RunEndEncodedType && length(f.children) == 2
+        return _leaffield(f.children[2])
+    end
+    t isa AC.DictionaryType && return _leaffield(AC.dictvaluefield(f, t))
+    return f
+end
+
+function _fieldfor(fields, ref, names)
+    ref isa Int && 1 <= ref <= length(fields) && return fields[ref]
+    i = findfirst(==(Symbol(ref)), names)
+    return i === nothing ? nothing : fields[i]
+end
+
+# --- zoned timestamp literals --------------------------------------------------
+# A UTC timestamp column (pandas tz-aware data, DuckDB TIMESTAMPTZ) reads as
+# `ZonedTimestamp{P,:UTC}`, which does not compare with `DateTime`, `Date`, or
+# `Timestamp`. A filter binding one of those to a UTC column reads it as the
+# same UTC wall time. For a column in another zone a zone-free literal is
+# ambiguous, and the filter fails naming a literal that works.
+
+const _ZonelessTime = Union{Dates.DateTime,Dates.Date,Durations.Timestamp}
+
+_utcinstant(x::Dates.DateTime) = Durations.ZonedTimestamp{Dates.Millisecond,:UTC}(
+    Durations.Timestamp{Dates.Millisecond}(x),
+)
+_utcinstant(x::Dates.Date) = Durations.ZonedTimestamp{Dates.Second,:UTC}(x)
+_utcinstant(x::Durations.Timestamp{P}) where {P} = Durations.ZonedTimestamp{P,:UTC}(x)
+
+# `x` as a literal for field `f`: unchanged unless `f` holds zoned timestamps.
+function _zonedliteral(f::AC.Field, x)
+    x isa _ZonelessTime || return x
+    t = _leaffield(f).type
+    t isa AC.DictionaryType && (t = t.valuetype)
+    t isa AC.TimestampType || return x
+    zone = _timestampzone(t)
+    zone === nothing && return x
+    P = _timestampperiod(t.unit)
+    if zone == "UTC"
+        z = _uninferred(_utcinstant, x)
+        # In the column's unit when exact, so `Set` membership hashes alike.
+        try
+            return Durations.ZonedTimestamp{P,:UTC}(z)
+        catch err
+            err isa Union{InexactError,OverflowError} || rethrow()
+            return z
+        end
+    end
+    unit = nameof(P)
+    throw(
+        ArgumentError(
+            "column $(f.name) holds ZonedTimestamp{$unit, " *
+            "$(_uninferred(repr, Symbol(zone))::String)} values, " *
+            "which do not compare with a $(nameof(typeof(x))); compare with an instant " *
+            "such as `Durations.ZonedTimestamp{Dates.$unit,:UTC}(2020, 1, 1)`",
+        ),
+    )
+end
+
+# A comparison literal for field `f`: also, a zone-free time compared with a
+# zone-free timestamp column becomes the column's value type when that is the
+# same instant, so each row compares integers instead of calendar fields.
+# Membership keeps its values: a `Set` of dates hashes them as dates.
+function _cmpliteral(f::AC.Field, x)
+    x = _zonedliteral(f, x)
+    (x isa _ZonelessTime && !_hasarrowtypesextension(f)) || return x
+    t = _leaffield(f).type
+    t isa AC.DictionaryType && (t = t.valuetype)
+    (t isa AC.TimestampType && _timestampzone(t) === nothing) || return x
+    y = try
+        Durations.Timestamp{_timestampperiod(t.unit)}(x)
+    catch err
+        err isa Union{InexactError,OverflowError,ArgumentError} || rethrow()
+        return x
+    end
+    return y == x ? y : x
+end
+
+function _zonedliterals(e, fields, names)
+    if e isa Tables.Cmp
+        f = _fieldfor(fields, e.lhs.ref, names)
+        f === nothing && return e
+        v = _cmpliteral(f, e.rhs)
+        return v === e.rhs ? e : Tables.Cmp(e.op, e.lhs, v)
+    elseif e isa Tables.In
+        f = _fieldfor(fields, e.lhs.ref, names)
+        values = e.values
+        # Only Base containers whose membership semantics survive a rebuild.
+        (f === nothing || !(values isa Union{Tuple,Array,Set})) && return e
+        # `values`' type is known at run time; see `_uninferred`.
+        return _uninferred(_zonedin, e, f, values)::Tables.In
+    elseif e isa Tables.AndExpr
+        return Tables.AndExpr(
+            Tables.ScanExpr[_zonedliterals(a, fields, names) for a in e.args],
+        )
+    elseif e isa Tables.OrExpr
+        return Tables.OrExpr(
+            Tables.ScanExpr[_zonedliterals(a, fields, names) for a in e.args],
+        )
+    elseif e isa Tables.NotExpr
+        return Tables.NotExpr(_zonedliterals(e.arg, fields, names))
+    end
+    return e
+end
+
+# `e` with its zone-free time values given `f`'s zone.
+function _zonedin(e::Tables.In, f, values)
+    any(x -> x isa _ZonelessTime, values) || return e
+    lit(x) = _zonedliteral(f, x)
+    rebuilt =
+        values isa Tuple ? map(lit, values) :
+        values isa Set ? Set(lit(x) for x in values) : map(lit, values)
+    return Tables.In(e.lhs, rebuilt)
+end
+
+function _zonedbound(b::Tables.BoundScan, fields, names)
+    b.filter === nothing && return b
+    filter = _zonedliterals(b.filter, fields, names)
+    filter === b.filter && return b
+    return Tables.BoundScan(b.columns, filter, b.filtercols, b.limit, b.offset, b.validate)
+end
+
+# --- filter literal kinds --------------------------------------------------------
+# A literal of another kind than its column's values (a number for a string
+# column, say) is an ArgumentError naming the column when the scan binds, not a
+# MethodError once values are compared. Kinds: numbers, strings, characters,
+# local and zoned instants, times of day, periods; other values, and columns
+# with an extension label, are not checked.
+
+function _filterkind(f::AC.Field)
+    _hasarrowtypesextension(f) && return nothing
+    t = _leaffield(f).type
+    t isa Union{AC.IntType,AC.FloatType,AC.BoolType,AC.DecimalType} && return :number
+    (t isa AC.Utf8Type || (t isa AC.ViewType && t.utf8)) && return :string
+    t isa AC.DateType && return :local
+    t isa AC.TimestampType && return _timestampzone(t) === nothing ? :local : :zoned
+    t isa AC.TimeType && return :time
+    t isa AC.DurationType && return :period
+    return nothing
+end
+
+_filterkind(::Type{T}) where {T} =
+    T <: Real ? :number :
+    T <: AbstractString ? :string :
+    T <: AbstractChar ? :char :
+    T <: Durations.ZonedTimestamp ? :zoned :
+    T <: _ZonelessTime ? :local :
+    T <: Dates.Time ? :time : T <: Dates.Period ? :period : nothing
+
+function _checkliterals(e, fields, names)
+    if e isa Union{Tables.Cmp,Tables.In,Tables.StrPred}
+        f = _fieldfor(fields, e.lhs.ref, names)
+        f === nothing && return nothing
+        kind = _filterkind(f)
+        kind === nothing && return nothing
+        r = e.lhs.ref
+        ref = r isa Integer ? names[r] : r
+        if e isa Tables.StrPred
+            kind === :string || throw(
+                ArgumentError(
+                    "the filter matches text in column $ref, which holds " *
+                    "$(_kindvalues(f, kind))",
+                ),
+            )
+        elseif e isa Tables.Cmp
+            _checkliteral(f, ref, kind, e.rhs)
+        elseif e.values isa Union{Tuple,AbstractArray,AbstractSet}
+            foreach(v -> _checkliteral(f, ref, kind, v), e.values)
+        end
+    elseif e isa Union{Tables.AndExpr,Tables.OrExpr}
+        foreach(a -> _checkliterals(a, fields, names), e.args)
+    elseif e isa Tables.NotExpr
+        _checkliterals(e.arg, fields, names)
+    end
+    return nothing
+end
+
+function _checkliteral(f::AC.Field, ref, kind::Symbol, value)
+    literal = _filterkind(typeof(value))
+    (literal === nothing || literal === kind) && return nothing
+    throw(
+        ArgumentError(
+            "the filter compares column $ref, which holds $(_kindvalues(f, kind)), " *
+            "with $(repr(value))::$(typeof(value))",
+        ),
+    )
+end
+
+_kindvalues(f::AC.Field, kind::Symbol) =
+    kind === :string ? "strings" : "$(Base.nonmissingtype(_declaredeltype(f))) values"
+
+"""
+One scan request resolved against one Arrow schema. `names` is the owned
+source schema identity used by every executor; `bound` is the request, which
+filters and converts public values.
+"""
+struct _ScanPlan
+    names::Vector{Symbol}
+    bound::Tables.BoundScan
+end
+
+function _deduplicatesorted!(values::Vector)
+    isempty(values) && return values
+    # Stability is irrelevant here. QuickSort avoids the input-sized scratch
+    # vector used by Julia's stable default sort.
+    sort!(values; alg=Base.Sort.QuickSort)
+    writeidx = 1
+    for readidx = 2:length(values)
+        values[readidx] == values[writeidx] && continue
+        writeidx += 1
+        values[writeidx] = values[readidx]
+    end
+    resize!(values, writeidx)
+    return values
+end
+
+# Not inferred: Tables resolves untyped selections (see `_uninferred`).
+_resolvescan(scan::Tables.Scan, names) =
+    _uninferred(Tables.resolve, scan, names)::Tables.BoundScan
+
+function _ScanPlan(scan::Tables.Scan, fields, budget=nothing)
+    # Unique names (`_fieldnamesymbols`), so every column has one reference.
+    names = _fieldnamesymbols(fields, budget)
+    b = _zonedbound(_resolvescan(scan, names), fields, names)
+    _checkliterals(b.filter, fields, names)
+    return _ScanPlan(names, b)
+end
+
+"Column table whose schema does not become part of its Julia type."
+struct _ScanColumns
+    names::Vector{Symbol}
+    columns::Vector{AbstractVector}
+    nrows::Int
+end
+Tables.istable(::Type{_ScanColumns}) = true
+Tables.columnaccess(::Type{_ScanColumns}) = true
+Tables.columns(t::_ScanColumns) = t
+Tables.columnnames(t::_ScanColumns) = getfield(t, :names)
+Tables.getcolumn(t::_ScanColumns, i::Int) = getfield(t, :columns)[i]
+function Tables.getcolumn(t::_ScanColumns, name::Symbol)
+    i = findfirst(==(name), getfield(t, :names))
+    i === nothing && throw(
+        ArgumentError("no column $(_uninferred(repr, name)::String) in this scan result"),
+    )
+    return getfield(t, :columns)[i]
+end
+Tables.rowcount(t::_ScanColumns) = getfield(t, :nrows)
+function Tables.schema(t::_ScanColumns)
+    names = getfield(t, :names)
+    types = Type[eltype(c) for c in getfield(t, :columns)]
+    # Preserve the compact typed schema for ordinary narrow results. Wide
+    # schemas stay in values so compiler work cannot scale with input names.
+    return Tables.Schema(names, types; stored=length(names) > _MAX_TYPED_SCHEMA_FIELDS)
+end
+Base.propertynames(t::_ScanColumns) = getfield(t, :names)
+Base.getproperty(t::_ScanColumns, name::Symbol) = Tables.getcolumn(t, name)
+
+# The pieces of one column, in order, as one column: the piece itself when there
+# is one, string pieces as one string column over all their buffers, pieces of
+# one dictionary-column type as a column of several record batches, or else a
+# `Vector` of their element types' join.
+function _joinparts(parts::Vector, budget=nothing)
+    length(parts) == 1 && return parts[1]
+    P = typeof(first(parts))
+    # The pieces' types are known at run time; see `_uninferred`.
+    P <: DictEncoded &&
+        all(part -> part isa P, parts) &&
+        return _uninferred(_chain, P, parts)
+    T = _eltypeof(first(parts))
+    for part in Iterators.drop(parts, 1)
+        T = Base.promote_typejoin(T, _eltypeof(part))
+    end
+    total = sum(length, parts; init=0)
+    if all(part -> part isa _StringColumn, parts)
+        _chargevector!(budget, _StringPayload, total, "joined column")
+        return _uninferred(_joinstrings, T, parts)
+    end
+    _chargevector!(budget, T, total, "joined column")
+    return _uninferred(_copyparts!, Vector{T}(undef, total), parts)
+end
+
+_chain(::Type{P}, parts) where {P} = ChainedVector(P[parts...])
+
+function _copyparts!(out::Vector, parts)
+    offset = 0
+    for part in parts
+        copyto!(out, offset + 1, part, firstindex(part), length(part))
+        offset += length(part)
+    end
+    return out
+end
+
+function _addscanrows(total::Int, rows::Int64)
+    (0 <= total && 0 <= rows && rows <= typemax(Int) - total) ||
+        throw(ValidationError("scan result row count is not addressable"))
+    return total + Int(rows)
+end
+
+# ---------------------------------------------------------------------------
+# Scan pushdown over a whole file
+# ---------------------------------------------------------------------------
+
+"""
+Exact batch windowing for consumed `limit`/`offset`: per surviving batch,
+how many leading rows to drop and how many to keep. Batches wholly outside
+the window are absent — never decoded.
+"""
+function _batchwindow(
+    rowcounts::Vector{Int64},
+    offset::Int,
+    limit::Union{Nothing,Int},
+    budget=nothing,
+)
+    # Count first so a narrow limit does not reserve one entry for every
+    # batch. The second pass allocates the exact logical window once.
+    count = 0
+    remaining_skip = Int64(offset)
+    unlimited = limit === nothing
+    remaining_take = unlimited ? Int64(0) : Int64(limit)
+    for rows in rowcounts
+        !unlimited && remaining_take <= 0 && break
+        if remaining_skip >= rows
+            remaining_skip -= rows
+            continue
+        end
+        take =
+            unlimited ? rows - remaining_skip : min(rows - remaining_skip, remaining_take)
+        count += 1
+        unlimited || (remaining_take -= take)
+        remaining_skip = 0
+    end
+    Entry = Tuple{Int,Int64,Int64}
+    _chargevector!(budget, Entry, count, "scan batch window")
+    window = Entry[]   # (batch index, skip, take)
+    sizehint!(window, count)
+    remaining_skip = Int64(offset)
+    unlimited = limit === nothing
+    remaining_take = unlimited ? Int64(0) : Int64(limit)
+    for (i, rows) in enumerate(rowcounts)
+        !unlimited && remaining_take <= 0 && break
+        if remaining_skip >= rows
+            remaining_skip -= rows
+            continue
+        end
+        take =
+            unlimited ? rows - remaining_skip : min(rows - remaining_skip, remaining_take)
+        push!(window, (i, remaining_skip, take))
+        if !unlimited
+            remaining_take -= take
+        end
+        remaining_skip = 0
+    end
+    return window
+end
+
+# ===========================================================================
+# Byte-range reads — SourceFile over an AbstractArrowSource, the planner,
+# and sparse decode
+# ===========================================================================
+
+"""
+    SourceFile(src::AbstractArrowSource; limits=Limits(), tailbytes=65536, gapbytes=262144)
+
+A handle that reads an Arrow IPC file from `src` by byte range, so a scan or
+an `Arrow.Stream` fetches only the parts it needs. Internal, not part of the
+public API: pass the source itself to `Arrow.Table` or `Arrow.Stream`.
+
+- `limits`: the [`Arrow.Limits`](@ref) every read through the handle checks.
+- `tailbytes`: the size of the first read, from the end of the object, which
+  normally holds the footer (at least 32).
+- `gapbytes`: how many unrequested bytes a read may include to save a request.
+  Ranges at most this far apart are read together, and a scan reads a
+  batch's body with its metadata when the body is at most four `gapbytes`
+  (otherwise its first `gapbytes`). `gapbytes=0` reads only the bytes asked
+  for, in more requests.
+"""
+# The footer is the only schema authority: a ranged read does not fetch the
+# leading magic, cross-check the leading schema message, or look for the EOS
+# marker, and the tail and coalesced reads may include bytes nobody asked for.
+# The footer's Block index and the global feature and message limits are
+# checked up front; per-record limits stay lazy, and every surviving
+# candidate's metadata plan is validated before any planned body range is
+# requested. Coalesced spans stop at 8 MiB. `limits.max_concurrent_reads`
+# caps the source's preferred concurrency, and one semaphore is shared by
+# every read on the handle. The source's length is read once, at construction.
+struct SourceFile{S<:AbstractArrowSource}
+    src::S
+    len::Int64
+    limits::Limits
+    tailbytes::Int64
+    gapbytes::Int64
+    # The last `tailbytes` of the object, read once and reused by every
+    # footer parse and format probe on this handle: `(bytes, tailstart)`.
+    tail::Base.RefValue{Union{Nothing,Tuple{Vector{UInt8},Int64}}}
+    # A Footer that did not fit in the tail window, read once as
+    # `(footerstart, bytes)` and reused by every footer parse on this handle.
+    footer::Base.RefValue{Union{Nothing,Tuple{Int64,Vector{UInt8}}}}
+    concurrency::Int
+    readsem::Base.Semaphore
+    cachelock::ReentrantLock
+end
+function SourceFile(
+    src::AbstractArrowSource;
+    limits::Limits=Limits(),
+    tailbytes::Integer=65536,
+    gapbytes::Integer=262144,
+)
+    _validatelimits(limits)
+    gap = Int64(gapbytes)
+    gap >= 0 || throw(ArgumentError("gapbytes must not be negative, got $gapbytes"))
+    reported = sourcelength(src)
+    (reported isa Integer && reported >= 0 && reported <= typemax(Int64)) ||
+        throw(ValidationError("source reports an invalid length $(repr(reported))"))
+    preference = concurrentreads(src)
+    (preference isa Integer && preference >= 1 && preference <= typemax(Int)) || throw(
+        ValidationError(
+            "source reports an invalid concurrent-read preference $(repr(preference))",
+        ),
+    )
+    concurrency = min(Int(preference), limits.max_concurrent_reads)
+    return SourceFile(
+        src,
+        Int64(reported),
+        limits,
+        Int64(max(tailbytes, 32)),
+        gap,
+        Base.RefValue{Union{Nothing,Tuple{Vector{UInt8},Int64}}}(nothing),
+        Base.RefValue{Union{Nothing,Tuple{Int64,Vector{UInt8}}}}(nothing),
+        concurrency,
+        Base.Semaphore(concurrency),
+        ReentrantLock(),
+    )
+end
+
+# The object's tail window (at most `tailbytes`, the whole object when it is
+# shorter), fetched on first use and cached on the handle.
+function _fetchtail(sf::SourceFile, budget::Union{Nothing,AllocationBudget}=nothing)
+    lock(sf.cachelock)
+    try
+        cached = sf.tail[]
+        cached === nothing || return cached
+        tailstart = max(Int64(0), sf.len - sf.tailbytes)
+        _chargevector!(budget, UInt8, sf.len - tailstart, "tail range fetch")
+        tail = _fetchexact(sf, tailstart, sf.len - tailstart)
+        sf.tail[] = (tail, tailstart)
+        return (tail, tailstart)
+    finally
+        unlock(sf.cachelock)
+    end
+end
+
+# A Footer that escapes the tail window: one exact read, cached on the handle
+# so the schema pass and the scan pass share it.
+function _fetchfooter(
+    sf::SourceFile,
+    footerstart::Int64,
+    footerlen::Int64,
+    budget::AllocationBudget,
+)
+    lock(sf.cachelock)
+    try
+        cached = sf.footer[]
+        if cached !== nothing && cached[1] == footerstart && length(cached[2]) == footerlen
+            return cached[2]
+        end
+        _chargevector!(budget, UInt8, footerlen, "footer range fetch")
+        bytes = _fetchexact(sf, footerstart, footerlen)
+        sf.footer[] = (footerstart, bytes)
+        return bytes
+    finally
+        unlock(sf.cachelock)
+    end
+end
+
+# Whether the object is an IPC FILE (trailing `ARROW1` magic) — a stream
+# object has no footer and is read whole instead of range-planned.
+function _isfilesource(sf::SourceFile, budget::Union{Nothing,AllocationBudget}=nothing)
+    tail, _ = _fetchtail(sf, budget)
+    return length(tail) >= 6 && tail[(end - 5):end] == Vector{UInt8}(FILE_MAGIC)
+end
+
+# A long read (a whole object, a record batch, a stream message) fetches in
+# ranges of this size, `sf.concurrency` at a time, so a source with concurrent
+# reads downloads in parallel and holds at most that many ranges besides the
+# result.
+const _READ_RANGE = Int64(8 * 1024 * 1024)
+
+# Bytes `[off, off + len)` of the source into `out` from index `at`: in
+# `_READ_RANGE` ranges at once, or as one range from a source that reads one
+# at a time.
+function _fetchinto!(out::Vector{UInt8}, at::Int, sf::SourceFile, off::Int64, len::Int64)
+    step = sf.concurrency == 1 ? max(len, Int64(1)) : _READ_RANGE
+    _foreach(Int(cld(len, step)), sf.concurrency) do i, _
+        o = (i - 1) * step
+        n = min(step, len - o)
+        copyto!(out, at + o, _fetchexact(sf, off + o, n), 1, n)
+        return nothing
+    end
+    return out
+end
+
+# The whole object as one buffer, reusing the cached tail for its final window.
+function _wholeobject(sf::SourceFile, budget::Union{Nothing,AllocationBudget}=nothing)
+    tail, tailstart = _fetchtail(sf, budget)
+    tailstart == 0 && return tail
+    _chargevector!(budget, UInt8, sf.len, "whole-object buffer")
+    _chargevector!(
+        budget,
+        UInt8,
+        min(sf.concurrency * _READ_RANGE, tailstart),
+        "range fetches",
+    )
+    out = Vector{UInt8}(undef, sf.len)
+    copyto!(out, tailstart + 1, tail, 1, length(tail))
+    return _fetchinto!(out, 1, sf, Int64(0), tailstart)
+end
+
+"""
+Reads footer blocks for a pass in file order: a block read right after the
+one before it comes with the blocks that follow it, up to `_READ_RANGE`
+bytes in all, and those are then served from that window. While a window
+(or a block larger than one) is in use, the next window is already being
+fetched. A pass over small blocks makes one request per window instead of
+one per block; a block read out of order is fetched alone. At most one
+window is held and one more is in flight.
+"""
+mutable struct _BlockReader
+    const sf::SourceFile
+    const lock::ReentrantLock
+    # Where the last block served ended, and the window's start and bytes.
+    next::Int64
+    start::Int64
+    window::Vector{UInt8}
+    # The window being fetched ahead: its start and end offsets, the index of
+    # its last block, and the task fetching it.
+    pending::Union{Nothing,Tuple{Int64,Int64,Int,Task}}
+end
+_BlockReader(sf::SourceFile) =
+    _BlockReader(sf, ReentrantLock(), Int64(-1), Int64(0), UInt8[], nothing)
+
+"""
+A file-format source read one record batch at a time (`Arrow.Stream` over an
+`AbstractArrowSource`): the footer and every dictionary batch when opened,
+then each record batch's bytes when the batch is read.
+"""
+struct _RangedFile
+    sf::SourceFile
+    schema::Schema
+    fields::AC.FrozenVector{Field}
+    fielddictids::IdDict{Field,Int64}
+    dictionaries::Dict{Int64,ArrayData}
+    validated::AC._ValidatedDictionaries
+    recordblocks::Vector{NTuple{3,Int64}}
+    dataend::Int64
+    limits::Limits
+    footerversion::Int16
+    # The stream's lifetime authority; each batch's bytes are their own region.
+    region::OwnerRegion
+    blocks::_BlockReader
+end
+
+function _RangedFile(sf::SourceFile, budget::AllocationBudget)
+    ft = _readfooter(sf, sf.limits, budget)
+    dictreader = _BlockReader(sf)
+    framed(i, block) =
+        let fm = first(_blockframe(dictreader, ft.dictblocks, i, ft.footerstart, budget))
+            _filemetadataversion(ft.version, fm.version)
+            fm
+        end
+    dicts, validated = _filedictionaries(
+        framed,
+        ft.dictblocks,
+        ft.dictids,
+        ft.dictvaluefields,
+        ft.fielddictids,
+        sf.limits,
+        budget,
+    )
+    return _RangedFile(
+        sf,
+        ft.sch,
+        AC.FrozenVector{Field}(ft.fields),
+        ft.fielddictids,
+        dicts,
+        validated,
+        ft.recordblocks,
+        ft.footerstart,
+        sf.limits,
+        ft.version,
+        heapregion(UInt8[]),
+        _BlockReader(sf),
+    )
+end
+
+# The bytes of `blocks[i]`, from the window, the window fetched ahead, or
+# fetched now.
+function _readblock(br::_BlockReader, blocks, i::Int, dataend::Int64)
+    offset, frameend = _blockextent(blocks[i], dataend)
+    ahead = nothing
+    sequential = false
+    @lock br.lock begin
+        if br.start <= offset && frameend <= br.start + length(br.window)
+            br.next = frameend
+            return br.window[(offset - br.start + 1):(frameend - br.start)]
+        end
+        sequential = i == 1 || 0 <= offset - br.next <= br.sf.gapbytes
+        p = br.pending
+        if p !== nothing && p[1] == offset
+            ahead = p
+            br.pending = nothing
+        end
+    end
+    if ahead === nothing
+        stop, last = sequential ? _windowfrom(blocks, i, dataend) : (frameend, i)
+        bytes = _fetchinto!(
+            Vector{UInt8}(undef, stop - offset),
+            1,
+            br.sf,
+            offset,
+            stop - offset,
+        )
+    else
+        _, stop, last, task = ahead
+        bytes = try
+            fetch(task)::Vector{UInt8}
+        catch e
+            rethrow(_firstcause(e))
+        end
+    end
+    @lock br.lock begin
+        br.next = frameend
+        if sequential && last < length(blocks) && br.pending === nothing
+            nstart, _ = _blockextent(blocks[last + 1], dataend)
+            nstop, nlast = _windowfrom(blocks, last + 1, dataend)
+            sf = br.sf
+            task = errormonitor(
+                Threads.@spawn _fetchinto!(
+                    Vector{UInt8}(undef, nstop - nstart),
+                    1,
+                    sf,
+                    nstart,
+                    nstop - nstart,
+                )
+            )
+            br.pending = (nstart, nstop, nlast, task)
+        end
+        stop == frameend && return bytes
+        br.start, br.window = offset, bytes
+    end
+    return bytes[1:(frameend - offset)]
+end
+
+# The end offset and last block index of the window that starts at block
+# `i`: the blocks after it while all of them fit in `_READ_RANGE` bytes.
+function _windowfrom(blocks, i::Int, dataend::Int64)
+    offset, stop = _blockextent(blocks[i], dataend)
+    j = i
+    while j < length(blocks)
+        o, e = _blockextent(blocks[j + 1], dataend)
+        (o >= stop && e - offset <= _READ_RANGE) || break
+        stop = e
+        j += 1
+    end
+    return stop, j
+end
+
+# A footer block fetched and framed as a message of its own: the message and
+# the region holding the block's bytes.
+function _blockframe(br::_BlockReader, blocks, i::Int, dataend::Int64, budget)
+    region = heapregion(_readblock(br, blocks, i, dataend))
+    _, metalen, bodylen = blocks[i]
+    fm = _blockmessage(
+        region,
+        (Int64(0), metalen, bodylen),
+        region.len,
+        br.sf.limits,
+        budget,
+    )
+    return fm, region
+end
+
+Base.length(r::_RangedFile) = length(r.recordblocks)
+
+# Row count of batch `i` from one range request for its metadata.
+_batchrows(r::_RangedFile, i::Int, budget::AllocationBudget) =
+    _rangedbatchrows(r.sf, r.recordblocks[i], r.footerversion, r.fields, budget)
+
+"""
+A forward `IO` over a `SourceFile`, for reading a stream-format object one
+message at a time: each fetch covers the bytes asked for plus a readahead
+window that serves the next short reads.
+"""
+mutable struct _SourceIO <: IO
+    const sf::SourceFile
+    pos::Int64
+    window::Vector{UInt8}
+    windowstart::Int64
+    # The readahead of the next short read: it doubles from
+    # `_SOURCE_READAHEAD` to `_READ_RANGE`, so a long pass over small messages
+    # makes few requests and a short one over-reads little.
+    ahead::Int64
+end
+_SourceIO(sf::SourceFile) = _SourceIO(sf, Int64(0), UInt8[], Int64(0), _SOURCE_READAHEAD)
+
+const _SOURCE_READAHEAD = Int64(64 * 1024)
+
+Base.eof(io::_SourceIO) = io.pos >= io.sf.len
+function Base.unsafe_read(io::_SourceIO, p::Ptr{UInt8}, n::UInt)
+    want = Int64(n)
+    want <= io.sf.len - io.pos || throw(EOFError())
+    windowend = io.windowstart + length(io.window)
+    buffered =
+        io.windowstart <= io.pos < windowend ? min(windowend - io.pos, want) : Int64(0)
+    if buffered > 0
+        from = Int(io.pos - io.windowstart) + 1
+        GC.@preserve io unsafe_copyto!(p, pointer(io.window, from), buffered)
+        io.pos += buffered
+    end
+    rest = want - buffered
+    rest == 0 && return nothing
+    # One fetch covers the rest and the next window (a body and the next
+    # message's prefix and metadata, for a stream).
+    # A read shorter than one `_READ_RANGE` brings the readahead and doubles
+    # it; a longer one (a large message) brings only the base readahead.
+    short = rest < _READ_RANGE
+    len = min(rest + (short ? io.ahead : _SOURCE_READAHEAD), io.sf.len - io.pos)
+    short && (io.ahead = min(2 * io.ahead, _READ_RANGE))
+    fetched = _fetchinto!(Vector{UInt8}(undef, len), 1, io.sf, io.pos, len)
+    GC.@preserve fetched unsafe_copyto!(p + buffered, pointer(fetched), rest)
+    io.pos += rest
+    # Keep only the readahead, not a copy of the bytes just delivered.
+    io.window = fetched[(rest + 1):end]
+    io.windowstart = io.pos
+    return nothing
+end
+
+# One exact range through the source, bounds-checked against the length
+# read at construction and length-checked on return; a range the cached
+# tail window already covers is served from it without a request.
+function _fetchexact(sf::SourceFile, off::Int64, len::Int64)
+    (off >= 0 && len >= 0 && off <= sf.len - len) ||
+        throw(ValidationError("range fetch [$off, $len] escapes the object"))
+    lock(sf.cachelock)
+    try
+        cached = sf.tail[]
+        if cached !== nothing
+            tail, tailstart = cached
+            if off >= tailstart && off + len <= tailstart + length(tail)
+                return tail[(off - tailstart + 1):(off - tailstart + len)]
+            end
+        end
+    finally
+        unlock(sf.cachelock)
+    end
+    Base.acquire(sf.readsem)
+    got = try
+        readrange(sf.src, off, len)
+    finally
+        Base.release(sf.readsem)
+    end
+    got isa Vector{UInt8} ||
+        throw(ValidationError("readrange must return a Vector{UInt8}, got $(typeof(got))"))
+    length(got) == len ||
+        throw(ValidationError("range fetch returned $(length(got)) bytes, expected $len"))
+    return got
+end
+
+"""
+Merge sorted ranges whose gap is at most `gap`: a small over-read is usually
+cheaper than another request round-trip. Ranges that do not overlap are not
+merged past `maxspan` bytes, so a long run of them is fetched in several
+requests at once. Returns file-coordinate spans.
+"""
+function _coalesce(
+    ranges::Vector{NTuple{2,Int64}},
+    gap::Int64,
+    budget=nothing,
+    maxspan::Int64=typemax(Int64),
+)
+    gap >= 0 || throw(ArgumentError("negative coalesce gap"))
+    all(r -> r[1] >= 0 && r[2] >= 0, ranges) ||
+        throw(ValidationError("negative range offset or length"))
+    nonempty = count(r -> r[2] > 0, ranges)
+    if nonempty == 0
+        _chargevector!(budget, NTuple{2,Int64}, 0, "coalesced range plan")
+        return NTuple{2,Int64}[]
+    end
+    _chargevector!(budget, NTuple{2,Int64}, nonempty, "coalesced range plan")
+    # `sort` owns the one output vector. Compact it in place instead of
+    # building a second range vector whose capacity also scales with input.
+    sorted = Vector{NTuple{2,Int64}}(undef, nonempty)
+    next = 0
+    for range in ranges
+        range[2] == 0 && continue
+        next += 1
+        sorted[next] = range
+    end
+    # Range order has no equal-key stability requirement. Keep the only
+    # input-sized allocation the explicitly charged output vector above.
+    sort!(sorted; alg=Base.Sort.QuickSort)
+    outidx = 1
+    for readidx = 2:length(sorted)
+        off, len = sorted[readidx]
+        loff, llen = sorted[outidx]
+        loend = AC.checked_add(loff, llen)
+        thisend = AC.checked_add(off, len)
+        if off < loend || (off - loend <= gap && max(loend, thisend) - loff <= maxspan)
+            sorted[outidx] = (loff, max(loend, thisend) - loff)
+        else
+            outidx += 1
+            sorted[outidx] = (off, len)
+        end
+    end
+    resize!(sorted, outidx)
+    return sorted
+end
+
+"""
+Fetched file-coordinate spans with their bytes, resolvable by containment.
+`starts` is ascending. The spans of one fetch round are disjoint
+(`_coalesce`); a scan's body round can overlap its metadata round
+(`_unionspans`), so `_spanslice` also checks earlier spans.
+"""
+struct FetchedSpans
+    starts::Vector{Int64}
+    lens::Vector{Int64}
+    slices::Vector{BufferSlice}
+end
+
+# Whether a body of `bodylen` bytes is read whole with its metadata: one
+# request costs more than the bytes of a body of at most four `gapbytes`.
+_smallbody(bodylen::Int64, gap::Int64) = bodylen <= AC.checked_mul(gap, Int64(4))
+
+# How much of a body of `bodylen` bytes a block's metadata request also reads:
+# all of a small body, otherwise one `gapbytes`' worth.
+_speculativebody(bodylen::Int64, gap::Int64) =
+    _smallbody(bodylen, gap) ? bodylen : min(bodylen, gap)
+
+function _fetchspans(
+    sf::SourceFile,
+    ranges::Vector{NTuple{2,Int64}},
+    gap::Int64;
+    budget::Union{Nothing,AllocationBudget}=nothing,
+    what::AbstractString="range fetch",
+)
+    spans = _coalesce(ranges, gap, budget, _READ_RANGE)
+    all(s -> s[1] >= 0 && s[2] >= 0 && s[1] <= sf.len - s[2], spans) ||
+        throw(ValidationError("planned range escapes the object"))
+    budget === nothing || foreach(s -> _chargevector!(budget, UInt8, s[2], what), spans)
+    payloads = _readspans(sf, spans, budget)
+    _chargevector!(budget, BufferSlice, length(payloads), "fetched range slices")
+    if isempty(payloads)
+        slices = BufferSlice[]
+    else
+        _chargeobject!(budget, sizeof(AC.ReleaseCell), "fetched range release state")
+        ownerbytes = AC.checked_mul(
+            Int64(length(payloads)),
+            AC._materializedobjectbytes(sizeof(AC.OwnerRegion)),
+        )
+        budget === nothing || _charge!(budget, ownerbytes, "fetched range owners")
+        cell = AC.ReleaseCell()
+        slices = BufferSlice[
+            BufferSlice(
+                AC.OwnerRegion(Ptr{UInt8}(pointer(p)), sizeof(p); root=p, cell=cell),
+                0,
+                length(p),
+            ) for p in payloads
+        ]
+    end
+    _chargevector!(budget, Int64, length(spans), "fetched range starts")
+    _chargevector!(budget, Int64, length(spans), "fetched range lengths")
+    return FetchedSpans(Int64[s[1] for s in spans], Int64[s[2] for s in spans], slices)
+end
+
+# A region's bytes are all in memory: one span over the whole region serves
+# every range a scan plans.
+_fetchspans(r::OwnerRegion, ranges, gap::Int64; budget=nothing, what="") =
+    FetchedSpans(Int64[0], Int64[r.len], BufferSlice[BufferSlice(r, 0, r.len)])
+
+# Read one round's spans, each length-checked, into `results[i]` by request
+# index. Small rounds read serially. Larger rounds use `sf.concurrency`
+# workers that pull indexes off one atomic counter. Storing by request index
+# means a source's completion order cannot permute payloads, and the worker
+# count bounds the reads in flight whatever the span count.
+function _readspans(sf::SourceFile, spans::Vector{NTuple{2,Int64}}, budget=nothing)
+    n = length(spans)
+    _chargevector!(budget, Vector{UInt8}, n, "range-fetch results")
+    results = Vector{Vector{UInt8}}(undef, n)
+    k = min(n, sf.concurrency)
+    if k <= 1
+        for i = 1:n
+            results[i] = _fetchexact(sf, spans[i][1], spans[i][2])
+        end
+        return results
+    end
+    # Task and scheduler objects are fixed-size control allocations, but the
+    # number of workers is input-directed. A conservative per-worker reserve
+    # keeps that bounded by the same operation budget as fetched payloads.
+    budget === nothing ||
+        _charge!(budget, AC.checked_mul(Int64(k), Int64(4096)), "range-fetch workers")
+    _chargeobject!(budget, sizeof(_SpanQueue), "range-fetch work queue")
+    queue = _SpanQueue(0)
+    try
+        @sync for _ = 1:k
+            errormonitor(Threads.@spawn _readworker!(results, sf, spans, queue))
+        end
+    catch e
+        rethrow(_firstcause(e))
+    end
+    return results
+end
+
+# The shared request counter of one round's worker pool.
+mutable struct _SpanQueue
+    @atomic next::Int
+end
+
+# One worker: claim the next request index, read it into its slot, repeat.
+function _readworker!(
+    results::Vector{Vector{UInt8}},
+    sf::SourceFile,
+    spans::Vector{NTuple{2,Int64}},
+    queue::_SpanQueue,
+)
+    n = length(spans)
+    while true
+        i = @atomic queue.next += 1
+        i > n && return nothing
+        results[i] = _fetchexact(sf, spans[i][1], spans[i][2])
+    end
+end
+
+# The underlying exception of a failed worker task (`@sync` wraps it).
+function _firstcause(e)
+    e isa CompositeException && !isempty(e) && return _firstcause(first(e))
+    e isa TaskFailedException && return _firstcause(e.task.result)
+    return e
+end
+
+function _spanslice(fs::FetchedSpans, off::Int64, len::Int64)
+    len == 0 && return BufferSlice()
+    i = _spanholding(fs, off, len)
+    i == 0 && throw(ValidationError("required bytes [$off, $len] were not fetched"))
+    return AC.subslice(fs.slices[i], off - fs.starts[i], len)
+end
+
+# The index of a span that holds `[off, off + len)`, or 0.
+function _spanholding(fs::FetchedSpans, off::Int64, len::Int64)
+    stop = AC.checked_add(off, len)
+    i = searchsortedlast(fs.starts, off)
+    while i >= 1
+        stop <= AC.checked_add(fs.starts[i], fs.lens[i]) && return i
+        i -= 1
+    end
+    return 0
+end
+
+# Add the spans of a later fetch round to `fs`, keeping them ordered by start.
+function _addspans!(fs::FetchedSpans, new::FetchedSpans, budget)
+    n = length(new.starts)
+    _chargevector!(budget, Int64, 2n, "fetched span index")
+    _chargevector!(budget, BufferSlice, n, "fetched span slices")
+    if n <= 16
+        for k = 1:n
+            at = searchsortedlast(fs.starts, new.starts[k]) + 1
+            insert!(fs.starts, at, new.starts[k])
+            insert!(fs.lens, at, new.lens[k])
+            insert!(fs.slices, at, new.slices[k])
+        end
+        return fs
+    end
+    # A large round sorts once instead of shifting the index once per span.
+    append!(fs.starts, new.starts)
+    append!(fs.lens, new.lens)
+    append!(fs.slices, new.slices)
+    order = sortperm(fs.starts)
+    permute!(fs.starts, order)
+    permute!(fs.lens, order)
+    permute!(fs.slices, order)
+    return fs
+end
+
+# Forget the spans inside `[from, to)`, so their bytes can be freed.
+function _dropspans!(fs::FetchedSpans, from::Int64, to::Int64)
+    keep = [!(from <= s && s + l <= to) for (s, l) in zip(fs.starts, fs.lens)]
+    keepat!(fs.starts, keep)
+    keepat!(fs.lens, keep)
+    keepat!(fs.slices, keep)
+    return fs
+end
+
+# `ranges` are all the bytes a read's columns view. A span they fill less than
+# half of is replaced by copies of just those ranges, so the span is freed when
+# the read returns instead of living as long as the columns.
+function _compactspans!(fs::FetchedSpans, ranges::Vector{NTuple{2,Int64}}, budget)
+    holders = Int[_spanholding(fs, off, len) for (off, len) in ranges]
+    used = zeros(Int64, length(fs.starts))
+    for (h, (_, len)) in zip(holders, ranges)
+        used[h] += len
+    end
+    sparse = BitVector(2u < len for (u, len) in zip(used, fs.lens))
+    copies = FetchedSpans(Int64[], Int64[], BufferSlice[])
+    for ((off, len), h) in zip(ranges, holders)
+        sparse[h] || continue
+        _chargevector!(budget, UInt8, len, "copied span range")
+        bytes = AC.slicebytes(AC.subslice(fs.slices[h], off - fs.starts[h], len))
+        push!(copies.starts, off)
+        push!(copies.lens, len)
+        push!(copies.slices, BufferSlice(heapregion(bytes), 0, len))
+    end
+    isempty(copies.starts) && return fs
+    keepat!(fs.starts, .!sparse)
+    keepat!(fs.lens, .!sparse)
+    keepat!(fs.slices, .!sparse)
+    return _addspans!(fs, copies, budget)
+end
+
+"""
+    SparseBody
+
+Stands in for a contiguous message body when only planned buffer windows
+were fetched. Every declared buffer must resolve inside a fetched span that
+was itself derived from the verified buffer table — the message-body
+authority invariant, sparse.
+"""
+struct SparseBody
+    bodylen::Int64
+    bodystart::Int64          # file coordinate of the body's first byte
+    spans::FetchedSpans
+end
+
+function _bodyslice(sb::SparseBody, offset::Int64, len::Int64)
+    (offset >= 0 && len >= 0 && offset <= sb.bodylen - len) ||
+        throw(ArgumentError("batch buffer escapes its message body"))
+    len == 0 && return BufferSlice()
+    return _spanslice(sb.spans, AC.checked_add(sb.bodystart, offset), len)
+end
+
+"""
+Ids of every dictionary inside the masked top-level subtrees, including the
+dictionaries a dictionary's values are encoded with.
+"""
+function _neededdictids(
+    fields,
+    fielddictids,
+    dictvaluefields,
+    mask::AbstractVector{Bool},
+    budget=nothing,
+)
+    _chargedict!(budget, Int64, Nothing, length(fielddictids), "scan dictionary-id set")
+    ids = Set{Int64}()
+    function walk(f::Field)
+        if f.type isa DictionaryType
+            id = fielddictids[f]
+            id in ids && return
+            push!(ids, id)
+            walk(dictvaluefields[id])
+            return
+        end
+        foreach(walk, f.children)
+    end
+    for (j, f) in enumerate(fields)
+        mask[j] && walk(f)
+    end
+    return ids
+end
+
+# The last `n` bytes of the object, from its cached tail window.
+function _lastbytes(sf::SourceFile, n::Int, budget)
+    tail, _ = _fetchtail(sf, budget)
+    return tail[(end - n + 1):end]
+end
+
+# The Footer's bytes: from the cached tail window when it holds them.
+function _footerbytes(sf::SourceFile, start::Int64, len::Int64, budget)
+    tail, tailstart = _fetchtail(sf, budget)
+    start >= tailstart || return _fetchfooter(sf, start, len, budget)
+    _chargevector!(budget, UInt8, len, "footer allocation")
+    return tail[(start - tailstart + 1):(start - tailstart + len)]
+end
+
+"""
+One record block's row count from one range request for its metadata, with
+the frame discipline of a scan's metadata pass: extent bounds before the
+fetch, the fetch and parse charged to the caller's cumulative budget,
+`_blockmeta` framing (continuation prefix, declared length, verified graph,
+body-length cross-check), header kind, footer-version agreement,
+and compression rejection.
+"""
+function _rangedbatchrows(
+    sf::SourceFile,
+    block::NTuple{3,Int64},
+    version::Int16,
+    fields::AbstractVector{Field},
+    budget::AllocationBudget,
+)
+    _, metalen, bodylen = block
+    declared = metalen - 8
+    _checkblocklengths(declared, bodylen, sf.limits)
+    _chargevector!(budget, UInt8, metalen, "metadata range fetch")
+    payload = _fetchexact(sf, block[1], metalen)
+    msg, v, header_type, _ =
+        _blockmeta(BufferSlice(heapregion(payload), 0, metalen), block, sf.limits, budget)
+    header_type == UInt8(3) ||
+        throw(ValidationError("footer record block is not a record batch"))
+    _filemetadataversion(version, v)
+    rejectexperimentalcompression(msg, v, header_type)
+    return _recordbatchmeta(msg.header::Meta.RecordBatch, fields, sf.limits, bodylen)
+end
+
+"Whether an output keeps its source field: no override, or a no-op one."
+_keepsfield(bc::Tables.BoundColumn, precol) =
+    bc.type === nothing || _eltypeof(precol) <: Union{bc.type,Missing}
+
+"""
+The OUTPUT schema of a scan: bound source fields under their output names.
+`precols` supplies each output's pre-override (facade-narrowed) column, so
+override keep/drop follows the SAME actual-subtype decision the conversion
+made: a no-op override keeps its retained field; a real conversion drops it
+(writing the result back to Arrow then re-infers the column).
+"""
+function _boundschema(schema, sourcefields, b::Tables.BoundScan, precols, budget=nothing)
+    schema === nothing && return nothing
+    _chargevector!(budget, AC.Field, length(b.columns), "scan output fields")
+    outfields = AC.Field[]
+    sizehint!(outfields, length(b.columns))
+    for (i, bc) in enumerate(b.columns)
+        f = sourcefields[bc.index]
+        i <= length(precols) && !_keepsfield(bc, precols[i]) && continue
+        # Metadata and children are immutable Core values. Share them instead
+        # of copying the same schema subtrees once per aliased selection.
+        _chargeobject!(budget, sizeof(bc.name), "scan field name")
+        outname = String(bc.name)
+        _chargeobject!(budget, Base.elsize(Vector{AC.Field}), "scan output field")
+        push!(outfields, AC.Field(outname, f.type, f.nullable, f.metadata, f.children))
+    end
+    _chargeobject!(budget, Base.elsize(Vector{AC.Schema}), "scan output schema")
+    return AC.Schema(
+        AC.FrozenVector{AC.Field}(outfields, nothing),
+        schema.metadata,
+        schema.endianness,
+    )
+end
+
+# A select override of a time-of-day column with a `Dates.Period` type reads
+# its stored ticks as periods (`_timeperiods`), so its values are not checked
+# against a day's length.
+_periodoverride(bc::Tables.BoundColumn, f::AC.Field) =
+    bc.type !== nothing &&
+    Base.nonmissingtype(bc.type) <: Dates.Period &&
+    f.type isa AC.TimeType
+# A select override of a `JuliaLang.Symbol` column with a string type reads its
+# stored strings, so the read creates no Symbol (`Limits.max_new_symbols`).
+function _symboloverride(bc::Tables.BoundColumn, f::AC.Field)
+    bc.type === nothing && return false
+    Base.nonmissingtype(bc.type) <: AbstractString || return false
+    ext = _arrowtypesextension(f)
+    return ext !== nothing && first(ext) == "JuliaLang.Symbol"
+end
+# Whether output `bc` of field `f` reads the stored values (see above). Other
+# outputs of the field, and a filter on it, read its public values.
+_rawoverride(bc::Tables.BoundColumn, f::AC.Field) =
+    _periodoverride(bc, f) || _symboloverride(bc, f)
+
+# A time-of-day column's stored ticks, not checked against a day's length.
+function _storedticks(f::AC.Field, d::AC.ArrayData, budget)
+    S = _rawdeclaredbasetype(f.type)
+    _chargeobject!(budget, _VIEW_OBJECT_BYTES, "column view")
+    nullable = Missing <: _declaredeltype(f, false) || _viewnulls(f, d)
+    return _primitive(nullable ? Union{Missing,S} : S, S, Nothing, d, budget)
+end
+
+# The stored values of batch column `d` that a raw override of field `f` reads.
+_rawbatchcolumn(f::AC.Field, d::AC.ArrayData, budget) =
+    f.type isa AC.TimeType ? _storedticks(f, d, budget) : _storagebatchcolumn(f, d, budget)
+
+# ===========================================================================
+# The scan executor: one planner for IPC files, one executor for every source
+# ===========================================================================
+
+# One record batch a scan reads: its decode plan, over a region, fetched
+# ranges, or a stream message's body, and the dictionaries in effect for it.
+struct _ScanRecord{B}
+    plan::_RecordPlan{B}
+    dictionaries::Dict{Int64,ArrayData}
+end
+
+# What decoding one source's record batches needs besides their plans.
+struct _Decoder{F<:AbstractVector{Field}}
+    fields::F
+    fielddictids::IdDict{Field,Int64}
+    validated::AC._ValidatedDictionaries
+    limits::Limits
+end
+
+_decodefield(dec::_Decoder, r::_ScanRecord, j::Int, state::DecodeState) = _decodeplanned(
+    r.plan,
+    j,
+    dec.fields[j],
+    r.dictionaries,
+    dec.fielddictids,
+    dec.limits,
+    dec.validated,
+    state,
+)
+
+_rowcount(r::_ScanRecord) = Int(r.plan.rblen)
+
+_columndictionary(dec::_Decoder, r::_ScanRecord, j::Int) =
+    get(r.dictionaries, dec.fielddictids[dec.fields[j]], nothing)
+
+# The dictionaries a stream's view pools may keep for this record batch.
+_recorddictionaries(r::_ScanRecord) = values(r.dictionaries)
+
+# A record batch that arrives decoded, from a C data or C stream import.
+struct _DecodedRecord
+    batch::AC.RecordBatch
+end
+
+_decodefield(::_Decoder, r::_DecodedRecord, j::Int, ::DecodeState) = r.batch.columns[j]
+_rowcount(r::_DecodedRecord) = Int(r.batch.nrows)
+_columndictionary(::_Decoder, r::_DecodedRecord, j::Int) = r.batch.columns[j].dictionary
+# Its columns reach every dictionary in effect (see `_markpools!`).
+_recorddictionaries(r::_DecodedRecord) = r.batch.columns
+
+# What building a scan's columns shares: view pools and ArrowTypes conversion
+# (under `lock`: its caches are not thread-safe).
+struct _ScanContext
+    views::_ViewContext
+    arrowtypes::_ArrowTypesContext
+    lock::ReentrantLock
+end
+
+_ScanContext(views::_ViewContext, arrowtypes) =
+    _ScanContext(views, arrowtypes, ReentrantLock())
+
+"""
+One decoded batch column of a scan, in the public domain: the view a full
+read gives, or the materialized column.
+"""
+function _scanbatchcolumn(f::AC.Field, d::AC.ArrayData, ctx::_ScanContext)
+    _viewable(f) && return _viewcolumn(f, AC.ArrayData[d], ctx.views)
+    return @lock ctx.lock _facadesinglecolumn(f, d, ctx.arrowtypes)
+end
+
+# Rows `rows` of batch column `d` of field `f`, in memory the result owns: a
+# string or binary column copies just those values' bytes.
+function _keptcolumn(f::AC.Field, d::AC.ArrayData, rows, ctx::_ScanContext)
+    if _isstringlayout(f.type) && _viewable(f)
+        return _rowsof(_vieweltype(f, AC.ArrayData[d], ctx.views), d, rows)
+    end
+    return _rowsof(_scanbatchcolumn(f, d, ctx), rows)
+end
+
+# The column a full read of no record batches gives field `f`.
+_emptycolumn(f::AC.Field, ctx::_ScanContext) =
+    _viewable(f) ? _viewcolumn(f, AC.ArrayData[], ctx.views) :
+    @lock ctx.lock _facadecolumn(f, Any[], ctx.arrowtypes)
+
+_filtermask(b::Tables.BoundScan, names, columns, n::Int) =
+    _uninferred(Tables.filtermask, b, _ScanColumns(names, columns, n))::AbstractVector{Bool}
+
+"""
+The rows of a batch of `n` rows where `b`'s filter is `true`, evaluated over
+its filter columns `columns` (named `names`) in chunks of rows on up to
+`ntasks` tasks. A filter that reads no column is row-invariant: one
+evaluation covers the batch.
+"""
+function _matchingrows(b::Tables.BoundScan, names, columns, n::Int, ntasks::Int)
+    isempty(columns) && return _zerofieldpredicate(b.filter) === true ? (1:n) : (1:0)
+    chunk = ntasks > 1 ? max(_STRING_CHUNK_ROWS, cld(n, ntasks)) : max(n, 1)
+    nchunks = cld(n, chunk)
+    nchunks <= 1 && return findall(_filtermask(b, names, columns, n))
+    found = Vector{Vector{Int}}(undef, nchunks)
+    _foreach(nchunks, ntasks) do c, _
+        lo = (c - 1) * chunk + 1
+        hi = min(c * chunk, n)
+        sub = AbstractVector[view(col, lo:hi) for col in columns]
+        found[c] = findall(_filtermask(b, names, sub, hi - lo + 1)) .+ (lo - 1)
+        return nothing
+    end
+    return reduce(vcat, found)
+end
+
+# Decode fields `idxs` of record `r` into `cols` on up to `ntasks` tasks, task
+# `w` with codec state `states[w]`.
+function _decoderecord!(cols, dec::_Decoder, r, idxs, states, ntasks::Int)
+    _foreach(length(idxs), ntasks) do q, w
+        j = idxs[q]
+        cols[j] = _decodefield(dec, r, j, states[w])
+        return nothing
+    end
+    return cols
+end
+
+# Call `work(k, states, tasks)` for each record `k` in `ks` on up to `ntasks`
+# tasks. With fewer records than tasks, each record gets several tasks (and
+# that many codec states) for its own columns and rows.
+function _eachrecord(work, ks, budget, ntasks::Int)
+    isempty(ks) && return nothing
+    outer = min(length(ks), ntasks)
+    inner = max(1, ntasks ÷ outer)
+    states = [DecodeState(budget) for _ = 1:(outer * inner)]
+    try
+        _foreach(length(ks), outer) do q, w
+            work(ks[q], view(states, ((w - 1) * inner + 1):(w * inner)), inner)
+            return nothing
+        end
+    finally
+        foreach(close, states)
+    end
+    return nothing
+end
+
+# The mask over `n` fields that selects fields `idxs`.
+function _fieldmask(idxs, n::Int)
+    mask = falses(n)
+    mask[idxs] .= true
+    return mask
+end
+
+# Whether a scan keeps every row of every batch it reads.
+_selectsonly(b::Tables.BoundScan) =
+    b.filter === nothing && b.limit === nothing && b.offset == 0
+
+# The values (rows times decoded columns) that make one more decode task worth it.
+const _VALUES_PER_TASK = 1 << 18
+# At most `ntasks` tasks, one per `_VALUES_PER_TASK` values to decode.
+_decodetasks(ntasks::Int, values::Integer) =
+    min(ntasks, max(1, Int(cld(values, _VALUES_PER_TASK))))
+
+"""
+Read scan `plan` from `records`, the record batches it may keep, and return
+its columns, row count, and the offset rows it skipped. Without a filter
+every row of a batch is kept, or `windows[k]`, the rows of record `k` in the
+scan's `offset`/`limit` window. A filter reads its filter columns first and
+the other selected columns only for batches that keep rows; without a
+`limit` or `offset`, batches run on up to `ntasks` tasks, and a batch with
+tasks to spare evaluates the filter in chunks of rows (`ntasks` is capped by
+the values to decode: see `_VALUES_PER_TASK`). Kept rows are copied:
+string and binary columns hold just their values' bytes. A scan that keeps
+every row builds the columns a full read builds. `_fetch!(bodies, ks, mask)`
+makes the bodies of the fields `mask` selects of records `ks` readable first.
+"""
+function _runscan(
+    records::Vector,
+    dec::_Decoder,
+    plan::_ScanPlan,
+    bodies,
+    ctx::_ScanContext,
+    budget::AllocationBudget;
+    ntasks::Int,
+    lazy::Bool,
+    windows=nothing,
+)
+    b = plan.bound
+    fields = dec.fields
+    nf = length(fields)
+    n = length(records)
+    # The batches' rows together must fit an `Int`, whatever the scan keeps.
+    total = 0
+    for r in records
+        total = _addscanrows(total, Int64(_rowcount(r)))
+    end
+    skipped = 0
+    if b.filter === nothing && windows === nothing && !_selectsonly(b)
+        windows = fill(1:0, n)
+        rowcounts = Int64[_rowcount(r) for r in records]
+        for (k, skip, take) in _batchwindow(rowcounts, b.offset, b.limit, budget)
+            windows[k] = (Int(skip) + 1):(Int(skip) + Int(take))
+        end
+        skipped = min(b.offset, total)
+    end
+    outidx = Int[c.index for c in b.columns]
+    raw = Bool[_rawoverride(c, fields[c.index]) for c in b.columns]
+    filteridx = _deduplicatesorted!(copy(b.filtercols))
+    decodeidx = _deduplicatesorted!(vcat(outidx, filteridx))
+    # A task pays for its spawn and wake-up only with enough values to decode,
+    # so a small batch (one `Arrow.Stream` step, say) runs on the calling task.
+    ntasks = _decodetasks(ntasks, total * length(decodeidx))
+    if b.filter === nothing && windows === nothing && !any(raw)
+        _fetch!(bodies, 1:n, _fieldmask(decodeidx, nf))
+        _chargevector!(budget, Union{Nothing,ArrayData}, n * nf, "batch columns")
+        decoded = [Vector{Union{Nothing,ArrayData}}(nothing, nf) for _ = 1:n]
+        m = length(decodeidx)
+        states = [DecodeState(budget) for _ = 1:min(ntasks, max(1, n * m))]
+        try
+            _foreach(n * m, ntasks) do item, w
+                k, q = divrem(item - 1, m) .+ (1, 1)
+                j = decodeidx[q]
+                decoded[k][j] = _decodefield(dec, records[k], j, states[w])
+                return nothing
+            end
+        finally
+            foreach(close, states)
+        end
+        batches = [(columns=c,) for c in decoded]
+        columns = _buildcolumns(
+            fields,
+            batches,
+            outidx,
+            ctx.arrowtypes,
+            ctx.views,
+            ntasks;
+            lazy=lazy,
+        )
+        return columns, total, 0
+    end
+    firstidx = b.filter === nothing ? decodeidx : filteridx
+    restidx = setdiff(decodeidx, firstidx)
+    firstmask, restmask = _fieldmask(firstidx, nf), _fieldmask(restidx, nf)
+    decodemask = firstmask .| restmask
+    filternames = Symbol[plan.names[i] for i in filteridx]
+    parts = Matrix{Any}(nothing, length(outidx), n)
+    kept = Vector{Any}(nothing, n)
+    # A filter with a window composes it over the qualifying rows, in order.
+    windowed = b.filter !== nothing && (b.limit !== nothing || b.offset > 0)
+    skip = Ref(Int64(b.offset))
+    take = Ref(b.limit === nothing ? Int64(-1) : Int64(b.limit))
+    # Output columns of the fields `idxs` keep record `k`'s rows: a raw
+    # override's from the stored values, others from a filter column already
+    # built (`built[i]`) or from the decoded batch.
+    function gather!(k, cols, idxs, built=nothing)
+        rows = kept[k]
+        for (c, bc) in enumerate(b.columns)
+            i = bc.index
+            insorted(i, idxs) || continue
+            d = cols[i]::ArrayData
+            parts[c, k] =
+                raw[c] ? _rowsof(_rawbatchcolumn(fields[i], d, ctx.views.budget), rows) :
+                built === nothing ? _keptcolumn(fields[i], d, rows, ctx) :
+                _rowsof(built[i], rows)
+        end
+        return nothing
+    end
+    function first!(k, states, tasks)
+        r = records[k]
+        cols = _decoderecord!(Vector{Any}(nothing, nf), dec, r, firstidx, states, tasks)
+        built = nothing
+        rows = if b.filter === nothing
+            windows === nothing ? (1:_rowcount(r)) : windows[k]
+        else
+            built = Vector{Any}(nothing, nf)
+            for i in filteridx
+                built[i] = _scanbatchcolumn(fields[i], cols[i], ctx)
+            end
+            filtercols = AbstractVector[built[i] for i in filteridx]
+            _matchingrows(b, filternames, filtercols, _rowcount(r), tasks)
+        end
+        if windowed
+            nskip = min(skip[], Int64(length(rows)))
+            skip[] -= nskip
+            ntake =
+                take[] < 0 ? Int64(length(rows)) - nskip :
+                min(take[], Int64(length(rows)) - nskip)
+            take[] < 0 || (take[] -= ntake)
+            rows = rows[(Int(nskip) + 1):(Int(nskip) + Int(ntake))]
+        end
+        isempty(rows) && return nothing
+        kept[k] = rows
+        gather!(k, cols, firstidx, built)
+        return nothing
+    end
+    function rest!(k, states, tasks)
+        cols = _decoderecord!(
+            Vector{Any}(nothing, nf),
+            dec,
+            records[k],
+            restidx,
+            states,
+            tasks,
+        )
+        gather!(k, cols, restidx)
+        return nothing
+    end
+    if windowed
+        states = [DecodeState(budget) for _ = 1:ntasks]
+        try
+            for k = 1:n
+                take[] == 0 && break
+                # One batch at a time: its own values decide its tasks.
+                tasks = _decodetasks(ntasks, _rowcount(records[k]) * length(decodeidx))
+                # A small body's columns cost one round trip, not two.
+                _fetch!(bodies, k:k, _smallrecord(bodies, k) ? decodemask : firstmask)
+                first!(k, states, tasks)
+                if kept[k] !== nothing && !isempty(restidx)
+                    _fetch!(bodies, k:k, restmask)
+                    rest!(k, states, tasks)
+                end
+                _release!(bodies, k)
+            end
+        finally
+            foreach(close, states)
+        end
+    else
+        ks = windows === nothing ? collect(1:n) : [k for k = 1:n if !isempty(windows[k])]
+        _fetch!(bodies, ks, firstmask)
+        _eachrecord(first!, ks, budget, ntasks)
+        if !isempty(restidx)
+            ks = [k for k in ks if kept[k] !== nothing]
+            _fetch!(bodies, ks, restmask)
+            _eachrecord(rest!, ks, budget, ntasks)
+        end
+    end
+    columns = Vector{AbstractVector}(undef, length(outidx))
+    for c in eachindex(outidx)
+        ps = Any[p for p in view(parts, c, :) if p !== nothing]
+        columns[c] =
+            isempty(ps) ? _emptycolumn(fields[outidx[c]], ctx) : _joinparts(ps, budget)
+    end
+    nrows = 0
+    for rows in kept
+        rows === nothing || (nrows = _addscanrows(nrows, Int64(length(rows))))
+    end
+    windowed && (skipped = Int(b.offset - skip[]))
+    return columns, nrows, skipped
+end
+
+"""
+The Table of scan `plan` over `records`: `_runscan`'s columns under their
+output names with the type overrides applied, the bound schema, and the
+dictionary columns' category pools.
+"""
+function _scantable(
+    records::Vector,
+    dec::_Decoder,
+    plan::_ScanPlan,
+    bodies,
+    ctx::_ScanContext,
+    schema,
+    regions,
+    budget::AllocationBudget;
+    ntasks::Int,
+    lazy::Bool,
+    windows=nothing,
+)
+    columns, nrows, skipped =
+        _runscan(records, dec, plan, bodies, ctx, budget; ntasks, lazy, windows)
+    b = plan.bound
+    fields = dec.fields
+    _chargevector!(budget, AbstractVector, length(columns), "pre-override scan columns")
+    precols = AbstractVector[]
+    sizehint!(precols, length(columns))
+    for (i, bc) in enumerate(b.columns)
+        f = fields[bc.index]
+        col = columns[i]
+        if _periodoverride(bc, f)
+            columns[i] =
+                _uninferred(_timeperiods, f.type, col, Base.nonmissingtype(bc.type))
+            # A real conversion: the output does not keep the time field.
+            push!(precols, Dates.Time[])
+        elseif _symboloverride(bc, f)
+            # The stored strings, without creating a Symbol per value.
+            columns[i] = _uninferred(_applyoverride, bc.type, col, budget)
+            push!(precols, Symbol[])
+        else
+            push!(precols, col)
+            bc.type === nothing ||
+                (columns[i] = _uninferred(_applyoverride, bc.type, col, budget))
+        end
+    end
+    # A dictionary column keeps its category pool, as a full read does, so a
+    # rewrite preserves category order (required when ordered).
+    _chargevector!(budget, Any, length(b.columns), "scan retained dictionary pools")
+    pools = Any[
+        fields[bc.index].type isa DictionaryType && _keepsfield(bc, precols[i]) ?
+        _retainedpool(fields[bc.index], _dictionariesof(dec, records, bc.index), ctx) :
+        nothing for (i, bc) in enumerate(b.columns)
+    ]
+    names = Symbol[c.name for c in b.columns]
+    bound = _boundschema(schema, fields, b, precols, budget)
+    return _table(names, columns, bound, regions, nrows, pools, budget), skipped
+end
+
+# The distinct dictionaries of column `j` across `records`, in order.
+function _dictionariesof(dec::_Decoder, records, j::Int)
+    dictionaries = AC.ArrayData[]
+    seen = Base.IdSet{AC.ArrayData}()
+    for r in records
+        d = _columndictionary(dec, r, j)
+        (d === nothing || d in seen) && continue
+        push!(seen, d)
+        push!(dictionaries, d)
+    end
+    return dictionaries
+end
+
+_retainedpool(f::AC.Field, dictionaries, ctx::_ScanContext) =
+    @lock ctx.lock _retainedpool(f, dictionaries, ctx.arrowtypes)
+
+# The record bodies of a scan whose bytes are all in memory are readable.
+_fetch!(::Nothing, ks, mask, extra=NTuple{2,Int64}[]) = nothing
+_release!(::Nothing, k) = nothing
+_smallrecord(::Nothing, k) = false
+
+# What fetching a byte-range scan's record bodies needs: the bytes fetched so
+# far, which fields' bodies of each record batch they hold, and each record
+# batch's Block, header, variadic counts, and codec.
+struct _RangedBodies
+    sf::SourceFile
+    spans::FetchedSpans
+    fetched::BitMatrix   # [field, record]
+    blocks::Vector{NTuple{3,Int64}}
+    headers::Vector{Meta.RecordBatch}
+    variadics::Vector{Vector{Int64}}
+    codecs::Vector{Int8}
+    fields::Vector{Field}
+    budget::AllocationBudget
+end
+
+"""
+Fetch the body ranges of the fields `mask` selects of record batches `ks`,
+and the ranges `extra`, that `rb.spans` does not hold yet, in one coalesced
+round, and return every range planned, fetched now or before. Every planned
+subtree's metadata is validated first, so a corrupt buffer table fails
+before its ranges are requested.
+"""
+function _fetch!(rb::_RangedBodies, ks, mask, extra=NTuple{2,Int64}[])
+    limits = rb.sf.limits
+    count = Int64(length(extra))
+    masks = BitVector[mask .& .!view(rb.fetched, :, k) for k in ks]
+    for (k, m) in zip(ks, masks)
+        any(m) || continue
+        count = AC.checked_add(
+            count,
+            _validatebodyplan(
+                rb.headers[k],
+                rb.fields,
+                limits,
+                rb.codecs[k],
+                m,
+                rb.variadics[k],
+            ),
+        )
+    end
+    count <= typemax(Int) ||
+        throw(ValidationError("body range count exceeds the host index range"))
+    _chargevector!(rb.budget, NTuple{2,Int64}, count, "body range plan")
+    ranges = Vector{NTuple{2,Int64}}(undef, Int(count))
+    copyto!(ranges, extra)
+    at = length(extra)
+    for (k, mask) in zip(ks, masks)
+        any(mask) || continue
+        rb.fetched[:, k] .|= mask
+        block = rb.blocks[k]
+        buffers = something(rb.headers[k].buffers, Meta.Buffer[])
+        varidx = Ref(1)
+        bufidx = 1
+        for (j, fld) in enumerate(rb.fields)
+            span64 = _bufferspan(fld, rb.variadics[k], varidx)
+            span64 <= typemax(Int) || throw(
+                ValidationError("field buffer span $span64 exceeds the host index range"),
+            )
+            span = Int(span64)
+            if mask[j]
+                for q = bufidx:(bufidx + span - 1)
+                    q <= length(buffers) || throw(
+                        ValidationError(
+                            "metadata declares fewer buffers than the schema requires",
+                        ),
+                    )
+                    buf = buffers[q]
+                    len = Int64(buf.length)
+                    off = Int64(buf.offset)
+                    (off >= 0 && len >= 0 && AC.checked_add(off, len) <= block[3]) || throw(
+                        ValidationError(
+                            "batch buffer [$off, $len] escapes its message body",
+                        ),
+                    )
+                    len == 0 && continue
+                    at += 1
+                    ranges[at] = (block[1] + block[2] + off, len)
+                end
+            end
+            bufidx += span
+        end
+    end
+    at == length(ranges) ||
+        throw(AssertionError("body range preflight count changed during planning"))
+    _chargevector!(rb.budget, NTuple{2,Int64}, length(ranges), "unfetched body ranges")
+    unfetched = filter(r -> _spanholding(rb.spans, r[1], r[2]) == 0, ranges)
+    fetched = _fetchspans(
+        rb.sf,
+        unfetched,
+        rb.sf.gapbytes;
+        budget=rb.budget,
+        what="body range fetch",
+    )
+    _addspans!(rb.spans, fetched, rb.budget)
+    return ranges
+end
+
+# Whether record `k`'s body is small (`_smallbody`).
+_smallrecord(rb::_RangedBodies, k) = _smallbody(rb.blocks[k][3], rb.sf.gapbytes)
+
+# Record `k` is read: a scan that reads batch by batch frees its fetched bytes.
+function _release!(rb::_RangedBodies, k)
+    offset, metalen, bodylen = rb.blocks[k]
+    _dropspans!(rb.spans, offset, offset + metalen + bodylen)
+    return nothing
+end
+
+_gapbytes(sf::SourceFile) = sf.gapbytes
+_gapbytes(::OwnerRegion) = Int64(0)
+
+"""
+Scan `plan` over the IPC file in `src`, a region (whose bytes are all in
+memory) or a byte-range source, with verified footer `ft`. One pass reads
+every Block's metadata: over a source, in coalesced ranges that also cover
+the start of each body, or all of a small body. Row counts from it choose the
+window; then the decode set's dictionaries decode in footer order, and
+`_runscan` reads the record batches. Over a source, the dictionary bodies
+and the first record bodies share one request round, and only the bodies of
+the decode set's buffers are fetched.
+"""
+function _scanfile(
+    src,
+    ft,
+    plan::_ScanPlan,
+    limits::Limits,
+    budget::AllocationBudget,
+    views::_ViewContext,
+    regions;
+    ntasks::Int,
+    lazy::Bool,
+)
+    b = plan.bound
+    fields = ft.fields
+    dictblocks, recordblocks = ft.dictblocks, ft.recordblocks
+    ndict, nrec = length(dictblocks), length(recordblocks)
+    nmeta = ndict + nrec
+    _chargevector!(budget, NTuple{3,Int64}, nmeta, "scan metadata blocks")
+    metablocks = vcat(dictblocks, recordblocks)
+    for (_, metalen, bodylen) in metablocks
+        _checkblocklengths(metalen - 8, bodylen, limits)
+    end
+    # Each block's metadata comes with the start of its body, or all of a small
+    # body: the selected buffers often lie there, and an over-read of a few
+    # hundred KiB costs less than a second request round. A scan with a row
+    # window needs few of the bodies, so it reads metadata alone.
+    gap = _gapbytes(src)
+    limitedfilter = b.filter !== nothing && b.limit !== nothing
+    bodygap = b.limit === nothing && b.offset == 0 ? gap : Int64(0)
+    _chargevector!(budget, NTuple{2,Int64}, nmeta, "metadata range plan")
+    metaranges = NTuple{2,Int64}[
+        (bl[1], AC.checked_add(bl[2], _speculativebody(bl[3], bodygap))) for
+        bl in metablocks
+    ]
+    # A filtered limit may end at its first batch. Coalescing across its
+    # successors' bodies would download those rows before the filter runs.
+    spans = _fetchspans(
+        src,
+        metaranges,
+        limitedfilter ? Int64(0) : gap;
+        budget=budget,
+        what="metadata range fetch",
+    )
+    _chargevector!(budget, Tuple{Meta.Message,Int16}, nmeta, "parsed block metadata")
+    msgs = Vector{Meta.Message}(undef, nmeta)
+    versions = Vector{Int16}(undef, nmeta)
+    headertypes = Vector{UInt8}(undef, nmeta)
+    _foreach(nmeta, ntasks) do i, _
+        block = metablocks[i]
+        msg, v, ht, _ =
+            _blockmeta(_spanslice(spans, block[1], block[2]), block, limits, budget)
+        msgs[i], versions[i], headertypes[i] = msg, v, ht
+        return nothing
+    end
+    for i = 1:nmeta
+        isdict = i <= ndict
+        headertypes[i] == (isdict ? UInt8(2) : UInt8(3)) || throw(
+            ValidationError(
+                isdict ? "footer dictionary block is not a dictionary batch" :
+                "footer record block is not a record batch",
+            ),
+        )
+        _filemetadataversion(ft.version, versions[i], versions[1])
+        rejectexperimentalcompression(msgs[i], versions[i], headertypes[i])
+    end
+    # Row counts are in the metadata, not the Footer: a window needs them.
+    _chargevector!(budget, Meta.RecordBatch, nrec, "record-batch headers")
+    headers = Meta.RecordBatch[msgs[ndict + p].header::Meta.RecordBatch for p = 1:nrec]
+    _chargevector!(budget, Vector{Int64}, nrec, "record variadic-count cache")
+    variadics = Vector{Vector{Int64}}(undef, nrec)
+    _chargevector!(budget, Int64, nrec, "scan batch row counts")
+    rowcounts = Vector{Int64}(undef, nrec)
+    _foreach(nrec, ntasks) do p, _
+        variadics[p] = variadiccounts(headers[p])
+        rowcounts[p] =
+            _recordbatchmeta(headers[p], fields, limits, recordblocks[p][3], variadics[p])
+        return nothing
+    end
+    # The file's rows together must fit an `Int`, whatever the scan keeps.
+    total = 0
+    for rows in rowcounts
+        total = _addscanrows(total, rows)
+    end
+    window =
+        b.filter === nothing && (b.limit !== nothing || b.offset > 0) ?
+        _batchwindow(rowcounts, b.offset, b.limit, budget) :
+        Tuple{Int,Int64,Int64}[(p, Int64(0), rowcounts[p]) for p = 1:nrec]
+    decodemask = _fieldmask(
+        _deduplicatesorted!(vcat(Int[c.index for c in b.columns], b.filtercols)),
+        length(fields),
+    )
+    # The decode set's dictionaries decode whole; the others are checked from
+    # their metadata only.
+    needed =
+        isempty(window) ? Set{Int64}() :
+        _neededdictids(fields, ft.fielddictids, ft.dictvaluefields, decodemask, budget)
+    _chargedict!(budget, Int64, Nothing, ndict, "seen dictionary ids")
+    seenids = Set{Int64}()
+    _chargevector!(budget, Int, ndict, "selected dictionary blocks")
+    wanted = Int[]
+    for (i, block) in enumerate(dictblocks)
+        header = msgs[i].header::Meta.DictionaryBatch
+        haskey(ft.dictids, header.id) ||
+            throw(ValidationError("dictionary batch has unknown id $(header.id)"))
+        _dictionarytransition(header.id, header.isDelta, header.id in seenids; file=true)
+        push!(seenids, header.id)
+        rb = header.data
+        vf = ft.dictvaluefields[header.id]
+        rbvariadics = variadiccounts(rb)
+        _recordbatchmeta(rb, (vf,), limits, block[3], rbvariadics)
+        if header.id in needed
+            src isa SourceFile && _validatebodyplan(
+                rb,
+                (vf,),
+                limits,
+                _batchcodec(rb.compression, versions[i]),
+                (true,),
+                rbvariadics,
+            )
+            push!(wanted, i)
+        end
+    end
+    for id in needed
+        id in seenids || throw(
+            ValidationError(
+                "record batch references dictionary id $id before its dictionary batch",
+            ),
+        )
+    end
+    candidates = Int[p for (p, _, _) in window]
+    bodies =
+        src isa SourceFile ?
+        _RangedBodies(
+            src,
+            spans,
+            falses(length(fields), length(candidates)),
+            recordblocks[candidates],
+            headers[candidates],
+            variadics[candidates],
+            Int8[
+                _batchcodec(headers[p].compression, versions[ndict + p]) for p in candidates
+            ],
+            fields,
+            budget,
+        ) : nothing
+    # One round fetches the decode set's dictionary bodies and, unless a
+    # filtered limit reads batch by batch, the bodies `_runscan` reads first.
+    dictranges = NTuple{2,Int64}[
+        (dictblocks[i][1] + dictblocks[i][2], dictblocks[i][3]) for
+        i in wanted if dictblocks[i][3] > 0
+    ]
+    firstmask =
+        b.filter === nothing ? decodemask :
+        _fieldmask(_deduplicatesorted!(copy(b.filtercols)), length(fields))
+    ranges = _fetch!(
+        bodies,
+        limitedfilter ? (1:0) : eachindex(candidates),
+        firstmask,
+        dictranges,
+    )
+    # A select's columns view the ranges it fetched, dictionaries included.
+    bodies === nothing || !_selectsonly(b) || _compactspans!(spans, ranges, budget)
+    _chargedict!(budget, Int64, ArrayData, length(wanted), "decoded dictionary table")
+    dicts = Dict{Int64,ArrayData}()
+    _chargedict!(
+        budget,
+        ArrayData,
+        Nothing,
+        length(wanted),
+        "validated dictionary identities",
+    )
+    validated = AC._ValidatedDictionaries()
+    state = DecodeState(budget)
+    try
+        for i in wanted
+            block = dictblocks[i]
+            header = msgs[i].header::Meta.DictionaryBatch
+            vf = ft.dictvaluefields[header.id]
+            decoded = _decodedictionary(
+                header.data,
+                _spanslice(spans, block[1] + block[2], block[3]),
+                versions[i],
+                vf,
+                dicts,
+                ft.fielddictids,
+                limits,
+                state,
+            )
+            _updatedictionary!(
+                dicts,
+                validated,
+                header.id,
+                header.isDelta,
+                vf,
+                decoded,
+                limits,
+                budget;
+                file=true,
+            )
+        end
+    finally
+        close(state)
+    end
+    records = Vector{_ScanRecord{SparseBody}}(undef, length(candidates))
+    _foreach(length(candidates), ntasks) do q, _
+        p = candidates[q]
+        block = recordblocks[p]
+        header = headers[p]
+        _scanmissingdicts(fields, header.nodes, dicts, ft.fielddictids, decodemask)
+        body = SparseBody(block[3], block[1] + block[2], spans)
+        records[q] = _ScanRecord(
+            _recordplan(header, body, versions[ndict + p], fields, limits),
+            dicts,
+        )
+        return nothing
+    end
+    windows =
+        b.filter === nothing && !_selectsonly(b) ?
+        UnitRange{Int}[
+            (Int(skip) + 1):(Int(skip) + Int(take)) for (_, skip, take) in window
+        ] : nothing
+    dec = _Decoder(fields, ft.fielddictids, validated, limits)
+    ctx = _ScanContext(views, _ArrowTypesContext(budget=budget))
+    return _scantable(
+        records,
+        dec,
+        plan,
+        bodies,
+        ctx,
+        _uniqueschema(ft.sch),
+        regions,
+        budget;
+        ntasks,
+        lazy,
+        windows,
+    )
+end
+
+# Record batch `i` of a file-format stream source, planned to decode the
+# fields `mask` selects, and what fetching its bodies needs (`nothing` when
+# they are in memory).
+_streamrecord(f::ArrowFile, i::Int, budget, mask) =
+    _ScanRecord(_fileplan(f, i, budget, mask), f.dictionaries), nothing
+
+# Over a byte-range source a batch that decodes every field, or whose body is
+# small, reads its whole block through the block reader, many blocks to a
+# request; one that decodes some fields of a large body reads its metadata
+# with the start of its body, and `_runscan` fetches the planned ranges it lacks.
+function _streamrecord(r::_RangedFile, i::Int, budget, mask)
+    sf = r.sf
+    block = r.recordblocks[i]
+    spans = nothing
+    if all(mask) || _smallbody(block[3], sf.gapbytes)
+        fm = first(_blockframe(r.blocks, r.recordblocks, i, r.dataend, budget))
+        msg, version, headertype, body = fm.msg, fm.version, fm.header_type, fm.body
+    else
+        range =
+            (block[1], AC.checked_add(block[2], _speculativebody(block[3], sf.gapbytes)))
+        spans = _fetchspans(
+            sf,
+            NTuple{2,Int64}[range],
+            sf.gapbytes;
+            budget=budget,
+            what="metadata range fetch",
+        )
+        meta = _spanslice(spans, block[1], block[2])
+        msg, version, headertype, _ = _blockmeta(meta, block, r.limits, budget)
+        body = SparseBody(block[3], block[1] + block[2], spans)
+    end
+    _filemetadataversion(r.footerversion, version)
+    headertype == UInt8(3) ||
+        throw(ValidationError("footer record block is not a record batch"))
+    rejectexperimentalcompression(msg, version, headertype)
+    header = msg.header::Meta.RecordBatch
+    variadics = variadiccounts(header)
+    _recordbatchmeta(header, r.fields, r.limits, block[3], variadics)
+    _scanmissingdicts(r.fields, header.nodes, r.dictionaries, r.fielddictids, mask)
+    record =
+        _ScanRecord(_recordplan(header, body, version, r.fields, r.limits), r.dictionaries)
+    spans === nothing && return record, nothing
+    bodies = _RangedBodies(
+        sf,
+        spans,
+        falses(length(r.fields), 1),
+        [block],
+        Meta.RecordBatch[header],
+        [variadics],
+        Int8[_batchcodec(header.compression, version)],
+        collect(Field, r.fields),
+        budget,
+    )
+    return record, bodies
+end
+
+"""
+Scan `plan` over the record batches of IPC stream `st` (`records`, planned as
+`_streamrecords` frames them).
+"""
+function _scanstream(
+    st::_StreamState,
+    pending::Vector{PendingRecord},
+    plan::_ScanPlan,
+    budget::AllocationBudget,
+    views::_ViewContext,
+    regions;
+    ntasks::Int,
+    lazy::Bool,
+)
+    b = plan.bound
+    records = _ScanRecord{BufferSlice}[_ScanRecord(p.plan, p.dictionaries) for p in pending]
+    dec = _Decoder(st.fields, st.fielddictids, st.validated, st.limits)
+    ctx = _ScanContext(views, _ArrowTypesContext(budget=budget))
+    return _scantable(
+        records,
+        dec,
+        plan,
+        nothing,
+        ctx,
+        _uniqueschema(st.schema),
+        regions,
+        budget;
+        ntasks,
+        lazy,
+    )
+end
+
+"Convert a column with the generic Tables.scan allocation contract."
+function _applyoverride(::Type{T}, col, budget=nothing) where {T}
+    eltype(col) <: Union{T,Missing} && return col
+    anymissing = any(ismissing, col)
+    E = anymissing ? Union{T,Missing} : T
+    _chargevector!(budget, E, length(col), "scan type override")
+    out = Tables.allocatecolumn(E, length(col))
+    V = Base.nonmissingtype(T)
+    @inbounds for i in eachindex(col)
+        x = col[i]
+        out[i] = ismissing(x) ? missing : convert(V, x)
+    end
+    return out
+end
diff --git a/src/sharedvalues.jl b/src/sharedvalues.jl
new file mode 100644
index 00000000..fb05dbd9
--- /dev/null
+++ b/src/sharedvalues.jl
@@ -0,0 +1,145 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Shared logical values belong in the facade; ArrowCore keeps wire storage.
+_decimalstorage(t::AC.DecimalType) =
+    t.bits == 32 ? Int32 :
+    t.bits == 64 ? Int64 : t.bits == 128 ? Int128 : DataDecimals.Int256
+_shareddecimal(t::AC.DecimalType) = 0 <= t.scale <= t.precision <= 76
+_decimalhost(t::AC.DecimalType) =
+    DataDecimals.Decimal{t.precision,t.scale,_decimalstorage(t)}
+_rawdeclaredbasetype(t::AC.DecimalType) =
+    t.bits == 32 ? Int32 : t.bits == 64 ? Int64 : Vector{UInt8}
+_rawdeclaredbasetype(t::AC.IntervalType) =
+    t.unit == AC.YEAR_MONTH ? Int32 :
+    t.unit == AC.DAY_TIME ? NamedTuple{(:days, :millis),Tuple{Int32,Int32}} :
+    NamedTuple{(:months, :days, :nanos),Tuple{Int32,Int32,Int64}}
+
+function _bytescoefficient(::Type{T}, x::AbstractVector{UInt8}) where {T}
+    U = unsigned(T)
+    u = zero(U)
+    for b in Iterators.reverse(x)
+        u = (u << 8) | U(b)
+    end
+    return reinterpret(T, u)
+end
+
+"""
+One shared-decimal scalar conversion, specialized on the host and storage
+types: the coefficient loop, the bound power, and the range check must all
+run unboxed, or a wide (128/256-bit) coefficient boxes on every operation.
+"""
+# A coefficient outside the declared precision reads as stored, as in Arrow
+# C++ (`DataDecimals` leaves that invariant to the producer).
+function _shareddecimalscalar(::Type{D}, ::Type{T}, precision::Int, x)::D where {D,T}
+    x isa D && return x
+    u =
+        x isa Integer ? T(x) :
+        x isa AbstractVector{UInt8} ? _bytescoefficient(T, x) :
+        throw(ArgumentError("unsupported decimal storage value"))
+    return reinterpret(D, u)
+end
+
+function _postconvert(t::AC.DecimalType, col, budget=nothing)
+    _shareddecimal(t) || return col
+    D = _decimalhost(t)
+    # Top-level columns already read as `D` (`_decimalcolumn`).
+    eltype(col) <: Union{Missing,D} && return col
+    T = _decimalstorage(t)
+    precision = Int(t.precision)
+    # The per-element call into the specialized converter is dynamic, so
+    # each element leaves a few transient boxes behind even over a
+    # concretely typed storage column.
+    budget === nothing || _charge!(
+        budget,
+        AC.checked_mul(Int64(length(col)), Int64(64)),
+        "facade decimal conversion temporaries",
+    )
+    return _mapcol(D, x -> _shareddecimalscalar(D, T, precision, x), col, budget)
+end
+
+function _postconvert(t::AC.IntervalType, col, budget=nothing)
+    return _mapcol(
+        Durations.Duration,
+        x ->
+            t.unit == AC.YEAR_MONTH ? Durations.Duration(x, 0, 0) :
+            t.unit == AC.DAY_TIME ?
+            Durations.Duration(0, x.days, Int64(x.millis) * 1_000_000) :
+            Durations.Duration(x.months, x.days, x.nanos),
+        col,
+        budget,
+    )
+end
+
+# Coefficients write as stored, as Arrow C++ writes them; precision is the
+# `validate_full` tier's check.
+function _shareddecimalraw(t::AC.DecimalType, x::DataDecimals.AbstractDecimal)
+    DataDecimals.scale(x) == t.scale ||
+        throw(ArgumentError("decimal scale does not match the Arrow schema"))
+    u = _decimalstorage(t)(DataDecimals.unscaled(x))
+    t.bits == 32 && return Int32(u)
+    t.bits == 64 && return Int64(u)
+    return UInt8[(u >> (8 * i)) & 0xff for i = 0:(t.bits ÷ 8 - 1)]
+end
+
+# Public values the writer lowers into interval storage.
+const _IntervalValue = Union{Durations.Duration,Dates.Month,Dates.Year}
+
+function _sharedintervalraw(t::AC.IntervalType, x::Union{Dates.Month,Dates.Year})
+    t.unit == AC.YEAR_MONTH && return Int32(_periodmonths(x))
+    return _sharedintervalraw(t, Durations.Duration(Int32(_periodmonths(x)), 0, 0))
+end
+
+function _sharedintervalraw(t::AC.IntervalType, x::Durations.Duration)
+    if t.unit == AC.YEAR_MONTH
+        iszero(x.days) && iszero(x.nanoseconds) ||
+            throw(ArgumentError("year-month interval cannot hold days or nanoseconds"))
+        return x.months
+    elseif t.unit == AC.DAY_TIME
+        iszero(x.months) && iszero(rem(x.nanoseconds, 1_000_000)) || throw(
+            ArgumentError("day-time interval requires zero months and exact milliseconds"),
+        )
+        return (days=x.days, millis=Int32(div(x.nanoseconds, 1_000_000)))
+    end
+    return (months=x.months, days=x.days, nanos=x.nanoseconds)
+end
+
+# Decimals write as decimal128 (precision <= 38) or decimal256, whatever their
+# storage type, as pyarrow, Polars, and DuckDB write them: Arrow 2.x and
+# readers on Arrow C++ before 18.0 do not read decimal32/64. A rewrite of an
+# Arrow column keeps its retained width.
+function _constructsharedpart(name, v, ::Type{D}) where {D<:DataDecimals.Decimal}
+    isconcretetype(D) || throw(
+        ArgumentError(
+            isempty(v) ?
+            "column $name is an empty decimal column, which needs a concrete " *
+            "precision, scale, and storage type" :
+            "column $name mixes decimal types ($D); an Arrow decimal column has one " *
+            "precision and scale, so convert its values to one Decimal{P,S}",
+        ),
+    )
+    P, S, _ = D.parameters
+    t = AC.DecimalType(P, S, P <= 38 ? 128 : 256)
+    f = AC.Field(name, t; nullable=Missing <: _eltypeof(v))
+    # `v`'s type is known at run time; see `_uninferred`.
+    return _uninferred(_retaineddecimal, f, v)::Tuple{AC.Field,AC.ArrayData}
+end
+function _constructsharedpart(name, v, ::Type{Durations.Duration})
+    t = AC.IntervalType(AC.MONTH_DAY_NANO)
+    f = AC.Field(name, t; nullable=Missing <: _eltypeof(v))
+    # `v`'s type is known at run time; see `_uninferred`.
+    return _uninferred(_retainedinterval, f, v)::Tuple{AC.Field,AC.ArrayData}
+end
diff --git a/src/show.jl b/src/show.jl
deleted file mode 100644
index 3a9b5564..00000000
--- a/src/show.jl
+++ /dev/null
@@ -1,64 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-# 2-arg show: show schema and list # of metadata entries if non-zero
-function Base.show(io::IO, table::Table)
-    ncols = length(Tables.columnnames(table))
-    print(io, "$(typeof(table)) with $(Tables.rowcount(table)) rows, $(ncols) columns,")
-    meta = getmetadata(table)
-    if meta !== nothing && !isempty(meta)
-        print(io, " ", length(meta), " metadata entries,")
-    end
-    sch = Tables.schema(table)
-    print(io, " and schema:\n")
-    show(IOContext(io, :print_schema_header => false), sch)
-    return nothing
-end
-
-# 3-arg show: show schema and show metadata entries adaptively according to `displaysize`
-function Base.show(io::IO, mime::MIME"text/plain", table::Table)
-    display_rows, display_cols = displaysize(io)
-    ncols = length(Tables.columnnames(table))
-    meta = getmetadata(table)
-    if meta !== nothing
-        display_rows -= 1 # decrement for metadata header line
-        display_rows -= min(length(meta), 2) # decrement so we can show at least 2 lines of metadata
-    end
-    print(
-        io,
-        "$(typeof(table)) with $(Tables.rowcount(table)) rows, $(ncols) columns, and ",
-    )
-    sch = Tables.schema(table)
-    print(io, "schema:\n")
-    schema_context = IOContext(
-        io,
-        :print_schema_header => false,
-        :displaysize => (max(display_rows, 3), display_cols),
-    )
-    schema_str = sprint(show, mime, sch; context=schema_context)
-    print(io, schema_str)
-    display_rows -= (count("\n", schema_str) + 1) # decrement for number of lines printed
-    if meta !== nothing
-        print(io, "\n\nwith metadata given by a ")
-        show(
-            IOContext(io, :displaysize => (max(display_rows, 5), display_cols)),
-            mime,
-            meta,
-        )
-    end
-    return nothing
-end
diff --git a/src/source.jl b/src/source.jl
new file mode 100644
index 00000000..3d115514
--- /dev/null
+++ b/src/source.jl
@@ -0,0 +1,84 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# =============================================================================
+# The byte-range source interface: what a remote (or any byte-addressable)
+# object must provide for `Arrow.Table` to read it with exact range requests.
+# =============================================================================
+
+"""
+    Arrow.AbstractArrowSource
+
+Supertype of sources that supply bytes by range, such as objects in cloud storage, for
+[`Arrow.Table`](@ref) and [`Arrow.Stream`](@ref). An implementation defines
+
+    Arrow.sourcelength(src)::Integer                  # total length in bytes
+    Arrow.readrange(src, offset, len)::Vector{UInt8}  # `len` bytes from 0-based `offset`
+
+and may define [`Arrow.concurrentreads`](@ref) to let several ranges be read at once.
+
+`Arrow.Table` with `select`, `drop`, `filter`, `limit`, `offset`, or `scan` reads the
+file-format footer from the end of the source, then fetches only the record batches and
+columns it needs (a record batch of at most 1 MiB whole), coalesced into a few ranges;
+without them, it fetches the whole source in 8 MiB ranges. `Arrow.Stream` fetches record
+batches as the iteration reaches them: whole, small ones several to a request, or only
+the columns it selects. A stream-format source has no footer and is read in order.
+
+`readrange` must return a new vector of exactly `len` bytes each time, and never reuse or
+change it: Arrow keeps it without copying. Arrow validates what it reads, but the source
+is trusted to return the bytes stored at the range.
+
+```julia
+struct BytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::BytesSource) = length(s.data)
+Arrow.readrange(s::BytesSource, offset, len) = s.data[(offset + 1):(offset + len)]
+
+table = Arrow.Table(BytesSource(bytes); select=[:a, :b])
+```
+
+With CloudStore.jl loaded, a `CloudStore.Object` (S3 or Azure Blob Storage) is a source.
+"""
+abstract type AbstractArrowSource end
+
+"""
+    Arrow.sourcelength(src::Arrow.AbstractArrowSource) -> Integer
+
+The source's length in bytes. Every source defines it.
+"""
+function sourcelength end
+
+"""
+    Arrow.readrange(src::Arrow.AbstractArrowSource, offset, len) -> Vector{UInt8}
+
+The `len` bytes starting at 0-based `offset`, as a new vector of exactly `len` elements
+that the source does not touch again: Arrow keeps it without copying. Every source
+defines it.
+"""
+function readrange end
+
+"""
+    Arrow.concurrentreads(src::Arrow.AbstractArrowSource) -> Int
+
+How many [`Arrow.readrange`](@ref) calls one read may have in flight at once, up to
+`Limits.max_concurrent_reads`. The default, 1, reads ranges one at a time; a source whose
+requests are independent, such as HTTP range requests, returns a larger number. The
+limit applies to each read separately: a source that needs one cap for the whole
+process enforces it in `readrange`.
+"""
+concurrentreads(::AbstractArrowSource) = 1
diff --git a/src/table.jl b/src/table.jl
index 606f2abe..4e013efb 100644
--- a/src/table.jl
+++ b/src/table.jl
@@ -14,1133 +14,2332 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-struct ArrowBlob
-    bytes::Vector{UInt8}
-    pos::Int
-    len::Int
-end
-
-ArrowBlob(bytes::Vector{UInt8}, pos::Int, len::Nothing) =
-    ArrowBlob(bytes, pos, length(bytes))
-
-tobytes(bytes::Vector{UInt8}) = bytes
-tobytes(io::IO) = Base.read(io)
-tobytes(io::IOStream) = Mmap.mmap(io)
-tobytes(file_path) = open(tobytes, file_path, "r")
-
-struct BatchIterator
-    bytes::Vector{UInt8}
-    startpos::Int
-    function BatchIterator(blob::ArrowBlob)
-        bytes, pos, len = blob.bytes, blob.pos, blob.len
-        if len > 24 && _startswith(bytes, pos, FILE_FORMAT_MAGIC_BYTES)
-            pos += 8 # skip past magic bytes + padding
-        end
-        new(bytes, pos)
-    end
-end
+# =============================================================================
+# The read facade: Arrow IPC -> Tables.jl columns.
+#
+# `Arrow.Table` reads flat columns as zero-copy views (`columns.jl`) and
+# materializes nested and union columns (closed element-type claims through
+# Core's typed path, everything else through the dynamic accessors).
+# `Arrow.Stream` iterates record batches as one Table each. Every read goes
+# through the scan planner and executor (`scan.jl`); a whole read is the scan
+# of every column.
+# =============================================================================
 
 """
-    Arrow.Stream(io::IO; convert::Bool=true)
-    Arrow.Stream(file::String; convert::Bool=true)
-    Arrow.Stream(bytes::Vector{UInt8}, pos=1, len=nothing; convert::Bool=true)
-    Arrow.Stream(inputs::Vector; convert::Bool=true)
+    Arrow.Table(source; select=nothing, drop=nothing, filter=nothing, limit=nothing,
+                offset=nothing, scan=nothing, mmap, stringtype=DataString,
+                ntasks=Threads.nthreads(), limits=Arrow.Limits()) -> Arrow.Table
+
+Read Arrow IPC data, in the file or the stream format, as Tables.jl columns. `source` is
+a path, an `IO` (read to its end), a byte vector (read in place: do not modify it while
+the columns are in use), or an [`Arrow.AbstractArrowSource`](@ref). Any other `source`
+that `open(source, "r")` accepts, such as a FilePathsBase.jl path, reads as the file or
+`IO` it opens.
+
+- `select` keeps the given columns, in that order: names, indices, a regex, a vector of
+  them, or a function `(i, name) -> Bool`; `name => newname` renames a column and
+  `name => Type` converts it to `Type`. `drop` keeps the others.
+- `filter` keeps the rows where a predicate built from [`Arrow.col`](@ref) is `true`,
+  such as `filter=Arrow.col(:fare) > 10`.
+- `limit` keeps at most that many rows, and `offset` skips that many rows first.
+- `scan` takes a `Tables.Scan` instead of those keywords.
+- `mmap` memory-maps a path. It is the default except on Windows, which cannot delete a
+  mapped file.
+- `stringtype=String` reads strings as `String`s instead of `DataStrings.DataString`s.
+- Up to `ntasks` tasks decode record batches and build columns; `ntasks=1` reads on the
+  calling task. The result does not depend on `ntasks`.
+- `limits` sets the [`Arrow.Limits`](@ref).
+
+Only the selected and filter columns are read, a filter's other columns only for the
+record batches that keep rows, and a `limit` stops reading once it has its rows. From an
+`AbstractArrowSource`, a read plans only those byte ranges, but fetches a record batch
+of at most 1 MiB whole.
+
+Numbers, booleans, temporal values, decimals, and dictionary indices read as read-only
+[`Arrow.ArrowVector`](@ref) views of the source; a column of several record batches is a
+`ChainedVector` of them. Strings and binary values are `DataStrings.StringVector` and
+`BytesVector` columns over the source's bytes, built the first time the table hands
+them out. Lists, maps, and structs read as typed rows. A read with `filter`, `limit`, or
+`offset` copies the rows it keeps instead: `Vector`s, string and binary columns that hold
+just their values' bytes, and dictionary columns that keep their categories. Column types
+do not depend on the kind of source. A column keeps the memory it reads
+alive while it is reachable, even after its table is gone; a mapped file is unmapped
+once the table and its columns are garbage collected. `copy(table)`, `DataFrame(table)`,
+and [`Arrow.read`](@ref) give owned, mutable columns. Columns that share a name read as
+`a`, `a_1`, `a_2`, and so on.
+
+!!! warning
+    If another program rewrites a memory-mapped file in place (truncating it, as
+    `open(path, "w")`, `CSV.write`, pyarrow, and shell redirection do) while any column
+    read from it is in use, the next access to that column kills the Julia process with
+    a bus error (SIGBUS). Read files that other programs rewrite with `mmap=false`.
+    `Arrow.write` replaces a file safely: it writes a new file and renames it over the
+    old one.
+"""
+struct Table <: Tables.AbstractColumns
+    names::Vector{Symbol}
+    columns::Vector{AbstractVector}
+    lookup::Dict{Symbol,Int}
+    schema::Union{Nothing,AC.Schema}
+    regions::Vector{AC.OwnerRegion}
+    nrows::Int   # authoritative even with zero columns
+    # Original dictionary pools, in column order, when the facade read had
+    # enough information to retain them. This is intentionally separate from
+    # `schema`: ordered dictionary semantics live in the pool order, not in
+    # the DictionaryType descriptor alone.
+    retainedpools::Vector{Any}
+end
 
-Start reading an arrow formatted table, from:
- * `io`, bytes will be read all at once via `read(io)`
- * `file`, bytes will be read via `Mmap.mmap(file)`
- * `bytes`, a byte vector directly, optionally allowing specifying the starting byte position `pos` and `len`
- * A `Vector` of any of the above, in which each input should be an IPC or arrow file and must match schema
+"""
+    copy(table::Arrow.Table) -> Arrow.Table
 
-Reads the initial schema message from the arrow stream/file, then returns an `Arrow.Stream` object
-which will iterate over record batch messages, producing an [`Arrow.Table`](@ref) on each iteration.
+Copy every column into owned, mutable memory and retain the schema and dictionary
+category order. Nested Arrow list and map views become vectors too, including within
+structs and tuples, so the new table reads nothing from the source. As with `copy` on
+Julia vectors, nested mutable values that were already materialized can still be shared.
+"""
+function Base.copy(t::Table)
+    _checkopen(t)
+    return _table(
+        copy(getfield(t, :names)),
+        AbstractVector[_copycolumn(_force(c)) for c in getfield(t, :columns)],
+        getfield(t, :schema),
+        AC.OwnerRegion[],
+        getfield(t, :nrows),
+        Any[p === nothing ? nothing : _copycolumn(p) for p in getfield(t, :retainedpools)],
+    )
+end
 
-By iterating [`Arrow.Table`](@ref), `Arrow.Stream` satisfies the `Tables.partitions` interface, and as such can
-be passed to Tables.jl-compatible sink functions.
+# Construct a Table with deliberately replaced materialized columns (the
+# facade tests exercise refusal paths this way). The passed lookup is
+# ignored and rebuilt from `names`, and no dictionary pools are retained.
+Table(names, columns, lookup, schema, regions, nrows) = Table(
+    names,
+    columns,
+    _namelookup(names),
+    schema,
+    regions,
+    nrows,
+    Any[nothing for _ in names],
+)
 
-This allows iterating over extremely large "arrow tables" in chunks represented as record batches.
+function _namelookup(names, budget=nothing)
+    _chargedict!(budget, Symbol, Int, length(names), "table column-name lookup")
+    lookup = Dict{Symbol,Int}()
+    sizehint!(lookup, length(names))
+    for (i, nm) in enumerate(names)
+        # Sentinel 0 marks a name that appears more than once; `_columnindex`
+        # turns it into an "ambiguous, use positional access" error. An
+        # absent key (-1 there) means no such column.
+        lookup[nm] = haskey(lookup, nm) ? 0 : i
+    end
+    return lookup
+end
 
-Supports the `convert` keyword argument which controls whether certain arrow primitive types will be
-lazily converted to more friendly Julia defaults; by default, `convert=true`.
-"""
-mutable struct Stream
-    inputs::Vector{ArrowBlob}
-    inputindex::Int
-    batchiterator::Union{Nothing,BatchIterator}
-    names::Vector{Symbol}
-    types::Vector{Type}
-    schema::Union{Nothing,Meta.Schema}
-    dictencodings::Lockable{Dict{Int64,DictEncoding}} # dictionary id => DictEncoding
-    dictencoded::Dict{Int64,Meta.Field} # dictionary id => field
-    convert::Bool
-    compression::Ref{Union{Symbol,Nothing}}
-end
-
-function Stream(inputs::Vector{ArrowBlob}; convert::Bool=true)
-    inputindex = 1
-    batchiterator = nothing
-    names = Symbol[]
-    types = Type[]
-    schema = nothing
-    dictencodings = Lockable(Dict{Int64,DictEncoding}())
-    dictencoded = Dict{Int64,Meta.Field}()
-    compression = Ref{Union{Symbol,Nothing}}(nothing)
-    Stream(
-        inputs,
-        inputindex,
-        batchiterator,
-        names,
-        types,
-        schema,
-        dictencodings,
-        dictencoded,
-        convert,
-        compression,
+function _columnindex(t::Table, nm::Symbol)
+    i = get(getfield(t, :lookup), nm, -1)
+    i == -1 &&
+        throw(ArgumentError("no column $(_uninferred(repr, nm)::String) in this table"))
+    i == 0 && throw(
+        ArgumentError(
+            "column name $(_uninferred(repr, nm)::String) is ambiguous; use positional " *
+            "column access",
+        ),
     )
+    return i
 end
 
-function Stream(input, pos::Integer=1, len=nothing; kw...)
-    b = tobytes(input)
-    isempty(b) ? Stream(ArrowBlob[]; kw...) : Stream([ArrowBlob(b, pos, len)]; kw...)
+function _validatefieldsymbolname(name::AbstractString)
+    occursin('\0', name) && throw(
+        AC.ValidationError(
+            "field name contains an embedded NUL and cannot be represented " *
+            "as a Tables.jl column Symbol",
+        ),
+    )
+    ncodeunits(name) <= _MAX_ARROWTYPE_SCHEMA_NAME_BYTES || throw(
+        AC.ValidationError(
+            "field name exceeds the Tables.jl facade limit of " *
+            "$_MAX_ARROWTYPE_SCHEMA_NAME_BYTES UTF-8 bytes",
+        ),
+    )
+    return nothing
 end
 
-function Stream(input::Vector{UInt8}, pos::Integer=1, len=nothing; kw...)
-    b = tobytes(input)
-    isempty(b) ? Stream(ArrowBlob[]; kw...) : Stream([ArrowBlob(b, pos, len)]; kw...)
-end
+_fieldsymbol(name::AbstractString) = (_validatefieldsymbolname(name); Symbol(name))
 
-function Stream(inputs::AbstractVector; kw...)
-    blobs = ArrowBlob[]
-    for x in inputs
-        b = tobytes(x)
-        isempty(b) && continue
-        push!(blobs, ArrowBlob(b, 1, nothing))
+const _MAX_TABLES_NEW_FIELD_NAMES = 65_536
+const _MAX_TABLES_NEW_FIELD_NAME_BYTES = 1024 * 1024
+
+# A timestamp's zone becomes a `ZonedTimestamp` type parameter: its name is
+# interned for the life of the process and its columns compile their own
+# methods. One read may bring at most this many zones new to the process.
+const _MAX_NEW_ZONES = 1024
+
+function _checknewzones(fields)
+    seen = Set{String}()
+    for f in fields
+        _newzones!(seen, f)
     end
-    Stream(blobs; kw...)
+    return nothing
 end
 
-function initialize!(x::Stream)
-    isempty(getfield(x, :names)) || return
-    # Initialize member fields using iteration and reset state
-    lastinputindex = x.inputindex
-    lastbatchiterator = x.batchiterator
-    iterate(x)
-    x.inputindex = lastinputindex
-    x.batchiterator = lastbatchiterator
-    nothing
+function _newzones!(seen::Set{String}, f::AC.Field)
+    t = f.type
+    if t isa AC.TimestampType
+        zone = _timestampzone(t)
+        if zone !== nothing && !(zone in seen) && _existingjlsymbol(zone) === nothing
+            push!(seen, zone)
+            length(seen) <= _MAX_NEW_ZONES || throw(
+                AC.ValidationError(
+                    "timestamp columns declare more than $_MAX_NEW_ZONES time zones " *
+                    "this Julia process has not seen; each zone is a type parameter",
+                ),
+            )
+        end
+    end
+    t isa AC.DictionaryType && _newzones!(seen, AC.dictvaluefield(f, t))
+    foreach(c -> _newzones!(seen, c), f.children)
+    return seen
 end
 
-Tables.partitions(x::Stream) = x
+# `names` with each repeated name made unique as CSV.jl does (`a`, `a_1`, `a_2`,
+# never taking a name already present); `names` itself when all are unique.
+function _uniquenames(names::AbstractVector{String})
+    allunique(names) && return names
+    taken = Set{String}(names)
+    next = Dict{String,Int}()
+    unique = String[]
+    for name in names
+        if haskey(next, name)
+            k = next[name]
+            while "$(name)_$k" in taken
+                k += 1
+            end
+            next[name] = k + 1
+            renamed = "$(name)_$k"
+            push!(taken, renamed)
+            push!(unique, renamed)
+        else
+            next[name] = 1
+            push!(unique, name)
+        end
+    end
+    return unique
+end
 
-function Tables.columnnames(x::Stream)
-    initialize!(x)
-    getfield(x, :names)
+# `schema` with its top-level fields renamed as `_fieldnamesymbols` names them.
+function _uniqueschema(schema::AC.Schema)
+    names = String[f.name for f in schema.fields]
+    unique = _uniquenames(names)
+    unique === names && return schema
+    fields = AC.Field[
+        AC.Field(n, f.type, f.nullable, f.metadata, f.children) for
+        (n, f) in zip(unique, schema.fields)
+    ]
+    return AC.Schema(
+        AC.FrozenVector{AC.Field}(fields, nothing),
+        schema.metadata,
+        schema.endianness,
+    )
 end
 
-function Tables.schema(x::Stream)
-    initialize!(x)
-    Tables.Schema(Tables.columnnames(x), getfield(x, :types))
+# Column names of `fields`, unique (`_uniquenames`) and interned within the
+# per-read novel-name limits.
+function _fieldnamesymbols(fields, budget=nothing)
+    # Before any name is interned, so names cannot pre-intern zones.
+    _checknewzones(fields)
+    _chargevector!(budget, String, length(fields), "field names")
+    names = _uniquenames(String[field.name for field in fields])
+    _chargedict!(budget, String, Nothing, length(fields), "novel field-name set")
+    novel = Set{String}()
+    sizehint!(novel, length(fields))
+    novelbytes = 0
+    for name in names
+        _validatefieldsymbolname(name)
+        _existingjlsymbol(name) === nothing || continue
+        name in novel && continue
+        length(novel) < _MAX_TABLES_NEW_FIELD_NAMES || throw(
+            AC.ValidationError(
+                "Tables.jl facade field names exceed the per-read novel-name limit",
+            ),
+        )
+        namebytes = ncodeunits(name)
+        novelbytes <= _MAX_TABLES_NEW_FIELD_NAME_BYTES - namebytes || throw(
+            AC.ValidationError(
+                "Tables.jl facade field names exceed the per-read novel-name byte budget",
+            ),
+        )
+        push!(novel, name)
+        novelbytes += namebytes
+    end
+    budget === nothing || _charge!(budget, Int64(novelbytes), "novel field-name bytes")
+    _chargevector!(budget, Symbol, length(fields), "table field names")
+    return Symbol[_fieldsymbol(name) for name in names]
 end
 
-Base.IteratorSize(::Type{Stream}) = Base.SizeUnknown()
-Base.eltype(::Type{Stream}) = Table
-Base.isdone(x::Stream) = x.inputindex > length(x.inputs)
+function _table(
+    names::Vector{Symbol},
+    columns::Vector{AbstractVector},
+    schema,
+    regions,
+    nrows::Integer,
+    retainedpools=nothing,
+    budget=nothing,
+)
+    retainedpools === nothing ||
+        length(retainedpools) == length(names) ||
+        throw(ArgumentError("retained dictionary pool count does not match column count"))
+    _chargevector!(budget, Any, length(names), "table retained-pool slots")
+    pools = retainedpools === nothing ? fill(nothing, length(names)) : Any[retainedpools...]
+    lookup = _namelookup(names, budget)
+    return Table(names, columns, lookup, schema, regions, Int(nrows), pools)
+end
 
-function Base.iterate(x::Stream, (pos, id)=(1, 0))
-    if Base.isdone(x)
-        x.inputindex = 1
-        x.batchiterator = nothing
-        return nothing
+Tables.istable(::Type{Table}) = true
+Tables.columnaccess(::Type{Table}) = true
+Tables.columns(t::Table) = t
+Tables.columnnames(t::Table) = getfield(t, :names)
+Tables.getcolumn(t::Table, i::Int) = (_checkopen(t); _force(getfield(t, :columns)[i]))
+Tables.getcolumn(t::Table, nm::Symbol) =
+    (_checkopen(t); _force(getfield(t, :columns)[_columnindex(t, nm)]))
+
+# A released table refuses column access; columns taken before stay valid.
+function _checkopen(t::Table)
+    for r in getfield(t, :regions)
+        (@atomic :acquire r.cell.closed) &&
+            throw(InvalidStateException("the table was released", :closed))
     end
-    if isnothing(x.batchiterator)
-        blob = x.inputs[x.inputindex]
-        x.batchiterator = BatchIterator(blob)
-        pos = x.batchiterator.startpos
+    return nothing
+end
+# Column count at or below which `Tables.schema` returns the fully typed
+# `Tables.Schema{names, types}`. Typed schemas let materializers that refuse
+# stored schemas (`Tables.rowtable`, `Tables.columntable`) work as usual and
+# comfortably cover Tables.jl's own 100-column specialization threshold.
+# Above it the names and types stay in `Vector` fields (`stored=true`) so
+# compiler work cannot scale with untrusted input names; Tables.jl then
+# refuses `NamedTuple` materialization with its "input table too wide" error,
+# which is the intended behavior for very wide tables.
+const _MAX_TYPED_SCHEMA_FIELDS = 256
+
+function Tables.schema(t::Table)
+    names = getfield(t, :names)
+    types = Type[_eltypeof(c) for c in getfield(t, :columns)]
+    return Tables.Schema(names, types; stored=length(names) > _MAX_TYPED_SCHEMA_FIELDS)
+end
+Base.propertynames(t::Table) = getfield(t, :names)
+Base.getproperty(t::Table, nm::Symbol) = Tables.getcolumn(t, nm)
+Base.getindex(t::Table, name::AbstractString) = Tables.getcolumn(t, Symbol(name))
+Base.names(t::Table) = String[String(name) for name in getfield(t, :names)]
+Tables.rowcount(t::Table) = getfield(t, :nrows)
+DataAPI.nrow(t::Table) = getfield(t, :nrows)
+DataAPI.ncol(t::Table) = length(getfield(t, :names))
+
+# Two tables are equal when their column names and columns are, as DataFrames
+# compares: `==` is `missing` when a column comparison is, `isequal` is not.
+function Base.:(==)(a::Table, b::Table)
+    getfield(a, :names) == getfield(b, :names) || return false
+    eq = true
+    for i in eachindex(getfield(a, :names))
+        coleq = Tables.getcolumn(a, i) == Tables.getcolumn(b, i)
+        isequal(coleq, false) && return false
+        eq &= coleq
     end
+    return eq
+end
+function Base.isequal(a::Table, b::Table)
+    getfield(a, :names) == getfield(b, :names) || return false
+    return all(
+        i -> isequal(Tables.getcolumn(a, i), Tables.getcolumn(b, i)),
+        eachindex(getfield(a, :names)),
+    )
+end
+function Base.hash(t::Table, h::UInt)
+    h = hash(getfield(t, :names), h)
+    for i in eachindex(getfield(t, :names))
+        h = hash(Tables.getcolumn(t, i), h)
+    end
+    return h
+end
 
-    columns = AbstractVector[]
-    compression = nothing
-
-    while true
-        state = iterate(x.batchiterator, (pos, id))
-        # check for additional inputs
-        while state === nothing
-            x.inputindex += 1
-            if Base.isdone(x)
-                x.inputindex = 1
-                x.batchiterator = nothing
-                return nothing
-            end
-            blob = x.inputs[x.inputindex]
-            x.batchiterator = BatchIterator(blob)
-            pos = x.batchiterator.startpos
-            state = iterate(x.batchiterator, (pos, id))
-        end
-        batch, (pos, id) = state
-        header = batch.msg.header
-        if isnothing(x.schema) && !isa(header, Meta.Schema)
-            throw(ArgumentError("first arrow ipc message MUST be a schema message"))
-        end
-        if header isa Meta.Schema
-            if isnothing(x.schema)
-                x.schema = header
-                # assert endianness?
-                # store custom_metadata?
-                for (i, field) in enumerate(x.schema.fields)
-                    push!(x.names, Symbol(field.name))
-                    push!(
-                        x.types,
-                        juliaeltype(field, buildmetadata(field.custom_metadata), x.convert),
-                    )
-                    # recursively find any dictionaries for any fields
-                    getdictionaries!(x.dictencoded, field)
-                    @debug "parsed column from schema: field = $field"
-                end
-            elseif header != x.schema
-                throw(
-                    ArgumentError(
-                        "mismatched schemas between different arrow batches: $(x.schema) != $header",
-                    ),
-                )
-            end
-        elseif header isa Meta.DictionaryBatch
-            id = header.id
-            recordbatch = header.data
-            @debug "parsing dictionary batch message: id = $id, compression = $(recordbatch.compression)"
-            if recordbatch.compression !== nothing
-                compression = recordbatch.compression
-            end
-            @lock x.dictencodings begin
-                dictencodings = x.dictencodings[]
-                if haskey(dictencodings, id) && header.isDelta
-                    # delta
-                    field = x.dictencoded[id]
-                    values, _, _, _ = build(
-                        field,
-                        field.type,
-                        batch,
-                        recordbatch,
-                        x.dictencodings,
-                        Int64(1),
-                        Int64(1),
-                        Int64(1),
-                        x.convert,
-                    )
-                    dictencoding = dictencodings[id]
-                    append!(dictencoding.data, values)
-                    continue
-                end
-                # new dictencoding or replace
-                field = x.dictencoded[id]
-                values, _, _, _ = build(
-                    field,
-                    field.type,
-                    batch,
-                    recordbatch,
-                    x.dictencodings,
-                    Int64(1),
-                    Int64(1),
-                    Int64(1),
-                    x.convert,
-                )
-                A = ChainedVector([values])
-                S =
-                    field.dictionary.indexType === nothing ? Int32 :
-                    juliaeltype(field, field.dictionary.indexType, false)
-                dictencodings[id] = DictEncoding{eltype(A),S,typeof(A)}(
-                    id,
-                    A,
-                    field.dictionary.isOrdered,
-                    values.metadata,
-                )
-            end # lock
-            @debug "parsed dictionary batch message: id=$id, data=$values\n"
-        elseif header isa Meta.RecordBatch
-            @debug "parsing record batch message: compression = $(header.compression)"
-            if header.compression !== nothing
-                compression = header.compression
-            end
-            for vec in VectorIterator(x.schema, batch, x.dictencodings, x.convert)
-                push!(columns, vec)
-            end
-            break
-        else
-            throw(ArgumentError("unsupported arrow message type: $(typeof(header))"))
+DataAPI.metadatasupport(::Type{Table}) = (read=true, write=false)
+DataAPI.colmetadatasupport(::Type{Table}) = (read=true, write=false)
+
+const _NO_DEFAULT = gensym(:nodefault)
+
+function DataAPI.metadatakeys(t::Table)
+    sch = getfield(t, :schema)
+    (sch === nothing || sch.metadata === nothing) && return ()
+    return (String(first(kv)) for kv in sch.metadata)
+end
+function DataAPI.metadata(
+    t::Table,
+    key::AbstractString,
+    default=_NO_DEFAULT;
+    style::Bool=false,
+)
+    sch = getfield(t, :schema)
+    if sch !== nothing && sch.metadata !== nothing
+        for kv in sch.metadata
+            first(kv) == key && return style ? (last(kv), :default) : last(kv)
         end
     end
+    default === _NO_DEFAULT && throw(KeyError(key))
+    return style ? (default, :default) : default
+end
+# `sym` names `s`, compared without interning `s` (Symbols hold no NUL).
+function _symbolis(sym::Symbol, s::String)
+    p = Base.unsafe_convert(Ptr{UInt8}, sym)
+    n = ncodeunits(s)
+    ccall(:strlen, Csize_t, (Ptr{UInt8},), p) == n || return false
+    return GC.@preserve s ccall(
+        :memcmp,
+        Cint,
+        (Ptr{UInt8}, Ptr{UInt8}, Csize_t),
+        p,
+        pointer(s),
+        n,
+    ) == 0
+end
 
-    if compression !== nothing
-        if compression.codec == Flatbuf.CompressionType.ZSTD
-            x.compression[] = :zstd
-        elseif compression.codec == Flatbuf.CompressionType.LZ4_FRAME
-            x.compression[] = :lz4
-        else
-            throw(ArgumentError("unsupported compression codec: $(compression.codec)"))
-        end
+# An ordinary facade read retains one field per output column in the same
+# order and under the same name.
+function _schemaaligned(t::Table)
+    names = getfield(t, :names)
+    sch = getfield(t, :schema)
+    sch === nothing && return false
+    fields = sch.fields
+    length(fields) == length(names) || return false
+    for i in eachindex(names)
+        _symbolis(names[i], fields[i].name) || return false
     end
+    return true
+end
 
-    lookup = Dict{Symbol,AbstractVector}()
-    types = Type[]
-    for (nm, col) in zip(x.names, columns)
-        lookup[nm] = col
-        push!(types, eltype(col))
+function _schemafield(t::Table, col::Int, aligned::Bool=_schemaaligned(t))
+    names = getfield(t, :names)
+    checkbounds(names, col)
+    sch = getfield(t, :schema)
+    sch === nothing && return nothing
+    fields = sch.fields
+    # Position is the only unambiguous identity when Arrow legally carries
+    # duplicate field names.
+    aligned && return fields[col]
+    # A real Tables.Scan type conversion drops that column's retained field,
+    # so its schema can be an ordered subset. Name lookup remains safe only
+    # when the output name itself is unique.
+    nm = names[col]
+    # The lookup holds 0 for a name that appears more than once.
+    getfield(t, :lookup)[nm] == 0 && return nothing
+    text = String(nm)
+    i = findfirst(f -> f.name == text, fields)
+    return i === nothing ? nothing : sch.fields[i]
+end
+function _schemafield(t::Table, col::Symbol)
+    return _schemafield(t, _columnindex(t, col))
+end
+function DataAPI.colmetadatakeys(t::Table, col::Union{Symbol,Int})
+    c = col isa Symbol ? _columnindex(t, col) : col
+    return _colmetadatakeys(_schemafield(t, c))
+end
+function DataAPI.colmetadatakeys(t::Table)
+    # One alignment check for the whole listing keeps it linear in the
+    # column count.
+    aligned = _schemaaligned(t)
+    return (
+        nm => keys for (i, nm) in enumerate(getfield(t, :names)) for
+        keys in (_colmetadatakeys(_schemafield(t, i, aligned)),) if !isempty(keys)
+    )
+end
+_colmetadatakeys(f) =
+    (f === nothing || f.metadata === nothing) ? () :
+    (String(first(kv)) for kv in f.metadata)
+function DataAPI.colmetadata(
+    t::Table,
+    col::Union{Symbol,Int},
+    key::AbstractString,
+    default=_NO_DEFAULT;
+    style::Bool=false,
+)
+    c = col isa Symbol ? _columnindex(t, col) : col
+    f = _schemafield(t, c)
+    if f !== nothing && f.metadata !== nothing
+        for kv in f.metadata
+            first(kv) == key && return style ? (last(kv), :default) : last(kv)
+        end
     end
-    return Table(x.names, types, columns, lookup, Ref(x.schema)), (pos, id)
+    default === _NO_DEFAULT && throw(KeyError(key))
+    return style ? (default, :default) : default
 end
 
 """
-    Arrow.Table(io::IO; convert::Bool=true)
-    Arrow.Table(file::String; convert::Bool=true)
-    Arrow.Table(bytes::Vector{UInt8}, pos=1, len=nothing; convert::Bool=true)
-    Arrow.Table(inputs::Vector; convert::Bool=true)
-
-Read an arrow formatted table, from:
- * `io`, bytes will be read all at once via `read(io)`
- * `file`, bytes will be read via `Mmap.mmap(file)`
- * `bytes`, a byte vector directly, optionally allowing specifying the starting byte position `pos` and `len`
- * A `Vector` of any of the above, in which each input should be an IPC or arrow file and must match schema
-
-Returns a `Arrow.Table` object that allows column access via `table.col1`, `table[:col1]`, or `table[1]`.
+    Arrow.getmetadata(x)
 
-NOTE: the columns in an `Arrow.Table` are views into the original arrow memory, and hence are not easily
-modifiable (with e.g. `push!`, `append!`, etc.). To mutate arrow columns, call `copy(x)` to materialize
-the arrow data as a normal Julia array.
+Compatibility form of the Arrow 2.x metadata accessor. For an `Arrow.Table`,
+returns the table-level key-value metadata as a `Dict{String,String}`, or
+`nothing` when the table has none. Every other object returns `nothing`,
+including other Tables.jl tables, so `metadata=Arrow.getmetadata(table)` works
+for any `Arrow.write` input. New code should prefer the DataAPI.jl interface
+(`DataAPI.metadata`, `DataAPI.metadatakeys`), which `Arrow.Table` supports.
 
-`Arrow.Table` also satisfies the [Tables.jl](https://github.com/JuliaData/Tables.jl) interface, and so can easily be materialied via any supporting
-sink function: e.g. `DataFrame(Arrow.Table(file))`, `SQLite.load!(db, "table", Arrow.Table(file))`, etc.
+A column also returns `nothing`; use
+`DataAPI.colmetadata(table, column, key)`/`DataAPI.colmetadatakeys(table)` for
+per-column metadata.
+"""
+function getmetadata(t::Table)
+    sch = getfield(t, :schema)
+    (sch === nothing || sch.metadata === nothing || isempty(sch.metadata)) && return nothing
+    return Dict{String,String}(String(first(kv)) => String(last(kv)) for kv in sch.metadata)
+end
+# Arrow 2.x returned `nothing` for every non-Arrow object; a row table such as
+# a `Vector` of records is indistinguishable from a column here.
+getmetadata(::Any) = nothing
 
-Supports the `convert` keyword argument which controls whether certain arrow primitive types will be
-lazily converted to more friendly Julia defaults; by default, `convert=true`.
 """
-struct Table <: Tables.AbstractColumns
-    names::Vector{Symbol}
-    types::Vector{Type}
-    columns::Vector{AbstractVector}
-    lookup::Dict{Symbol,AbstractVector}
-    schema::Ref{Meta.Schema}
-    metadata::Ref{Union{Nothing,Base.ImmutableDict{String,String}}}
-end
-
-Table() = Table(
-    Symbol[],
-    Type[],
-    AbstractVector[],
-    Dict{Symbol,AbstractVector}(),
-    Ref{Meta.Schema}(),
-    Ref{Union{Nothing,Base.ImmutableDict{String,String}}}(nothing),
-)
+    Arrow.release!(t::Union{Table,Stream})
 
-function Table(names, types, columns, lookup, schema)
-    m = isassigned(schema) ? buildmetadata(schema[]) : nothing
-    return Table(
-        names,
-        types,
-        columns,
-        lookup,
-        schema,
-        Ref{Union{Nothing,Base.ImmutableDict{String,String}}}(m),
-    )
+End a read: the table refuses further column access, and a stream refuses
+further iteration. Every `Table` a `Stream` yields shares its source, so
+releasing either one releases both. Columns taken before the release remain
+usable and keep the memory they read: a memory-mapped file is unmapped once
+the table and all of its columns are garbage collected. Idempotent.
+"""
+function AC.release!(t::Table)
+    foreach(AC.release!, getfield(t, :regions))
+    return nothing
 end
 
-names(t::Table) = getfield(t, :names)
-types(t::Table) = getfield(t, :types)
-columns(t::Table) = getfield(t, :columns)
-lookup(t::Table) = getfield(t, :lookup)
-schema(t::Table) = getfield(t, :schema)
-metadata(t::Table) = getfield(t, :metadata)
+# --- Dates conversion (the facade owns what Core deliberately does not) ----
+
+# Days from Julia's Date epoch (0000-12-31) to the Arrow epoch (1970-01-01).
+const _EPOCH_DAYS = Dates.value(Dates.Date(1970, 1, 1))
+const _MILLIS_PER_DAY = Int128(86_400_000)
+const _NANOS_PER_DAY = Int64(86_400_000_000_000)
 
 """
-    Arrow.getmetadata(x)
+The public `Dates.Time` for one stored time-of-day value. `Dates.Time` wraps
+modulo 24 hours, so a value outside the format's [0, 24h) range has no
+exact public value and is refused instead of aliasing another time.
+"""
+function _publictime(unit, x)
+    perday =
+        unit == AC.SECOND ? Int64(86_400) :
+        unit == AC.MILLISECOND ? Int64(86_400_000) :
+        unit == AC.MICROSECOND ? Int64(86_400_000_000) : _NANOS_PER_DAY
+    v = Int64(x)
+    0 <= v < perday ||
+        throw(ValidationError("time-of-day value $v is outside [0, $perday) in its unit"))
+    return Dates.Time(Dates.Nanosecond(v * (_NANOS_PER_DAY ÷ perday)))
+end
 
-If `x isa Arrow.Table` return a `Base.ImmutableDict{String,String}` representation of `x`'s
-`Schema` `custom_metadata`, or `nothing` if no such metadata exists.
+# Map a temporal descriptor to the compile-time token the writer's conversion
+# loops dispatch on; eighteen values total (2 date + 4 timestamp + 4 zoned
+# timestamp + 4 time + 4 duration). Zone-declared timestamps carry their own
+# kind: their values (`ZonedTimestamp`/`ZonedDateTime`) are disjoint from the
+# zone-naive ones.
+_facadetoken(t::AC.DateType) =
+    t.unit == AC.DAY ? Val((:date, AC.DAY)) : Val((:date, AC.MILLISECOND_DATE))
+_facadetoken(t::AC.TimestampType) =
+    if _timestampzone(t) === nothing
+        t.unit == AC.SECOND ? Val((:timestamp, AC.SECOND)) :
+        t.unit == AC.MILLISECOND ? Val((:timestamp, AC.MILLISECOND)) :
+        t.unit == AC.MICROSECOND ? Val((:timestamp, AC.MICROSECOND)) :
+        Val((:timestamp, AC.NANOSECOND))
+    else
+        t.unit == AC.SECOND ? Val((:zonedtimestamp, AC.SECOND)) :
+        t.unit == AC.MILLISECOND ? Val((:zonedtimestamp, AC.MILLISECOND)) :
+        t.unit == AC.MICROSECOND ? Val((:zonedtimestamp, AC.MICROSECOND)) :
+        Val((:zonedtimestamp, AC.NANOSECOND))
+    end
+_facadetoken(t::AC.TimeType) =
+    t.unit == AC.SECOND ? Val((:time, AC.SECOND)) :
+    t.unit == AC.MILLISECOND ? Val((:time, AC.MILLISECOND)) :
+    t.unit == AC.MICROSECOND ? Val((:time, AC.MICROSECOND)) : Val((:time, AC.NANOSECOND))
+_facadetoken(t::AC.DurationType) =
+    t.unit == AC.SECOND ? Val((:duration, AC.SECOND)) :
+    t.unit == AC.MILLISECOND ? Val((:duration, AC.MILLISECOND)) :
+    t.unit == AC.MICROSECOND ? Val((:duration, AC.MICROSECOND)) :
+    Val((:duration, AC.NANOSECOND))
+
+@inline function _boundedint64(value::Int128)::Union{Nothing,Int64}
+    Int128(typemin(Int64)) <= value <= Int128(typemax(Int64)) || return nothing
+    return Int64(value)
+end
 
-If `x isa Arrow.ArrowVector`, return a `Base.ImmutableDict{String,String}` representation of `x`'s
-`Field` `custom_metadata`, or `nothing` if no such metadata exists.
+@inline function _boundedint32(value::Int128)::Union{Nothing,Int32}
+    Int128(typemin(Int32)) <= value <= Int128(typemax(Int32)) || return nothing
+    return Int32(value)
+end
 
-Otherwise, return `nothing`.
+@inline function _datestorage(value)::Union{Nothing,Int32}
+    days = if value isa Dates.Date
+        Int128(Dates.value(value))
+    elseif value isa Dates.DateTime
+        q, r = divrem(Int128(Dates.value(value)), _MILLIS_PER_DAY)
+        iszero(r) || return nothing
+        q
+    else
+        return nothing
+    end
+    return _boundedint32(days - Int128(_EPOCH_DAYS))
+end
 
-See [the official Arrow documentation for more details on custom application metadata](https://arrow.apache.org/docs/format/Columnar.html#custom-application-metadata).
-"""
-getmetadata(t::Table) = getfield(t, :metadata)[]
-getmetadata(::Any) = nothing
+@inline function _epochmillis(value)::Union{Nothing,Int64}
+    absolute = if value isa Dates.Date
+        # Match DateTime(Date): dates outside DateTime's Int64 millisecond
+        # domain do not have a facade representation for these layouts.
+        raw = Int128(Dates.value(value)) * _MILLIS_PER_DAY
+        _boundedint64(raw) === nothing && return nothing
+        raw
+    elseif value isa Dates.DateTime
+        Int128(Dates.value(value))
+    else
+        return nothing
+    end
+    return _boundedint64(absolute - Int128(Dates.UNIXEPOCH))
+end
 
-DataAPI.metadatasupport(::Type{Table}) = (read=true, write=false)
-DataAPI.colmetadatasupport(::Type{Table}) = (read=true, write=false)
+@inline function _timestorage(unit, value)::Union{Nothing,Int64}
+    value isa Dates.Time || return nothing
+    nanos = Int64(Dates.value(value))
+    unit == AC.NANOSECOND && return nanos
+    divisor =
+        unit == AC.MICROSECOND ? Int64(1_000) :
+        unit == AC.MILLISECOND ? Int64(1_000_000) : Int64(1_000_000_000)
+    q, r = divrem(nanos, divisor)
+    return iszero(r) ? q : nothing
+end
 
-function DataAPI.metadata(t::Table, key::AbstractString; style::Bool=false)
-    meta = getmetadata(t)[key]
-    return style ? (meta, :default) : meta
+# The Arrow spec treats an absent and an empty timezone string the same way:
+# the column is zone-naive. One helper keeps every facade rule on that page.
+@inline _timestampzone(t::AC.TimestampType) =
+    t.timezone === nothing || isempty(t.timezone) ? nothing : t.timezone
+
+@inline _unitticks(unit)::Int64 =
+    unit == AC.SECOND ? Int64(1) :
+    unit == AC.MILLISECOND ? Int64(1_000) :
+    unit == AC.MICROSECOND ? Int64(1_000_000) : Int64(1_000_000_000)
+
+# Ticks per second of a Timestamp/ZonedTimestamp period. Package-defined
+# periods return `nothing`: converting them would run package code, so they
+# have no exact storage value here.
+@inline _periodticks(::Type{Dates.Second})::Union{Nothing,Int64} = Int64(1)
+@inline _periodticks(::Type{Dates.Millisecond})::Union{Nothing,Int64} = Int64(1_000)
+@inline _periodticks(::Type{Dates.Microsecond})::Union{Nothing,Int64} = Int64(1_000_000)
+@inline _periodticks(::Type{Dates.Nanosecond})::Union{Nothing,Int64} = Int64(1_000_000_000)
+@inline _periodticks(::Type)::Union{Nothing,Int64} = nothing
+
+_instantperiod(::Durations.Timestamp{P}) where {P} = P
+_instantperiod(::Durations.ZonedTimestamp{P}) where {P} = P
+
+"Exactly rescale an instant count between tick rates, or `nothing`."
+@inline function _rescalecount(count::Int64, from::Int64, to::Int64)::Union{Nothing,Int64}
+    from == to && return count
+    to > from && return _boundedint64(Int128(count) * Int128(to ÷ from))
+    q, r = divrem(count, from ÷ to)
+    return iszero(r) ? q : nothing
 end
 
-function DataAPI.metadata(t::Table, key::AbstractString, default; style::Bool=false)
-    meta = getmetadata(t)
-    if meta !== nothing
-        haskey(meta, key) && return style ? meta[key] : (meta[key], :default)
+# Zone-NAIVE timestamp columns: `Durations.Timestamp`, `DateTime`, and `Date`
+# values lower by instant. Zoned values never lower here — the public
+# domain defines them as unequal to every zone-naive value.
+@inline function _timestampstorage(unit, value)::Union{Nothing,Int64}
+    if value isa Durations.Timestamp
+        from = _periodticks(_instantperiod(value))
+        from === nothing && return nothing
+        return _rescalecount(Int64(Dates.value(value)), from, _unitticks(unit))
     end
-    return style ? (default, :default) : default
+    value isa Durations.ZonedTimestamp && return nothing
+    millis = _epochmillis(value)
+    millis === nothing && return nothing
+    return _rescalecount(millis, Int64(1_000), _unitticks(unit))
 end
 
-function DataAPI.metadatakeys(t::Table)
-    meta = getmetadata(t)
-    meta === nothing && return ()
-    return keys(meta)
+# Zone-DECLARED timestamp columns: a `ZonedTimestamp` value in ANY zone
+# lowers to its UTC instant — public `==`/`isless` between zoned values
+# compare only the UTC time, so the zone label plays no role. With TimeZones
+# loaded, `ZonedDateTime` values lower the same way through the extension
+# (it lowers only its own type and never throws). Zone-naive values do not
+# lower: the domain defines them as unequal to every zoned value.
+@inline function _zonedtimestampstorage(unit, value)::Union{Nothing,Int64}
+    if value isa Durations.ZonedTimestamp
+        from = _periodticks(_instantperiod(value))
+        from === nothing && return nothing
+        return _rescalecount(Int64(Dates.value(value)), from, _unitticks(unit))
+    end
+    ext = Base.get_extension(@__MODULE__, :ArrowTimeZonesExt)
+    ext === nothing && return nothing
+    z = ext.zonedstorage(unit, value)
+    return z === nothing ? nothing : z::Int64
+end
+
+@inline function _periodnanos(value)::Union{Nothing,Int128}
+    # Keep `Dates.value` inside each `isa` branch. Returning only the scale
+    # loses the type refinement for Vector{Any} and boxes every converted row.
+    value isa Dates.Week && return Int128(Dates.value(value)) * Int128(604_800_000_000_000)
+    value isa Dates.Day && return Int128(Dates.value(value)) * Int128(86_400_000_000_000)
+    value isa Dates.Hour && return Int128(Dates.value(value)) * Int128(3_600_000_000_000)
+    value isa Dates.Minute && return Int128(Dates.value(value)) * Int128(60_000_000_000)
+    value isa Dates.Second && return Int128(Dates.value(value)) * Int128(1_000_000_000)
+    value isa Dates.Millisecond && return Int128(Dates.value(value)) * Int128(1_000_000)
+    value isa Dates.Microsecond && return Int128(Dates.value(value)) * Int128(1_000)
+    value isa Dates.Nanosecond && return Int128(Dates.value(value))
+    return nothing
 end
 
-function DataAPI.colmetadata(t::Table, col, key::AbstractString; style::Bool=false)
-    meta = getmetadata(t[col])[key]
-    return style ? (meta, :default) : meta
+@inline _durationunitscale(unit) =
+    unit == AC.SECOND ? Int128(1_000_000_000) :
+    unit == AC.MILLISECOND ? Int128(1_000_000) :
+    unit == AC.MICROSECOND ? Int128(1_000) : Int128(1)
+
+@inline function _durationstorage(unit, value)::Union{Nothing,Int64}
+    nanos = _periodnanos(value)
+    nanos === nothing && return nothing
+    divisor = _durationunitscale(unit)
+    q, r = divrem(nanos, divisor)
+    iszero(r) || return nothing
+    return _boundedint64(q)
 end
 
-function DataAPI.colmetadata(t::Table, col, key::AbstractString, default; style::Bool=false)
-    meta = getmetadata(t[col])
-    if meta !== nothing
-        haskey(meta, key) && return style ? (meta[key], :default) : meta[key]
+"""
+Lower a built-in temporal value without exceptions or request-defined code.
+
+`K` is one of the eighteen `_facadetoken` descriptor/unit values. The result
+is exact, or `nothing` when the value has no exact storage value.
+"""
+@inline function _exactfacadevalue(::Val{K}, value)::Union{Nothing,Int32,Int64} where {K}
+    kind, unit = K
+    if kind === :date
+        return unit == AC.DAY ? _datestorage(value) : _epochmillis(value)
+    elseif kind === :timestamp
+        return _timestampstorage(unit, value)
+    elseif kind === :zonedtimestamp
+        return _zonedtimestampstorage(unit, value)
+    elseif kind === :time
+        return _timestorage(unit, value)
+    elseif kind === :duration
+        return _durationstorage(unit, value)
     end
-    return style ? (default, :default) : default
+    return nothing
 end
 
-function DataAPI.colmetadatakeys(t::Table, col)
-    meta = getmetadata(t[col])
-    meta === nothing && return ()
-    return keys(meta)
+function _facadeconversionfailure(err)
+    err isa Union{InterruptException,OutOfMemoryError} && throw(err)
+    err isa Union{InexactError,OverflowError,MethodError} || throw(err)
+    # Range, inexactness, and missing conversion methods all mean that no
+    # exact facade-to-storage representation exists.
+    return nothing
 end
 
-function DataAPI.colmetadatakeys(t::Table)
-    return (
-        col => DataAPI.colmetadatakeys(t, col) for
-        col in Tables.columnnames(t) if getmetadata(t[col]) !== nothing
-    )
+@inline _exactfacadescalar(t::AC.DateType, value) =
+    t.unit == AC.DAY ? _datestorage(value) : _epochmillis(value)
+@inline _exactfacadescalar(t::AC.TimestampType, value) =
+    _timestampzone(t) === nothing ? _timestampstorage(t.unit, value) :
+    _zonedtimestampstorage(t.unit, value)
+@inline _exactfacadescalar(t::AC.TimeType, value) = _timestorage(t.unit, value)
+@inline _exactfacadescalar(t::AC.DurationType, value) = _durationstorage(t.unit, value)
+
+_facadescalarvalue(t::Union{AC.DateType,AC.TimeType}, value) = _exactfacadescalar(t, value)
+
+_facadescalarvalue(t::AC.TimestampType, value) = _exactfacadescalar(t, value)
+
+@noinline function _customdurationvalue(
+    t::AC.DurationType,
+    value::Dates.Period,
+)::Union{Nothing,Int64}
+    period =
+        t.unit == AC.SECOND ? Dates.Second :
+        t.unit == AC.MILLISECOND ? Dates.Millisecond :
+        t.unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
+    try
+        return Int64(Dates.value(convert(period, value)))
+    catch err
+        return _facadeconversionfailure(err)
+    end
 end
 
-Tables.istable(::Table) = true
-Tables.columnaccess(::Table) = true
-Tables.columns(t::Table) = Tables.CopiedColumns(t)
-Tables.schema(t::Table) = Tables.Schema(names(t), types(t))
-Tables.columnnames(t::Table) = names(t)
-Tables.getcolumn(t::Table, i::Int) = columns(t)[i]
-Tables.getcolumn(t::Table, nm::Symbol) = lookup(t)[nm]
+function _facadescalarvalue(t::AC.DurationType, value)::Union{Nothing,Int64}
+    result = _exactfacadescalar(t, value)
+    result === nothing || return result
+    value isa Dates.Period || return nothing
+    return _customdurationvalue(t, value)
+end
 
-struct TablePartitions
-    table::Table
-    npartitions::Int
+"""
+Lower one public value to a descriptor's storage domain exactly: `(true, stored)`,
+or `(false, v)` when conversion would change facade comparison semantics, which
+retained column construction reports as incompatible replacement data.
+"""
+function _facadetostorage(t::AC.ArrowType, v)
+    t isa AC.DictionaryType && return _facadetostorage(t.valuetype, v)
+    if t isa Union{AC.DateType,AC.TimestampType,AC.TimeType,AC.DurationType}
+        stored = _facadescalarvalue(t, v)
+        return stored === nothing ? (false, v) : (true, stored)
+    end
+    # Non-temporal fields compare in their storage (and public) domain, but
+    # temporal public values — including Timestamp and ZonedTimestamp,
+    # which are AbstractDateTime — are incompatible with them.
+    if v isa Dates.Date ||
+       v isa Dates.AbstractDateTime ||
+       v isa Dates.Time ||
+       v isa Dates.Period
+        return false, v
+    end
+    return true, v
 end
 
-function TablePartitions(table::Table)
-    cols = columns(table)
-    npartitions = if length(cols) == 0
-        0
-    elseif cols[1] isa ChainedVector
-        length(cols[1].arrays)
-    else
-        1
+function _mapcol(::Type{T}, f::F, col, budget=nothing) where {T,F}
+    Out = Missing <: eltype(col) ? Union{Missing,T} : T
+    _chargevector!(budget, Out, length(col), "facade converted column")
+    out = Vector{Out}(undef, length(col))
+    for i in eachindex(col)
+        value = col[i]
+        out[i] = value === missing ? missing : f(value)::T
     end
-    return TablePartitions(table, npartitions)
-end
-
-function Base.iterate(tp::TablePartitions, i=1)
-    i > tp.npartitions && return nothing
-    tp.npartitions == 1 && return tp.table, i + 1
-    cols = columns(tp.table)
-    newcols = AbstractVector[cols[j].arrays[i] for j = 1:length(cols)]
-    nms = names(tp.table)
-    tbl = Table(
-        nms,
-        types(tp.table),
-        newcols,
-        Dict{Symbol,AbstractVector}(nms[i] => newcols[i] for i = 1:length(nms)),
-        schema(tp.table),
+    return out
+end
+
+@inline _timestampperiod(unit) =
+    unit == AC.SECOND ? Dates.Second :
+    unit == AC.MILLISECOND ? Dates.Millisecond :
+    unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
+
+# The `ZonedTimestamp{P,Z}` (and `Timestamp{P}`) element type of a
+# zone-declared (naive micro/nanosecond) timestamp column. Both types have
+# the 8-byte layout of the Arrow column itself — every Int64 is a valid
+# value — so conversion is a per-element reinterpret.
+_zonedtimestamptype(unit, zone::String) =
+    Durations.ZonedTimestamp{_timestampperiod(unit),_zonesymbol(zone)}
+
+# The declared zone becomes a type parameter. A Symbol cannot hold an
+# embedded NUL, and the facade's per-name bound keeps input-controlled zone
+# names from interning arbitrarily large process-global state.
+function _zonesymbol(zone::String)
+    occursin('\0', zone) &&
+        throw(AC.ValidationError("timestamp timezone contains an embedded NUL"))
+    ncodeunits(zone) <= _MAX_ARROWTYPE_SCHEMA_NAME_BYTES || throw(
+        AC.ValidationError(
+            "timestamp timezone exceeds $_MAX_ARROWTYPE_SCHEMA_NAME_BYTES UTF-8 bytes",
+        ),
     )
-    return tbl, i + 1
-end
-
-Tables.partitions(t::Table) = TablePartitions(t)
-
-# high-level user API functions
-Table(input, pos::Integer=1, len=nothing; kw...) =
-    Table([ArrowBlob(tobytes(input), pos, len)]; kw...)
-Table(input::Vector{UInt8}, pos::Integer=1, len=nothing; kw...) =
-    Table([ArrowBlob(tobytes(input), pos, len)]; kw...)
-Table(inputs::Vector; kw...) =
-    Table([ArrowBlob(tobytes(x), 1, nothing) for x in inputs]; kw...)
-
-# will detect whether we're reading a Table from a file or stream
-function Table(blobs::Vector{ArrowBlob}; convert::Bool=true)
-    t = Table()
-    sch = nothing
-    dictencodingslockable = Lockable(Dict{Int64,DictEncoding}()) # dictionary id => DictEncoding
-    dictencoded = Dict{Int64,Meta.Field}() # dictionary id => field
-    # we'll grow/add a record batch set of columns as they're constructed
-    # must be holding the lock while growing/adding
-    # starts at 0-length because we don't know how many record batches there will be
-    rb_cols = []
-    rb_cols_lock = ReentrantLock()
-    rbi = 1
-    tasks = Task[]
-    for blob in blobs
-        for batch in BatchIterator(blob)
-            # store custom_metadata of batch.msg?
-            header = batch.msg.header
-            if header isa Meta.Schema
-                @debug "parsing schema message"
-                # assert endianness?
-                # store custom_metadata?
-                if sch === nothing
-                    for (i, field) in enumerate(header.fields)
-                        push!(names(t), Symbol(field.name))
-                        # recursively find any dictionaries for any fields
-                        getdictionaries!(dictencoded, field)
-                        @debug "parsed column from schema: field = $field"
-                    end
-                    sch = header
-                    schema(t)[] = sch
-                elseif sch != header
-                    throw(
-                        ArgumentError(
-                            "mismatched schemas between different arrow batches: $sch != $header",
-                        ),
-                    )
-                end
-            elseif header isa Meta.DictionaryBatch
-                # Earlier record batches must capture their dictionaries before an update.
-                _waitall(tasks)
-                empty!(tasks)
-                id = header.id
-                recordbatch = header.data
-                @debug "parsing dictionary batch message: id = $id, compression = $(recordbatch.compression)"
-                @lock dictencodingslockable begin
-                    dictencodings = dictencodingslockable[]
-                    if haskey(dictencodings, id) && header.isDelta
-                        # delta
-                        field = dictencoded[id]
-                        values, _, _, _ = build(
-                            field,
-                            field.type,
-                            batch,
-                            recordbatch,
-                            dictencodingslockable,
-                            Int64(1),
-                            Int64(1),
-                            Int64(1),
-                            convert,
-                        )
-                        dictencoding = dictencodings[id]
-                        append!(dictencoding.data, values)
-                        continue
-                    end
-                    # new dictencoding or replace
-                    field = dictencoded[id]
-                    values, _, _, _ = build(
-                        field,
-                        field.type,
-                        batch,
-                        recordbatch,
-                        dictencodingslockable,
-                        Int64(1),
-                        Int64(1),
-                        Int64(1),
-                        convert,
-                    )
-                    # Keep the dictionary storage type stable when later deltas arrive.
-                    A = ChainedVector([values])
-                    S =
-                        field.dictionary.indexType === nothing ? Int32 :
-                        juliaeltype(field, field.dictionary.indexType, false)
-                    dictencodings[id] = DictEncoding{eltype(A),S,typeof(A)}(
-                        id,
-                        A,
-                        field.dictionary.isOrdered,
-                        values.metadata,
-                    )
-                end # lock
-                @debug "parsed dictionary batch message: id=$id, data=$values\n"
-            elseif header isa Meta.RecordBatch
-                @debug "parsing record batch message: compression = $(header.compression)"
-                push!(
-                    tasks,
-                    collect_cols!(
-                        rbi,
-                        rb_cols_lock,
-                        rb_cols,
-                        sch,
-                        batch,
-                        dictencodingslockable,
-                        convert,
-                    ),
-                )
-                rbi += 1
-            else
-                throw(ArgumentError("unsupported arrow message type: $(typeof(header))"))
-            end
-        end
-    end
-    _waitall(tasks)
-    lu = lookup(t)
-    ty = types(t)
-    # 158; some implementations may send 0 record batches
-    # no more multithreading, so no need to take the lock now
-    if length(rb_cols) == 0 && !isnothing(sch)
-        for field in sch.fields
-            T = juliaeltype(field, buildmetadata(field), convert)
-            push!(columns(t), T[])
-        end
+    return Symbol(zone)
+end
+
+# Function barrier: `T` arrives as a runtime type (the zone name is a type
+# parameter), one dynamic call per column, and the element loop compiles
+# type-stable per `T`.
+_instantcolumn(::Type{T}, col, budget) where {T} =
+    _mapcol(T, x -> reinterpret(T, Int64(x)), col, budget)
+
+_postconvert(::AC.ArrowType, col, budget=nothing) = col
+
+# The convertible-leaf authority, per SCALAR: the same conversions the
+# `_postconvert` column methods apply, for one value at a time. The dynamic
+# row builder below uses it where a leaf lands inside an `Any`-shaped row.
+# A differential test pins scalar/column agreement for every leaf kind.
+_isconvertibleleaf(t::AC.ArrowType) =
+    t isa AC.DateType ||
+    t isa AC.TimeType ||
+    t isa AC.TimestampType ||
+    t isa AC.DurationType ||
+    t isa AC.IntervalType ||
+    (t isa AC.DecimalType && _shareddecimal(t))
+
+function _publicleafscalar(t::AC.ArrowType, x)
+    if t isa AC.DateType
+        return t.unit == AC.DAY ? Dates.Date(Dates.UTD(Int64(x) + _EPOCH_DAYS)) :
+               Dates.DateTime(Dates.UTM(Int64(x) + Dates.UNIXEPOCH))
+    elseif t isa AC.TimestampType
+        zone = _timestampzone(t)
+        T =
+            zone === nothing ? Durations.Timestamp{_timestampperiod(t.unit)} :
+            _zonedtimestamptype(t.unit, zone)
+        return reinterpret(T, Int64(x))
+    elseif t isa AC.TimeType
+        return _publictime(t.unit, x)
+    elseif t isa AC.DurationType
+        P =
+            t.unit == AC.SECOND ? Dates.Second :
+            t.unit == AC.MILLISECOND ? Dates.Millisecond :
+            t.unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
+        return P(Int64(x))
+    elseif t isa AC.IntervalType
+        return t.unit == AC.YEAR_MONTH ? Durations.Duration(x, 0, 0) :
+               t.unit == AC.DAY_TIME ?
+               Durations.Duration(0, x.days, Int64(x.millis) * 1_000_000) :
+               Durations.Duration(x.months, x.days, x.nanos)
+    elseif t isa AC.DecimalType && _shareddecimal(t)
+        return _shareddecimalscalar(
+            _decimalhost(t),
+            _decimalstorage(t),
+            Int(t.precision),
+            x,
+        )
     end
-    if length(rb_cols) > 0
-        foreach(x -> push!(columns(t), x), rb_cols[1])
+    return x
+end
+
+# Whole-column conversion, FIELD-aware: transparent wrappers (run-end
+# encoding via the values child field, dictionary via the value field) walk
+# to the leaf whose descriptor governs every element of the flat column the
+# typed path produced. Composite roots fall to the no-op: their rows were
+# already built in the public domain by `_publicvalue`.
+function _postconvertfield(f::AC.Field, col, budget=nothing)
+    t = f.type
+    if t isa AC.RunEndEncodedType && length(f.children) == 2
+        return _postconvertfield(f.children[2], col, budget)
     end
-    if length(rb_cols) > 1
-        foreach(enumerate(rb_cols[2])) do (i, x)
-            columns(t)[i] = ChainedVector([columns(t)[i], x])
+    t isa AC.DictionaryType &&
+        return _postconvertfield(AC.dictvaluefield(f, t), col, budget)
+    return _postconvert(t, col, budget)
+end
+
+# The facade's dynamic row builder: Core's `_value` shapes — struct rows as
+# `Vector{Pair{String,Any}}`, list rows as `Vector{Any}`, map rows as
+# `Vector{Pair{Any,Any}}` — with facade-converted leaves. `convertleaf` is
+# false at a column root: a root scalar (or a transparent-wrapper chain to
+# one) stays in storage for the one-pass whole-column conversion above and
+# for storage-domain scan predicates. It turns true when the walk enters a
+# composite container, where each leaf value lands inside an `Any`-shaped
+# row and must convert AS it is read — a built union row cannot recover its
+# branch afterward, so leaf conversion cannot run as a post-pass.
+function _publicvalue(f::AC.Field, d::AC.ArrayData, i::Int64, budget, convertleaf::Bool)
+    t = f.type
+    if t isa AC.DictionaryType
+        AC.isvalid_at(d, i) || return missing
+        w = AC.primwidth(t.indextype)
+        index =
+            AC._load_int(AC.rolebuffer(d, AC.DATA), t.indextype, AC._slotbyteoff(d, i, w))
+        pool = d.dictionary
+        pool === nothing && throw(AC.ValidationError("dictionary array has no value pool"))
+        return _publicvalue(
+            AC.dictvaluefield(f, t),
+            pool,
+            AC.checked_add(Int64(index), Int64(1)),
+            budget,
+            convertleaf,
+        )
+    elseif t isa AC.RunEndEncodedType && length(f.children) == 2
+        return _publicvalue(
+            f.children[2],
+            d.children[2],
+            AC._ree_runindex(d, i),
+            budget,
+            convertleaf,
+        )
+    elseif t isa AC.UnionType
+        childfield, childdata, childindex = AC._union_child(f, d, i)
+        return _publicvalue(childfield, childdata, childindex, budget, true)
+    elseif t isa AC.ListType
+        AC.isvalid_at(d, i) || return missing
+        lo, hi = AC._offsets_at(d, i, AC.layoutspec(t).offsetwidth == 8)
+        childfield, childdata = f.children[1], d.children[1]
+        _chargevector!(budget, Any, hi - lo, "facade public list row")
+        out = Vector{Any}(undef, Int(hi - lo))
+        for k = 1:length(out)
+            out[k] = _publicvalue(
+                childfield,
+                childdata,
+                AC.checked_add(lo, Int64(k)),
+                budget,
+                true,
+            )
         end
-        foreach(3:length(rb_cols)) do j
-            foreach(enumerate(rb_cols[j])) do (i, x)
-                append!(columns(t)[i], x)
-            end
+        return out
+    elseif t isa AC.ListViewType
+        AC.isvalid_at(d, i) || return missing
+        off, size = AC._listview_range(t, d, i)
+        childfield, childdata = f.children[1], d.children[1]
+        _chargevector!(budget, Any, size, "facade public list-view row")
+        out = Vector{Any}(undef, Int(size))
+        for k = 1:length(out)
+            out[k] = _publicvalue(
+                childfield,
+                childdata,
+                AC.checked_add(off, Int64(k)),
+                budget,
+                true,
+            )
+        end
+        return out
+    elseif t isa AC.FixedSizeListType
+        AC.isvalid_at(d, i) || return missing
+        childfield, childdata = f.children[1], d.children[1]
+        base = AC.checked_mul(AC._slotindex0(d, i), Int64(t.listsize))
+        _chargevector!(budget, Any, t.listsize, "facade public fixed-list row")
+        out = Vector{Any}(undef, t.listsize)
+        for k = 1:(t.listsize)
+            out[k] = _publicvalue(
+                childfield,
+                childdata,
+                AC.checked_add(base, Int64(k)),
+                budget,
+                true,
+            )
         end
+        return out
+    elseif t isa AC.StructType
+        AC.isvalid_at(d, i) || return missing
+        childindex = AC.checked_add(d.offset, i)
+        _chargevector!(
+            budget,
+            Pair{String,Any},
+            length(f.children),
+            "facade public struct row",
+        )
+        out = Vector{Pair{String,Any}}(undef, length(f.children))
+        for k in eachindex(f.children)
+            out[k] =
+                f.children[k].name =>
+                    _publicvalue(f.children[k], d.children[k], childindex, budget, true)
+        end
+        return out
+    elseif t isa AC.MapType
+        AC.isvalid_at(d, i) || return missing
+        lo, hi = AC._offsets_at(d, i, false)
+        entriesfield, entriesdata = f.children[1], d.children[1]
+        keyfield, valuefield = entriesfield.children
+        keydata, valuedata = entriesdata.children
+        _chargevector!(budget, Pair{Any,Any}, hi - lo, "facade public map row")
+        out = Vector{Pair{Any,Any}}(undef, Int(hi - lo))
+        for k = 1:length(out)
+            entryindex = AC.checked_add(entriesdata.offset, AC.checked_add(lo, Int64(k)))
+            out[k] = Pair{Any,Any}(
+                _publicvalue(keyfield, keydata, entryindex, budget, true),
+                _publicvalue(valuefield, valuedata, entryindex, budget, true),
+            )
+        end
+        return out
     end
-    for (nm, col) in zip(names(t), columns(t))
-        lu[nm] = col
-        push!(ty, eltype(col))
+    # A null slot must not run the budgeted extraction: its transient
+    # charging machinery would allocate per missing value with nothing to
+    # reserve it against. The Null layout has no validity buffer (asking
+    # for it throws) and every slot is missing.
+    t isa AC.NullType && return missing
+    AC.isvalid_at(d, i) || return missing
+    x = budget === nothing ? AC.getvalue(f, d, i) : AC.getvalue(f, d, i, budget)
+    (convertleaf && x !== missing && _isconvertibleleaf(t)) || return x
+    # The converted value is one more boxed object beside the storage value
+    # the budgeted getvalue charged, plus transient conversion temporaries;
+    # the measured worst case (shared Decimal inside a union row) leaves
+    # about 96 bytes of boxes and charging machinery per converted leaf.
+    _chargeobject!(budget, 96, "facade converted leaf")
+    return _publicleafscalar(t, x)
+end
+
+"One dynamic-path column: public rows, storage roots (see `_publicvalue`)."
+function _publicdynamiccolumn(f::AC.Field, d::AC.ArrayData, budget=nothing)
+    _chargevector!(budget, Any, d.len, "facade dynamic column")
+    return Any[_publicvalue(f, d, Int64(i), budget, false) for i = 1:(d.len)]
+end
+_postconvert(t::AC.DateType, col, budget=nothing) =
+    t.unit == AC.DAY ?
+    _mapcol(Dates.Date, x -> Dates.Date(Dates.UTD(Int64(x) + _EPOCH_DAYS)), col, budget) :
+    _mapcol(
+        Dates.DateTime,
+        x -> Dates.DateTime(Dates.UTM(Int64(x) + Dates.UNIXEPOCH)),
+        col,
+        budget,
+    )
+function _postconvert(t::AC.TimestampType, col, budget=nothing)
+    zone = _timestampzone(t)
+    # A zone-declared column materializes as `ZonedTimestamp` and a
+    # zone-naive one as `Timestamp`, both at every unit: the stored value IS
+    # the instant count, so conversion is a per-element reinterpret and no
+    # value can wrap or truncate.
+    zone === nothing ||
+        return _instantcolumn(_zonedtimestamptype(t.unit, zone), col, budget)
+    return _instantcolumn(Durations.Timestamp{_timestampperiod(t.unit)}, col, budget)
+end
+function _postconvert(t::AC.TimeType, col, budget=nothing)
+    unit = t.unit
+    return _mapcol(Dates.Time, x -> _publictime(unit, x), col, budget)
+end
+function _postconvert(t::AC.DurationType, col, budget=nothing)
+    P =
+        t.unit == AC.SECOND ? Dates.Second :
+        t.unit == AC.MILLISECOND ? Dates.Millisecond :
+        t.unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
+    return _mapcol(P, x -> P(Int64(x)), col, budget)
+end
+
+# The public element type of the SCALAR layouts the facade converts (Dates)
+# or passes through; `_declaredbasetype` completes it for every layout and
+# `_declaredeltype` is the Field-aware rule the facade materializes with.
+function _facadebasetype(t::AC.ArrowType)
+    t isa AC.DateType && return t.unit == AC.DAY ? Dates.Date : Dates.DateTime
+    if t isa AC.TimestampType
+        zone = _timestampzone(t)
+        zone === nothing || return _zonedtimestamptype(t.unit, zone)
+        return Durations.Timestamp{_timestampperiod(t.unit)}
     end
-    getfield(t, :metadata)[] = buildmetadata(sch)
-    return t
-end
-
-function collect_cols!(
-    rbi,
-    rb_cols_lock,
-    rb_cols,
-    sch,
-    batch,
-    dictencodingslockable,
-    convert,
-)
-    @wkspawn begin
-        cols = collect(VectorIterator(sch, batch, dictencodingslockable, convert))
-        @lock rb_cols_lock begin
-            if length(rb_cols) < rbi
-                resize!(rb_cols, rbi)
-            end
-            rb_cols[rbi] = cols
-        end
+    t isa AC.TimeType && return Dates.Time
+    if t isa AC.DurationType
+        return t.unit == AC.SECOND ? Dates.Second :
+               t.unit == AC.MILLISECOND ? Dates.Millisecond :
+               t.unit == AC.MICROSECOND ? Dates.Microsecond : Dates.Nanosecond
     end
+    t isa AC.DictionaryType && return _facadebasetype(t.valuetype)
+    t isa AC.IntType && return AC.juliatype(t)
+    t isa AC.FloatType && return AC.juliatype(t)
+    t isa AC.BoolType && return Bool
+    t isa AC.Utf8Type && return String
+    (t isa AC.ViewType && t.utf8) && return String
+    return Any
+end
+
+# The public element type of a materialized column: the Field's declared
+# domain (`_declaredeltype(f, true)` — closed for scalars, the row container
+# for composites, transparent through dictionary/REE, the children's join
+# for unions), widened with `Missing` only when the DATA holds nulls a
+# non-nullable declaration did not admit. Field nullability is advisory at
+# the reader tier (the semantic validation IPC applies accepts such data,
+# as the reference implementation does), so those columns READ, as
+# missing-capable, rather than throw. `Any` stays the narrowing path.
+function _publictype(f::AC.Field, col)
+    T = _declaredeltype(f, true)
+    (T === Any || Missing <: T) && return T
+    (eltype(col) >: Missing && any(x -> x === missing, col)) || return T
+    return Union{Missing,T}
 end
 
-function getdictionaries!(dictencoded, field)
-    d = field.dictionary
-    if d !== nothing
-        dictencoded[d.id] = field
+"The concrete element join a package-owned narrowing copy will allocate."
+function _narrowedeltype(values)
+    isempty(values) && return Any
+    T = typeof(first(values))
+    for i in Iterators.drop(eachindex(values), 1)
+        T = Base.promote_typejoin(T, typeof(values[i]))
+        T === Any && break
     end
-    if field.children !== nothing
-        for child in field.children
-            getdictionaries!(dictencoded, child)
-        end
+    return T
+end
+
+"Copy one vector after preflighting and charging its final element type."
+function _narrowcopy(values, budget, what::AbstractString)
+    T = _narrowedeltype(values)
+    _chargevector!(budget, T, length(values), what)
+    out = Vector{T}(undef, length(values))
+    copyto!(out, values)
+    return out
+end
+
+"""
+The public column for `converted`, a column already in the public domain.
+`owned=true` means no other object references `converted` (the facade just
+materialized or joined it), so a vector that already has the public element
+type is returned as is instead of copied.
+"""
+function _publiccolumn(f::AC.Field, converted, budget=nothing; owned::Bool=false)
+    T = _publictype(f, converted)
+    T === Any && return _narrowcopy(converted, budget, "facade public column")
+    owned && converted isa Vector{T} && return converted
+    _chargevector!(budget, T, length(converted), "facade public column")
+    return _collectas(T, converted)
+end
+
+# A claim the typed path resolves without boxing: concrete scalars,
+# their Missing unions, and Vectors thereof. `Vector{Any}` (lists of
+# unresolved children) and the `Vector{Pair}` composite rows gain nothing
+# typed, so they stay on the dynamic path.
+function _closedclaim(::Type{T}) where {T}
+    T === Any && return false
+    # NullType columns claim Missing (nonmissingtype gives BOTTOM, which
+    # subtypes Vector and has no eltype): the dynamic path serves them.
+    T === Missing && return false
+    NT = Base.nonmissingtype(T)
+    NT === Union{} && return false
+    NT <: Vector && return _closedclaim(eltype(NT))
+    NT <: Pair && return false
+    return isconcretetype(NT)
+end
+
+# The claim alone cannot see a union: a homogeneous union JOINS to a
+# concrete Julia type, but Core refuses every typed union read — the
+# route must inspect the descriptor through the transparent wrappers.
+function _typedroutable(f::AC.Field)
+    t = f.type
+    t isa AC.UnionType && return false
+    t isa AC.DictionaryType && return _typedroutable(AC.dictvaluefield(f, t))
+    (t isa AC.RunEndEncodedType && length(f.children) == 2) &&
+        return _typedroutable(f.children[2])
+    return true
+end
+
+"The storage element claim shared by decoded batches and zero-part scan joins."
+function _storageelementclaim(f::AC.Field)
+    T = _declaredeltype(f, false)
+    return _closedclaim(T) && _typedroutable(f) ? T : Any
+end
+
+"""
+Materialize one batch column in the storage domain: through the typed element
+path when its raw domain is closed, else through Core's dynamic path. This
+never emits the private ArrowTypes Union routing markers.
+"""
+function _storagebatchcolumn(f::AC.Field, d::AC.ArrayData, budget=nothing)
+    # A registered extension over a decimal restores from raw coefficients.
+    (_isbulkdecimal(f) && !_hasarrowtypesextension(f)) &&
+        return _decimalcolumn(f, d, budget)
+    T = _storageelementclaim(f)
+    T === Any &&
+        return budget === nothing ? AC.materialize(f, d) : AC.materialize(f, d, budget)
+    # Field nullability is advisory: the batch may hold nulls under a
+    # non-nullable declaration (the semantic tier accepts that, as the
+    # reference implementation does). Admit them in the claim rather than
+    # refuse the read; conforming batches keep the Missing-free fast path.
+    (Missing <: T || !_hasnulls(f, d)) || (T = Union{Missing,T})
+    # `T` is known at run time; see `_uninferred`.
+    return budget === nothing ? _uninferred(AC.materialize, T, f, d) :
+           _uninferred(AC.materialize, T, f, d, budget)
+end
+
+# The public-domain sibling of `_storagebatchcolumn`: identical typed path
+# (the flat storage column converts once, whole-column, in `_facadefromraw`),
+# but the dynamic path builds PUBLIC rows — composite leaf conversion cannot
+# run as a post-pass (see `_publicvalue`).
+function _publicbatchcolumn(f::AC.Field, d::AC.ArrayData, budget=nothing)
+    _isbulkdecimal(f) && return _decimalcolumn(f, d, budget)
+    T = _storageelementclaim(f)
+    T === Any && return _publicdynamiccolumn(f, d, budget)
+    (Missing <: T || !_hasnulls(f, d)) || (T = Union{Missing,T})
+    return budget === nothing ? _uninferred(AC.materialize, T, f, d) :
+           _uninferred(AC.materialize, T, f, d, budget)
+end
+
+"Materialize for the facade, retaining an ArrowTypes Union route when needed."
+function _batchcolumn(f::AC.Field, d::AC.ArrayData, plan::_ArrowTypesRoutePlan)
+    if _hasarrowtypesextension(f, plan)
+        # Ext-bearing columns WITH structure walk the routed builder: it
+        # keeps union branch provenance and splits labeled (raw, for
+        # restoration) from label-free (public) subtrees. A flat labeled
+        # leaf column stays on the typed storage path; restoration converts
+        # the whole column at once.
+        routed = _arrowtypesroutedcolumn(f, d, plan; force=(!isempty(f.children)))
+        routed === nothing || return routed
+        return _storagebatchcolumn(f, d, plan.budget)
+    end
+    return _publicbatchcolumn(f, d, plan.budget)
+end
+
+function _batchcolumn(f::AC.Field, d::AC.ArrayData, arrowtypes::_ArrowTypesContext)
+    if _hasarrowtypesextension(f, arrowtypes)
+        routed = _arrowtypesroutedcolumn(
+            f,
+            d,
+            _arrowtypesrouteplan!(arrowtypes);
+            force=(!isempty(f.children)),
+        )
+        routed === nothing || return routed
+        return _storagebatchcolumn(f, d, arrowtypes.budget)
     end
-    return
+    return _publicbatchcolumn(f, d, arrowtypes.budget)
 end
 
-struct Batch
-    msg::Meta.Message
-    bytes::Vector{UInt8}
-    pos::Int
-    id::Int
+function _batchcolumn(f::AC.Field, d::AC.ArrayData, budget=nothing)
+    _hasarrowtypesextension(f) || return _publicbatchcolumn(f, d, budget)
+    return _batchcolumn(f, d, _ArrowTypesRoutePlan(budget))
 end
 
-function Base.iterate(x::BatchIterator, (pos, id)=(x.startpos, 0))
-    @debug "checking for next arrow message: pos = $pos"
-    if pos + 3 > length(x.bytes)
-        @debug "not enough bytes left for another batch message"
-        return nothing
+# Whether the typed claim for `f` would meet a null in `d`: physical nulls
+# at this level, plus — through the wrappers the claim is transparent to —
+# the REE values child's and a dictionary pool's.
+function _hasnulls(f::AC.Field, d::AC.ArrayData)
+    t = d.type
+    if t isa AC.RunEndEncodedType && length(d.children) == 2 && length(f.children) == 2
+        return _hasnulls(f.children[2], d.children[2])
     end
-    if readbuffer(x.bytes, pos, UInt32) != CONTINUATION_INDICATOR_BYTES
-        @debug "didn't find continuation byte to keep parsing messages: $(readbuffer(x.bytes, pos, UInt32))"
-        return nothing
+    if t isa AC.DictionaryType && d.dictionary !== nothing
+        return AC.nullcount(d) > 0 || _hasnulls(AC.dictvaluefield(f, t), d.dictionary)
     end
-    pos += 4
-    if pos + 3 > length(x.bytes)
-        @debug "not enough bytes left to read length of another batch message"
-        return nothing
+    return AC.nullcount(d) > 0
+end
+
+function _facadecolumn(
+    f::AC.Field,
+    parts::Vector,
+    arrowtypes::_ArrowTypesContext=_ArrowTypesContext(),
+)
+    budget = arrowtypes.budget
+    if isempty(parts)
+        T =
+            _hasarrowtypesextension(f, arrowtypes) ?
+            _arrowtypespubliceltype(arrowtypes, f) : _declaredeltype(f, true)
+        _chargevector!(budget, T === Any ? Any : T, 0, "empty facade column")
+        return T === Any ? Any[] : Vector{T}()
     end
-    msglen = readbuffer(x.bytes, pos, Int32)
-    if msglen == 0
-        @debug "message has 0 length; terminating message parsing"
-        return nothing
+    col = _joinparts(parts, budget)
+    # `col` is a fresh batch materialization or the join just built; its type
+    # is known at run time (see `_uninferred`).
+    return _uninferred(_facadefromraw, f, col, arrowtypes; owned=true)
+end
+
+function _facadesinglecolumn(f::AC.Field, d::AC.ArrayData, arrowtypes::_ArrowTypesContext)
+    _chargevector!(arrowtypes.budget, AbstractVector, 1, "batch column parts")
+    return _facadecolumn(f, AbstractVector[_batchcolumn(f, d, arrowtypes)], arrowtypes)
+end
+
+_columndatas(batches, i::Int) = AC.ArrayData[b.columns[i] for b in batches]
+
+"""
+Table columns `idxs` of `fields` over decoded `batches`, built on at most
+`ntasks` tasks: a view column is one piece of work, a string or binary
+column is cut into chunks of rows, and the materialized (nested, union,
+extension) columns build on the calling task afterwards.
+"""
+# With `lazy`, string and binary columns are `_PendingStrings` that build when a
+# table first hands them out.
+function _buildcolumns(
+    fields,
+    batches,
+    idxs,
+    arrowtypes,
+    views::_ViewContext,
+    ntasks::Int;
+    lazy::Bool=false,
+)
+    m = length(idxs)
+    _chargevector!(views.budget, AbstractVector, m, "table columns")
+    cols = Vector{AbstractVector}(undef, m)
+    builds = Vector{Any}(nothing, m)
+    jobs = Tuple{Int,Int}[]   # (output column, string chunk or 0 for the whole column)
+    rows = ntasks > 1 ? _STRING_CHUNK_ROWS : typemax(Int)
+    for (p, i) in enumerate(idxs)
+        f = fields[i]
+        _viewable(f) || continue
+        if _isstringlayout(f.type)
+            datas = _columndatas(batches, i)
+            T = _vieweltype(f, datas, views)
+            b = _stringbuild(T, datas, views.budget, rows)
+            if lazy
+                cols[p] = _PendingStrings{T}(b, ntasks)
+                continue
+            end
+            builds[p] = _allocate!(b)
+            append!(jobs, (p, k) for k in eachindex(b.chunks))
+        else
+            push!(jobs, (p, 0))
+        end
     end
-    pos += 4
-    if pos + msglen - 1 > length(x.bytes)
-        @debug "not enough bytes left to read Meta.Message"
+    _foreach(length(jobs), ntasks) do q, _
+        p, k = jobs[q]
+        if k == 0
+            cols[p] = _viewcolumn(fields[idxs[p]], _columndatas(batches, idxs[p]), views)
+        else
+            _buildchunk!(builds[p], k)
+        end
         return nothing
     end
-    msg = FlatBuffers.getrootas(Meta.Message, x.bytes, pos - 1)
-    pos += msglen
-    # pos now points to message body
-    @debug "parsing message: pos = $pos, msglen = $msglen, bodyLength = $(msg.bodyLength)"
-    if pos + msg.bodyLength - 1 > length(x.bytes)
-        @debug "not enough bytes left to read message body"
-        return nothing
+    for (p, i) in enumerate(idxs)
+        b = builds[p]
+        if b !== nothing
+            cols[p] = _finishbuild(b)
+        elseif !isassigned(cols, p)
+            cols[p] = _facadebatchcolumn(fields[i], batches, i, arrowtypes)
+        end
     end
-    return Batch(msg, x.bytes, pos, id), (pos + msg.bodyLength, id + 1)
+    return cols
 end
 
-struct VectorIterator
-    schema::Meta.Schema
-    batch::Batch # batch.msg.header MUST BE RecordBatch
-    dictencodings::Lockable{Dict{Int64,DictEncoding}}
-    convert::Bool
+function _facadebatchcolumn(f::AC.Field, batches, i::Int, arrowtypes::_ArrowTypesContext)
+    _chargevector!(arrowtypes.budget, AbstractVector, length(batches), "batch column parts")
+    parts =
+        AbstractVector[_batchcolumn(f, batch.columns[i], arrowtypes) for batch in batches]
+    return _facadecolumn(f, parts, arrowtypes)
 end
 
-buildmetadata(f::Union{Meta.Field,Meta.Schema}) = buildmetadata(f.custom_metadata)
-buildmetadata(meta) = toidict(String(kv.key) => String(kv.value) for kv in meta)
-buildmetadata(::Nothing) = nothing
-buildmetadata(x::AbstractDict) = x
+_facadefromraw(
+    f::AC.Field,
+    col::AbstractVector,
+    arrowtypes::_ArrowTypesContext=_ArrowTypesContext();
+    owned::Bool=false,
+) =
+    _hasarrowtypesextension(f, arrowtypes) ? _arrowtypescolumn(f, col, arrowtypes) :
+    _publiccolumn(
+        f,
+        _postconvertfield(f, col, arrowtypes.budget),
+        arrowtypes.budget;
+        owned=owned,
+    )
 
-function Base.iterate(
-    x::VectorIterator,
-    (columnidx, nodeidx, bufferidx, varbufferidx)=(Int64(1), Int64(1), Int64(1), Int64(1)),
-)
-    columnidx > length(x.schema.fields) && return nothing
-    field = x.schema.fields[columnidx]
-    @debug "building top-level column: field = $(field), columnidx = $columnidx, nodeidx = $nodeidx, bufferidx = $bufferidx, varbufferidx = $varbufferidx"
-    A, nodeidx, bufferidx, varbufferidx = build(
-        field,
-        x.batch,
-        x.batch.msg.header,
-        x.dictencodings,
-        nodeidx,
-        bufferidx,
-        varbufferidx,
-        x.convert,
+# The private scan-plan module is included at the facade conversion seam.
+# It owns planning, execution, projection, and output schema.
+include("scan.jl")
+
+# --- source opening ---------------------------------------------------------
+
+const _OpenedReader = Union{SourceFile,ArrowFile,IPCStream}
+
+_configuredlimits(source::SourceFile) = source.limits
+_configuredlimits(source::Union{ArrowFile,_RangedFile}) = source.limits
+_configuredlimits(source::IPCStream) = source.limits
+_configuredlimits(source::_StreamReader) = source.limits
+_defaultreaderlimits(source) =
+    source isa _OpenedReader ? _configuredlimits(source) : Limits()
+
+"Resolve one facade read policy without weakening an already-opened handle."
+function _readerlimits(source, requested::Limits)
+    limits = if source isa _OpenedReader
+        configured = _configuredlimits(source)
+        requested == configured || throw(
+            ArgumentError(
+                "cannot change limits for an already-opened $(nameof(typeof(source))) " *
+                "handle; omit `limits` or pass the handle's configured value",
+            ),
+        )
+        configured
+    else
+        requested
+    end
+    _validatelimits(limits)
+    return limits
+end
+
+# The rest of `io`. A generic IO has no reliable remaining-length query: read
+# bounded chunks whose allocation is reserved first, then reserve the one final
+# assembly while all chunks are still live.
+function _readio(io::IO, budget)
+    _chargevector!(budget, Vector{UInt8}, 0, "source IO chunk references")
+    chunks = Vector{UInt8}[]
+    total = Int64(0)
+    chunksize = Int64(64 * 1024)
+    while !eof(io)
+        _chargevector!(budget, UInt8, chunksize, "source IO chunk")
+        chunk = Base.read(io, Int(chunksize))
+        # Julia grows a pushed Vector geometrically, and recent runtimes add
+        # another backing-store size-class round. Eight pointer slots per
+        # logical chunk conservatively cover both layers; this is negligible
+        # beside each 64 KiB chunk but keeps the accounting self-contained.
+        _charge!(
+            budget,
+            Int64(8 * Base.elsize(Vector{Vector{UInt8}})),
+            "source IO chunk reference",
+        )
+        push!(chunks, chunk)
+        total = AC.checked_add(total, Int64(length(chunk)))
+    end
+    _chargevector!(budget, UInt8, total, "source IO assembly")
+    return isempty(chunks) ? UInt8[] : reduce(vcat, chunks)
+end
+# Whether `open(x, mode)` opens `x`, as it does a FilePathsBase path or AWSS3's
+# `S3Path`. Base's `open(f::Function, args...)` would call a function instead,
+# and `open(Arrow.Writer, x)` would make a writer.
+_openable(x, mode) = !(x isa Union{Function,Type}) && applicable(open, x, mode)
+
+# A source that is none of those kinds: name the kinds there are. (Arrow 2.x
+# also accepted a vector of sources and positional byte windows.)
+# An `IO` with nothing left to read: say so, and how to read it from its start.
+function _atend(io::IO)
+    pos = try
+        position(io)
+    catch
+        0
+    end
+    pos > 0 && throw(
+        ArgumentError(
+            "the IO is at its end (position $pos): call seekstart(io) first, " *
+            "or pass take!(io)",
+        ),
     )
-    @debug "built top-level column: A = $(typeof(A)), columnidx = $columnidx, nodeidx = $nodeidx, bufferidx = $bufferidx, varbufferidx = $varbufferidx"
-    @debug A
-    return A, (columnidx + 1, nodeidx, bufferidx, varbufferidx)
-end
-
-Base.length(x::VectorIterator) = length(x.schema.fields)
-
-const ListTypes =
-    Union{Meta.Utf8,Meta.LargeUtf8,Meta.Binary,Meta.LargeBinary,Meta.List,Meta.LargeList}
-const LargeLists = Union{Meta.LargeUtf8,Meta.LargeBinary,Meta.LargeList,Meta.LargeListView}
-const ViewTypes = Union{Meta.Utf8View,Meta.BinaryView,Meta.ListView,Meta.LargeListView}
-
-function build(field::Meta.Field, batch, rb, de, nodeidx, bufferidx, varbufferidx, convert)
-    d = field.dictionary
-    if d !== nothing
-        validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-        bufferidx += 1
-        buffer = rb.buffers[bufferidx]
-        S = d.indexType === nothing ? Int32 : juliaeltype(field, d.indexType, false)
-        bytes, indices = reinterp(S, batch, buffer, rb.compression)
-        @lock de begin
-            encoding = de[][d.id]
-            A = DictEncoded(
-                bytes,
-                validity,
-                indices,
-                encoding,
-                buildmetadata(field.custom_metadata),
+    return nothing
+end
+
+function _unreadable(source)
+    hint =
+        Tables.istable(source) ?
+        "; to read a table in memory as an Arrow.Table, write it first, as " *
+        "Arrow.Table(Arrow.tobuffer(table))" :
+        "; read several sources separately and combine their tables"
+    throw(
+        ArgumentError(
+            "Arrow reads one IPC source: a file path, an IO, a Vector{UInt8}, an " *
+            "Arrow.AbstractArrowSource, or an object that open(x, \"r\") accepts, " *
+            "not $(typeof(source))$hint",
+        ),
+    )
+end
+
+# --- Table construction ------------------------------------------------------
+
+# A fresh read budget. An opened file handle's input is its region; a source
+# whose size is not known yet starts at the cap, and opening it bounds the
+# budget to the input's allowance (`_boundbudget!`).
+_sourcebudget(source, limits::Limits) =
+    source isa ArrowFile ? _readbudget(limits, source.region.len) :
+    AllocationBudget(
+        limits.max_total_allocated_bytes;
+        ratio=limits.max_allocation_ratio,
+        cap=limits.max_total_allocated_bytes,
+        maxnewsymbols=limits.max_new_symbols,
+    )
+
+# The select/drop/filter/limit/offset keywords: a `Tables.Scan` once the
+# column names are known (`_requestedscan`).
+struct _ScanRequest
+    select::Any
+    drop::Any
+    filter::Any
+    limit::Any
+    offset::Int
+end
+
+# The scan the read keywords ask for: `nothing` for a whole read, the `scan`,
+# or a `_ScanRequest`.
+function _scanrequest(select, drop, filter, limit, offset, scan)
+    sugar =
+        select !== nothing ||
+        drop !== nothing ||
+        filter !== nothing ||
+        limit !== nothing ||
+        offset !== nothing
+    if scan !== nothing
+        sugar && throw(
+            ArgumentError(
+                "pass `scan` or the select/drop/filter/limit/offset keywords, not both; " *
+                "a Tables.Scan can express all of them",
+            ),
+        )
+        return scan
+    end
+    sugar || return nothing
+    (select === nothing || drop === nothing) ||
+        throw(ArgumentError("pass `select` or `drop`, not both"))
+    _checkfilterform(filter)
+    # The filter, limit, and offset are checked now, before the source is read.
+    scan = Tables.Scan(; filter=filter, limit=limit, offset=something(offset, 0))
+    return _ScanRequest(select, drop, filter, limit, scan.offset)
+end
+
+# The filters people write first, with the forms Tables.jl 1.14 takes. (Tables
+# 1.15 takes `==`, `in`, and `:x => ==(v)` pairs itself.)
+function _checkfilterform(filter)
+    filter isa Bool && throw(
+        ArgumentError(
+            "filter is a Bool: `Arrow.col(:x) == v` compares the column reference itself. " *
+            "Write equality as Arrow.colcmp(==, Arrow.col(:x), v) and membership as " *
+            "Arrow.colin(Arrow.col(:x), values)",
+        ),
+    )
+    filter isa Pair && throw(
+        ArgumentError(
+            "filter pairs such as `:x => ==(v)` need Tables.jl 1.15; write " *
+            "Arrow.colcmp(==, Arrow.col(:x), v)",
+        ),
+    )
+    filter isa Function && throw(
+        ArgumentError(
+            "filter takes a predicate built from Arrow.col, not a function; to filter " *
+            "with a function, read the table and filter its rows, as with DataFrames",
+        ),
+    )
+    return nothing
+end
+
+_requestedscan(scan::Tables.Scan, names) = scan
+function _requestedscan(r::_ScanRequest, names)
+    columns =
+        r.drop === nothing ? _selection(:select, something(r.select, Tables.All()), names) :
+        Tables.Not(_selection(:drop, r.drop, names))
+    return Tables.Scan(; select=columns, filter=r.filter, limit=r.limit, offset=r.offset)
+end
+_ScanPlan(r::_ScanRequest, fields, budget=nothing) =
+    _ScanPlan(_requestedscan(r, _fieldnamesymbols(fields, budget)), fields, budget)
+
+# The columns `select` or `drop` (`keyword`) names among `names`: a function
+# `(i, name) -> Bool` picks them by index and name, as in CSV.jl; names,
+# indices, and patterns must each match a column.
+function _selection(keyword::Symbol, selection, names)
+    selection isa Function &&
+        return Int[i for (i, name) in enumerate(names) if selection(i, name)]
+    keyword === :select &&
+        selection isa Union{AbstractVector,Tuple} &&
+        isempty(selection) &&
+        throw(
+            ArgumentError(
+                "select=$(repr(selection)) names no column; pass the columns to read",
+            ),
+        )
+    items =
+        selection isa Union{AbstractVector,Tuple} ? selection :
+        selection isa Union{Tables.All,Tables.Not} ? () : (selection,)
+    for item in items
+        ref = item isa Pair ? first(item) : item
+        found =
+            ref isa Union{Symbol,AbstractString} ? Symbol(ref) in names :
+            ref isa Integer ? 1 <= ref <= length(names) :
+            ref isa Regex ? any(name -> occursin(ref, String(name)), names) :
+            ref isa Union{Tables.All,Tables.Not} ? true :
+            throw(
+                ArgumentError(
+                    "$keyword takes column names, indices, a Regex, a function " *
+                    "(i, name) -> Bool, or a vector of them, not $(repr(ref))" *
+                    (keyword === :select ? "; drop gives the columns to leave out" : ""),
+                ),
             )
-        end
-        nodeidx += 1
-        bufferidx += 1
-    else
-        A, nodeidx, bufferidx, varbufferidx = build(
-            field,
-            field.type,
-            batch,
-            rb,
-            de,
-            nodeidx,
-            bufferidx,
-            varbufferidx,
-            convert,
+        found || throw(
+            ArgumentError(
+                "$keyword names no column $(repr(ref)); the columns are " *
+                join(first(names, 20), ", ") *
+                (length(names) > 20 ? ", … ($(length(names)) in all)" : ""),
+            ),
         )
     end
-    return A, nodeidx, bufferidx, varbufferidx
+    return selection
 end
 
-function buildbitmap(batch, rb, nodeidx, bufferidx)
-    buffer = rb.buffers[bufferidx]
-    voff = batch.pos + buffer.offset
-    node = rb.nodes[nodeidx]
-    if rb.compression === nothing
-        return ValidityBitmap(batch.bytes, voff, node.length, node.null_count)
-    else
-        # compressed
-        ptr = pointer(batch.bytes, voff)
-        _, decodedbytes = uncompress(ptr, buffer, rb.compression)
-        return ValidityBitmap(decodedbytes, 1, node.length, node.null_count)
+function Table(
+    source;
+    select=nothing,
+    drop=nothing,
+    filter=nothing,
+    limit=nothing,
+    offset=nothing,
+    scan::Union{Nothing,Tables.Scan}=nothing,
+    mmap::Bool=_MMAP_DEFAULT,
+    stringtype::Type=DataStrings.DataString,
+    limits::Limits=_defaultreaderlimits(source),
+    ntasks::Integer=Threads.nthreads(),
+    unknown...,
+)
+    isempty(unknown) || _unknownkeywords("read", keys(unknown))
+    scan = _scanrequest(select, drop, filter, limit, offset, scan)
+    readlimits = _readerlimits(source, limits)
+    _checkstringtype(stringtype)
+    ntasks = _checkntasks(ntasks)
+    if source isa Union{AbstractArrowSource,SourceFile}
+        sf = source isa SourceFile ? source : SourceFile(source; limits=readlimits)
+        _requirelittleendian()
+        budget = _readbudget(readlimits, sf.len)
+        # A scan of a file-format object plans its byte ranges from the Footer;
+        # a whole read, or a stream-format object, fetches the object.
+        scan === nothing ||
+            !_isfilesource(sf, budget) ||
+            return _readtable(sf, scan, readlimits, budget, stringtype, ntasks)
+        region = heapregion(_wholeobject(sf, budget))
+        return _readtable(region, scan, readlimits, budget, stringtype, ntasks)
+    end
+    budget = _sourcebudget(source, readlimits)
+    region, mapped = _openregion(source; mmap=mmap, budget=budget)
+    _boundbudget!(budget, readlimits, region.len)
+    return _unmaponerror(region, mapped) do
+        return _readtable(region, scan, readlimits, budget, stringtype, ntasks)
+    end
+end
+
+# `f()`, unmapping file mapping `region` if it fails: no column of a failed
+# read escapes, and on Windows a mapped file cannot be deleted.
+function _unmaponerror(f, region::OwnerRegion, mapped::Bool)
+    try
+        return f()
+    catch
+        if mapped
+            AC.release!(region)
+            AC._unmap!(region)
+        end
+        rethrow()
+    end
+end
+
+# The Table that `scan` (`nothing` for every column) reads from `src`, a
+# byte-range source of the file format or a region of either format.
+function _readtable(src, scan, limits::Limits, budget, stringtype::Type, ntasks::Int)
+    views = _ViewContext(stringtype, budget)
+    request = something(scan, Tables.Scan())
+    regions = src isa OwnerRegion ? AC.OwnerRegion[src] : AC.OwnerRegion[]
+    if src isa SourceFile || _isfileregion(src)
+        ft = _readfooter(src, limits, budget)
+        plan = _ScanPlan(request, ft.fields, budget)
+        return first(
+            _scanfile(src, ft, plan, limits, budget, views, regions; ntasks, lazy=true),
+        )
     end
+    st, records = _streamrecords(src, limits, budget)
+    plan = _ScanPlan(request, st.fields, budget)
+    return first(_scanstream(st, records, plan, budget, views, regions; ntasks, lazy=true))
 end
 
-function uncompress(ptr::Ptr{UInt8}, buffer, compression)
-    buffer.length == 0 && return 0, UInt8[]
-    len = unsafe_load(convert(Ptr{Int64}, ptr))
-    len == 0 && return 0, UInt8[]
-    ptr += 8 # skip past uncompressed length as Int64
-    encodedbytes = unsafe_wrap(Array, ptr, buffer.length - 8)
-    if len == -1
-        # len = -1 means data is not compressed
-        # it's unclear why other language implementations allow this
-        # but we support to be able to read data produced as such
-        return length(encodedbytes), copy(encodedbytes)
+_isfileregion(r::OwnerRegion) =
+    r.len >= 6 &&
+    AC.slicebytes(AC.subslice(AC.BufferSlice(r, 0, r.len), 0, 6)) == FILE_MAGIC
+
+# The bytes of `source` as one region, and whether it is a file mapping: a
+# path mapped (or read, with `mmap=false`), an `IO` read to its end, a byte
+# vector in place, or an opened reader's bytes.
+_openregion(path::AbstractString; kwargs...) =
+    open(io -> _fileregion(io, path; kwargs...), path, "r")
+function _openregion(io::IO; budget, kwargs...)
+    eof(io) && _atend(io)
+    return heapregion(_readio(io, budget)), false
+end
+_openregion(bytes::Vector{UInt8}; kwargs...) = heapregion(bytes), false
+function _openregion(src::Union{IPCStream,ArrowFile}; budget, kwargs...)
+    src.region.cell.action == C_NULL && return src.region, false
+    # Facade columns outlive release!(table). A caller-owned region may free
+    # its memory explicitly, so it cannot back those unguarded views.
+    _chargevector!(budget, UInt8, src.region.len, "detached reader source")
+    bytes = AC.slicebytes(AC.BufferSlice(src.region, 0, src.region.len))
+    return heapregion(bytes), false
+end
+function _openregion(source; kwargs...)
+    _openable(source, "r") || _unreadable(source)
+    return open(source, "r") do io
+        io isa IOStream ? _fileregion(io, source; kwargs...) : _openregion(io; kwargs...)
     end
-    decodedbytes = Vector{UInt8}(undef, len)
-    if compression.codec === Meta.CompressionType.LZ4_FRAME
-        comp = lz4_frame_decompressor()
-        Base.@lock comp begin
-            transcode(comp[], encodedbytes, decodedbytes)
+end
+
+# An open file, from its start (`label` names it in errors). Columns read a
+# mapping in place, so `release!` does not unmap it: the mapping lives until
+# nothing reaches it.
+function _fileregion(io::IOStream, label; mmap::Bool, budget)
+    reported = stat(io).size
+    (reported isa Integer && 0 <= reported <= typemax(Int)) ||
+        throw(AC.ValidationError("source file length is not addressable"))
+    size = Int(reported)
+    mmap && size > 0 && return AC._mmapregion(io, label; eager=false), true
+    _chargevector!(budget, UInt8, size, "source file read")
+    bytes = Base.read(io, size)
+    length(bytes) == size || throw(
+        AC.ValidationError(
+            "source file changed while reading: got $(length(bytes)) of $size bytes",
+        ),
+    )
+    return heapregion(bytes), false
+end
+
+# Arrow 2.x read a window of a byte vector as `Arrow.Table(bytes, pos, len)`.
+function _bytewindowerror(name)
+    throw(
+        ArgumentError(
+            "Arrow.$name(bytes, pos, len) was removed in Arrow 3.0; pass the bytes " *
+            "themselves, as Arrow.$name(bytes[pos:pos+len-1])",
+        ),
+    )
+end
+Table(::AbstractVector{UInt8}, ::Integer, ::Any=nothing; kwargs...) =
+    _bytewindowerror(:Table)
+
+# Windows cannot delete a file while it is mapped, and the facade unmaps
+# only when the table and its columns are garbage collected, so paths there
+# read into memory unless `mmap=true` is requested.
+const _MMAP_DEFAULT = !Sys.iswindows()
+
+"""
+    Arrow.read(source, sink; kwargs...)
+
+Read `source` as [`Arrow.Table`](@ref) does, with the same keywords, and pass the
+result to `sink` with owned, mutable columns, copied once: `Arrow.read(path, DataFrame)`
+returns a `DataFrame` whose columns are `Vector`s (`PooledArray`s for dictionary columns,
+`StringVector`s for strings). A sink that takes DataAPI metadata, such as a `DataFrame`,
+gets the file and column metadata, as `DataFrame(Arrow.Table(path))` does.
+"""
+function read(source, sink; kwargs...)
+    t = Table(source; kwargs...)
+    cols = AbstractVector[_ownedcolumn(_force(c)) for c in getfield(t, :columns)]
+    owned = Table(
+        getfield(t, :names),
+        cols,
+        getfield(t, :lookup),
+        getfield(t, :schema),
+        getfield(t, :regions),
+        getfield(t, :nrows),
+        getfield(t, :retainedpools),
+    )
+    result = sink(Tables.CopiedColumns(owned))
+    # The CopiedColumns wrapper, which lets the sink keep the columns, hides
+    # the table's metadata from it.
+    if DataAPI.metadatasupport(typeof(result)).write
+        for key in DataAPI.metadatakeys(owned)
+            DataAPI.metadata!(result, key, DataAPI.metadata(owned, key); style=:default)
         end
-    elseif compression.codec === Meta.CompressionType.ZSTD
-        comp = zstd_decompressor()
-        Base.@lock comp begin
-            transcode(comp[], encodedbytes, decodedbytes)
+    end
+    if DataAPI.colmetadatasupport(typeof(result)).write
+        for (col, keys) in DataAPI.colmetadatakeys(owned), key in keys
+            DataAPI.colmetadata!(
+                result,
+                col,
+                key,
+                DataAPI.colmetadata(owned, col, key);
+                style=:default,
+            )
         end
-    else
-        error(
-            "unsupported compression type when reading arrow buffers: $(typeof(compression.codec))",
-        )
     end
-    return len, decodedbytes
+    return result
+end
+
+function read(source; kwargs...)
+    throw(
+        ArgumentError(
+            "Arrow.read needs a sink, as in Arrow.read(source, DataFrame); " *
+            "Arrow.Table(source) reads without copying",
+        ),
+    )
 end
 
-function reinterp(::Type{T}, batch, buf, compression) where {T}
-    ptr = pointer(batch.bytes, batch.pos + buf.offset)
-    bytes = batch.bytes
-    len = buf.length
-    if compression !== nothing
-        len, bytes = uncompress(ptr, buf, compression)
-        ptr = pointer(bytes)
+"""
+    Arrow.col(name)
+
+A column reference for a read `filter`, the same as `Tables.col`:
+`Arrow.Table(path; filter=Arrow.col(:x) > 3)`. Combine comparisons with `&`,
+`|`, and `!`; see also [`Arrow.colcmp`](@ref), [`Arrow.colin`](@ref), and
+[`Arrow.isnull`](@ref).
+"""
+const col = Tables.col
+
+"""
+    Arrow.colcmp(op, column, value)
+
+A filter comparison, the same as `Tables.colcmp`: `Arrow.colcmp(==, Arrow.col(:zone),
+"A")` for equality, and comparisons with values the operator forms of
+[`Arrow.col`](@ref) do not take, such as dates and timestamps:
+`Arrow.colcmp(>=, Arrow.col(:day), Date(2025, 1, 1))`.
+"""
+const colcmp = Tables.colcmp
+
+"""
+    Arrow.colin(column, values)
+
+A filter that keeps rows whose value is in `values`, the same as `Tables.colin`.
+"""
+const colin = Tables.colin
+
+"""
+    Arrow.isnull(column)
+
+A filter that keeps rows whose value is missing, the same as `Tables.isnull`.
+"""
+const isnull = Tables.isnull
+
+# Views copy into owned memory, a column of several batches into one vector,
+# and a string column into one that owns its bytes; columns this read
+# materialized are already owned by nobody else.
+_ownedcolumn(c::Union{ArrowVector,ChainedVector}) = _copycolumn(c)
+_ownedcolumn(c::_StringColumn) = _compactstrings(c)
+_ownedcolumn(c::AbstractVector{T}) where {T} = _needsowned(c) ? _copyrows(T, c) : c
+
+_copycolumn(c::ArrowVector) = copy(c)
+_copycolumn(c::_StringColumn) = _compactstrings(c)
+_copycolumn(c::AbstractVector{T}) where {T} = _needsowned(c) ? _copyrows(T, c) : copy(c)
+_copycolumn(c::ChainedVector{T,<:ArrowVector}) where {T} = copy(c)
+
+# A source's schema as its tables carry it: repeated column names made unique.
+_tableschema(f::Union{ArrowFile,_RangedFile}) = _uniqueschema(f.schema)
+_tableschema(r::_StreamReader) = _uniqueschema(r.st.schema)
+
+"Merge category snapshots while preserving every entry in the first snapshot."
+function _mergecategorypools(pools; widen::Bool=false, budget=nothing)
+    isempty(pools) && throw(ArgumentError("cannot merge an empty category-pool set"))
+    length(pools) == 1 && return first(pools)
+    # Public `hash`/`isequal` methods are logical API, not Arrow encoding
+    # identity. IdDict uses Julia's non-overridable `===` relation. This may
+    # retain harmless duplicate categories, which Arrow dictionaries permit,
+    # but it can never merge two distinct physical values.
+    capacity = Int64(0)
+    for pool in pools
+        capacity = AC.checked_add(capacity, Int64(length(pool)))
     end
-    # it would be technically more correct to check that T.layout->alignment > 8
-    # but the datatype alignment isn't officially exported, so we're using
-    # primitive types w/ sizeof(T) >= 16 as a proxy for types that need 16-byte alignment
-    if sizeof(T) >= 16 && (UInt(ptr) & 15) != 0
-        # https://github.com/apache/arrow-julia/issues/345
-        # https://github.com/JuliaLang/julia/issues/42326
-        # need to ensure that the data/pointers are aligned to 16 bytes
-        # so we can't use unsafe_wrap here, but do an extra allocation
-        # to avoid the allocation, user needs to ensure input buffer is
-        # 16-byte aligned (somehow, it's not super straightforward how to ensure that)
-        A = Vector{T}(undef, div(len, sizeof(T)))
-        unsafe_copyto!(Ptr{UInt8}(pointer(A)), ptr, len)
-        return bytes, A
-    else
-        return bytes, unsafe_wrap(Array, convert(Ptr{T}, ptr), div(len, sizeof(T)))
+    capacity <= typemax(Int) ||
+        throw(AC.ValidationError("merged category pool is not addressable"))
+    T = widen ? Any : _eltypeof(first(pools))
+    _chargevector!(budget, T, capacity, "merged category pool")
+    _chargedict!(budget, Any, Nothing, capacity, "category identity index")
+    out = Vector{T}()
+    sizehint!(out, Int(capacity))
+    append!(out, first(pools))
+    seen = IdDict{Any,Nothing}()
+    sizehint!(seen, Int(capacity))
+    for value in out
+        seen[value] = nothing
+    end
+    for pool in Iterators.drop(pools, 1), value in pool
+        haskey(seen, value) && continue
+        push!(out, value)
+        seen[value] = nothing
     end
+    return out
+end
+
+"""
+The category pool a top-level dictionary column retains from its distinct
+pool snapshots `dictionaries`, in batch order: none gives an empty pool, and
+several merge, the first's order and duplicates authoritative.
+"""
+function _retainedpool(f::AC.Field, dictionaries, arrowtypes::_ArrowTypesContext)
+    # DictionaryType stores the value descriptor on the index Field. Reapply
+    # that Field's extension metadata while materializing pool snapshots so a
+    # registered dictionary value and its nested children lift exactly once.
+    vf = _arrowtypesdictvaluefield(
+        arrowtypes,
+        f,
+        f.type::AC.DictionaryType;
+        retainmetadata=true,
+    )
+    isempty(dictionaries) && return _facadecolumn(vf, Any[], arrowtypes)
+    length(dictionaries) == 1 &&
+        return _facadesinglecolumn(vf, only(dictionaries), arrowtypes)
+    _chargevector!(
+        arrowtypes.budget,
+        AbstractVector,
+        length(dictionaries),
+        "materialized dictionary pools",
+    )
+    pools = AbstractVector[
+        _facadesinglecolumn(vf, dictionary, arrowtypes) for dictionary in dictionaries
+    ]
+    # Encoding identity never calls a public-domain value's equality or
+    # hashing methods.
+    return _mergecategorypools(
+        pools;
+        widen=vf.type isa AC.UnionType,
+        budget=arrowtypes.budget,
+    )
 end
 
-const SubVector{T,P} = SubArray{T,1,P,Tuple{UnitRange{Int64}},true}
+_retainedsnapshotpool(f::AC.Field, dictionary, arrowtypes::_ArrowTypesContext) =
+    _retainedpool(
+        f,
+        dictionary === nothing ? AC.ArrayData[] : AC.ArrayData[dictionary],
+        arrowtypes,
+    )
 
-function build(
-    f::Meta.Field,
-    L::ListTypes,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
-)
-    @debug "building array: L = $L"
-    validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-    bufferidx += 1
-    buffer = rb.buffers[bufferidx]
-    ooff = batch.pos + buffer.offset
-    OT = L isa LargeLists ? Int64 : Int32
-    bytes, offs = reinterp(OT, batch, buffer, rb.compression)
-    offsets = Offsets(bytes, offs)
-    bufferidx += 1
-    len = rb.nodes[nodeidx].length
-    nodeidx += 1
-    meta = buildmetadata(f.custom_metadata)
-    T = juliaeltype(f, meta, convert)
-    if L isa Meta.Utf8 ||
-       L isa Meta.Utf8View ||
-       L isa Meta.LargeUtf8 ||
-       L isa Meta.Binary ||
-       L isa Meta.BinaryView ||
-       L isa Meta.LargeBinary
-        buffer = rb.buffers[bufferidx]
-        bytes, A = reinterp(UInt8, batch, buffer, rb.compression)
-        bufferidx += 1
-    else
-        bytes = UInt8[]
-        A, nodeidx, bufferidx, varbufferidx =
-            build(f.children[1], batch, rb, de, nodeidx, bufferidx, varbufferidx, convert)
-        # juliaeltype returns Vector for List, translate to SubArray
-        S = Base.nonmissingtype(T)
-        if S <: Vector
-            ST = SubVector{eltype(A),typeof(A)}
-            T = S == T ? ST : Union{Missing,ST}
-        end
+# The eltype the keep/drop decision uses for an EMPTY pre-override column:
+# the descriptor's declared facade type. Composites materialize rows as
+# vectors (their eltype accident is `Any[]` when no rows exist), so the
+# declared domain — not the accident — must drive subsumption, keeping the
+# empty decision identical to the nonempty one. Field-aware rules:
+#   * The declared domain must equal the ACTUAL pre-override container type.
+#     With `converted=true` every convertible leaf declares its PUBLIC type
+#     at every depth — wrappers and union children propagate the flag — and
+#     the dynamic row builder (`_publicvalue`) delivers exactly that.
+#     `converted=false` is the STORAGE-claim domain the typed Core path
+#     materializes before the whole-column conversion.
+#   * Run-end encoding is transparent at the value layer: rows ARE the
+#     values child's rows, with no REE-level validity.
+#   * Dictionary rows are pool VALUES, and their composite children live on
+#     the value FIELD (Dictionary<REE<...>>).
+#   * A multi-child union declares what a valid MIXED population
+#     materializes as: Julia's pairwise `promote_typejoin`, exactly the
+#     widening `map(identity)` performs — not the mathematical union of the
+#     child domains.
+# Missing in the declared type never changes keep/drop (the rule tests
+# `D <: Union{T,Missing}`), so nullability wraps are cosmetic.
+function _declaredeltype(f::AC.Field, converted::Bool=true)
+    t = f.type
+    if t isa AC.RunEndEncodedType && length(f.children) == 2
+        return _declaredeltype(f.children[2], converted)
     end
-    return List{T,OT,typeof(A)}(bytes, validity, offsets, A, len, meta),
-    nodeidx,
-    bufferidx,
-    varbufferidx
-end
-
-function build(
-    f::Meta.Field,
-    L::ViewTypes,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
-)
-    @debug "building array: L = $L"
-    validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-    bufferidx += 1
-    buffer = rb.buffers[bufferidx]
-    _, views = reinterp(ViewElement, batch, buffer, rb.compression)
-    inline = reinterpret(UInt8, views)  # reuse the (possibly realigned) memory backing `views`
-    bufferidx += 1
-    buffers = Vector{UInt8}[]
-    for i = 1:rb.variadicBufferCounts[varbufferidx]
-        buffer = rb.buffers[bufferidx]
-        _, A = reinterp(UInt8, batch, buffer, rb.compression)
-        push!(buffers, A)
-        bufferidx += 1
+    if t isa AC.DictionaryType
+        # The schema carries ONE nullability flag for a dictionary column;
+        # `dictvaluefield` marks the pool field nullable because the format
+        # cannot say otherwise. That is not a declaration: strip it here and
+        # let a pool that actually holds nulls widen the public type through
+        # the data check (`_publictype`/`_hasnulls`), like any other null a
+        # non-nullable declaration did not admit.
+        D0 = Base.nonmissingtype(_declaredeltype(AC.dictvaluefield(f, t), converted))
+        return f.nullable ? Union{Missing,D0} : D0
     end
-    varbufferidx += 1
-    len = rb.nodes[nodeidx].length
-    nodeidx += 1
-    meta = buildmetadata(f.custom_metadata)
-    T = juliaeltype(f, meta, convert)
-    return View{T}(batch.bytes, validity, views, inline, buffers, len, meta),
-    nodeidx,
-    bufferidx,
-    varbufferidx
-end
-
-function build(
-    f::Meta.Field,
-    L::Union{Meta.FixedSizeBinary,Meta.FixedSizeList},
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
-)
-    @debug "building array: L = $L"
-    validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-    bufferidx += 1
-    len = rb.nodes[nodeidx].length
-    nodeidx += 1
-    if L isa Meta.FixedSizeBinary
-        buffer = rb.buffers[bufferidx]
-        bytes, A = reinterp(UInt8, batch, buffer, rb.compression)
-        bufferidx += 1
-    else
-        bytes = UInt8[]
-        A, nodeidx, bufferidx, varbufferidx =
-            build(f.children[1], batch, rb, de, nodeidx, bufferidx, varbufferidx, convert)
+    if t isa AC.UnionType && !isempty(f.children)
+        D = _declaredeltype(f.children[1], converted)
+        for k = 2:length(f.children)
+            D = Base.promote_typejoin(D, _declaredeltype(f.children[k], converted))
+        end
+        return D
     end
-    meta = buildmetadata(f.custom_metadata)
-    T = juliaeltype(f, meta, convert)
-    return FixedSizeList{T,typeof(A)}(bytes, validity, A, len, meta),
-    nodeidx,
-    bufferidx,
-    varbufferidx
-end
-
-function build(
-    f::Meta.Field,
-    L::Meta.Map,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
+    D = converted ? _declaredbasetype(t) : _rawdeclaredbasetype(t)
+    return f.nullable ? Union{Missing,D} : D
+end
+
+# The units the facade converts at the TOP level; under a wrapper their
+# columns keep Core storage integers, sized by the descriptor width.
+_istemporalconv(t::AC.ArrowType) =
+    t isa AC.DateType ||
+    t isa AC.TimeType ||
+    t isa AC.DurationType ||
+    t isa AC.TimestampType
+_rawdeclaredbasetype(t::AC.ArrowType) =
+    _istemporalconv(t) ? (AC.primwidth(t) == 4 ? Int32 : Int64) : _declaredbasetype(t)
+# One entry per Core layout whose _value materializes a CLOSED row type
+# (the _value methods are the authority): every one must appear here, or
+# empty and nonempty columns of that layout would decide keep/drop
+# differently.
+_declaredbasetype(t::AC.ArrowType) =
+    t isa AC.ListType ? Vector{Any} :
+    t isa AC.ListViewType ? Vector{Any} :
+    t isa AC.FixedSizeListType ? Vector{Any} :
+    t isa AC.BinaryType ? Vector{UInt8} :
+    t isa AC.FixedSizeBinaryType ? Vector{UInt8} :
+    (t isa AC.ViewType && !t.utf8) ? Vector{UInt8} :
+    t isa AC.StructType ? Vector{Pair{String,Any}} :
+    t isa AC.MapType ? Vector{Pair{Any,Any}} :
+    t isa AC.NullType ? Missing :
+    t isa AC.DecimalType ? (_shareddecimal(t) ? _decimalhost(t) : _rawdeclaredbasetype(t)) :
+    t isa AC.IntervalType ? Durations.Duration :
+    t isa AC.DictionaryType ? _declaredbasetype(t.valuetype) : _facadebasetype(t)
+
+# --- Stream ------------------------------------------------------------------
+
+"""
+    Arrow.Stream(source; select=nothing, drop=nothing, filter=nothing, limit=nothing,
+                 offset=nothing, scan=nothing, mmap, stringtype=DataString,
+                 ntasks=Threads.nthreads(), limits=Arrow.Limits())
+
+Read `source` one record batch at a time: each iteration gives an [`Arrow.Table`](@ref)
+of one batch. The keywords are those of `Arrow.Table`; `select`, `drop`, and `filter`
+apply to each batch, and `limit` and `offset` count rows across batches. A
+stream is its own `Tables.partitions`, so `Arrow.write(sink, stream)` writes a record
+batch for each batch read.
+
+Batches are read as the iteration reaches them: from a stream-format `IO`, such as a
+pipe or a socket, as they arrive; from a mapped path, in place; and from an
+[`Arrow.AbstractArrowSource`](@ref), by range: a batch of at most 1 MiB whole, several to
+a request, and a larger one only its selected and filter columns. A file-format `IO` is
+read to its end first. A loop that drops each batch holds one batch at a time, plus the
+dictionaries, and each batch is read under its own allocation allowance
+([`Arrow.Limits`](@ref)).
+
+`Tables.schema(stream)`, `Tables.columnnames(stream)`, `DataAPI.metadata(stream)`, and
+`DataAPI.colmetadata(stream, col)` read no data. A file-format source also has
+`length(stream)`, `stream[i]`, and `DataAPI.nrow(stream)`, counted from the batches'
+metadata. A stream-format source is read in order, and one over an `IO` can be iterated
+once.
+
+The tables a stream yields share its source: [`Arrow.release!`](@ref) of the stream or
+of any of them releases all of them.
+"""
+struct Stream
+    src::Union{ArrowFile,_RangedFile,_StreamReader,ImportedStream}
+    regions::Vector{AC.OwnerRegion}
+    budget::AllocationBudget
+    closed::AC.ReleaseCell
+    arrowtypes::_ArrowTypesContext
+    arrowtypeslock::ReentrantLock
+    views::_ViewContext
+    ntasks::Int
+    scan::Union{Nothing,Tables.Scan}   # the request; its window spans the batches
+    plan::_ScanPlan                    # every column when there is no request
+    mask::BitVector                    # the fields a batch decodes
+end
+
+function Stream(
+    source;
+    select=nothing,
+    drop=nothing,
+    filter=nothing,
+    limit=nothing,
+    offset=nothing,
+    scan::Union{Nothing,Tables.Scan}=nothing,
+    mmap::Bool=_MMAP_DEFAULT,
+    stringtype::Type=DataStrings.DataString,
+    limits::Limits=_defaultreaderlimits(source),
+    ntasks::Integer=Threads.nthreads(),
+    unknown...,
 )
-    @debug "building array: L = $L"
-    validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-    bufferidx += 1
-    buffer = rb.buffers[bufferidx]
-    ooff = batch.pos + buffer.offset
-    OT = Int32
-    bytes, offs = reinterp(OT, batch, buffer, rb.compression)
-    offsets = Offsets(bytes, offs)
-    bufferidx += 1
-    len = rb.nodes[nodeidx].length
-    nodeidx += 1
-    A, nodeidx, bufferidx, varbufferidx =
-        build(f.children[1], batch, rb, de, nodeidx, bufferidx, varbufferidx, convert)
-    meta = buildmetadata(f.custom_metadata)
-    T = juliaeltype(f, meta, convert)
-    return Map{T,OT,typeof(A)}(validity, offsets, A, len, meta),
-    nodeidx,
-    bufferidx,
-    varbufferidx
-end
-
-function build(
-    f::Meta.Field,
-    L::Meta.Struct,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
+    isempty(unknown) || _unknownkeywords("read", keys(unknown))
+    scan = _scanrequest(select, drop, filter, limit, offset, scan)
+    readlimits = _readerlimits(source, limits)
+    _checkstringtype(stringtype)
+    ntasks = _checkntasks(ntasks)
+    budget = _sourcebudget(source, readlimits)
+    src = _openstream(source; mmap=mmap, limits=readlimits, budget=budget)
+    fields = _batchfields(src)
+    # A scan that does not fit the schema fails here, not at the first batch.
+    scan === nothing || (scan = _requestedscan(scan, _fieldnamesymbols(fields)))
+    plan = _ScanPlan(something(scan, Tables.Scan()), fields, _readbudget(readlimits, 0))
+    b = plan.bound
+    mask = _fieldmask(vcat(Int[c.index for c in b.columns], b.filtercols), length(fields))
+    # The stream and every table it yields share one lifetime authority, the
+    # source's region: releasing any of them releases it.
+    return Stream(
+        src,
+        AC.OwnerRegion[src.region],
+        budget,
+        src.region.cell,
+        _ArrowTypesContext(budget=budget),
+        ReentrantLock(),
+        _ViewContext(stringtype, budget),
+        ntasks,
+        scan,
+        plan,
+        mask,
+    )
+end
+
+Stream(::AbstractVector{UInt8}, ::Integer, ::Any=nothing; kwargs...) =
+    _bytewindowerror(:Stream)
+
+function AC.release!(s::Stream)
+    AC.release!(getfield(s, :closed))
+    foreach(AC.release!, getfield(s, :regions))
+    return nothing
+end
+
+# The reader of a stream's source. A path, a byte vector, or an opened reader
+# reads in place: a stream-format region frames its messages as the iteration
+# reaches them, and a file-format region decodes its record batches on
+# demand. A stream-format `IO` is read one message at a time, and a
+# file-format `IO` to its end. A byte-range source is fetched as it is
+# iterated: a file-format object one record batch at a time (its footer and
+# dictionaries first), a stream-format object one message at a time.
+function _openstream(source; mmap::Bool, limits::Limits, budget)
+    region, mapped = _openregion(source; mmap=mmap, budget=budget)
+    _boundbudget!(budget, limits, region.len)
+    _isfileregion(region) || return _StreamReader(_RegionMessages(region), limits)
+    return _unmaponerror(() -> _readfile(region, limits, budget), region, mapped)
+end
+function _openstream(io::IO; limits::Limits, budget, kwargs...)
+    eof(io) && _atend(io)
+    head = Base.read(io, 8)
+    (length(head) >= 6 && view(head, 1:6) == FILE_MAGIC) ||
+        return _StreamReader(_IOMessages(io, head, Int64(0)), limits)
+    # The file format needs its footer: read the rest.
+    bytes = vcat(head, _readio(io, budget))
+    _boundbudget!(budget, limits, length(bytes))
+    return _readfile(heapregion(bytes), limits, budget)
+end
+function _openstream(
+    src::Union{AbstractArrowSource,SourceFile};
+    limits::Limits,
+    budget,
+    kwargs...,
 )
-    @debug "building array: L = $L"
-    validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-    bufferidx += 1
-    len = rb.nodes[nodeidx].length
-    vecs = []
-    nodeidx += 1
-    for child in f.children
-        A, nodeidx, bufferidx, varbufferidx =
-            build(child, batch, rb, de, nodeidx, bufferidx, varbufferidx, convert)
-        push!(vecs, A)
-    end
-    data = Tuple(vecs)
-    meta = buildmetadata(f.custom_metadata)
-    T = juliaeltype(f, meta, convert)
-    fnames = ntuple(i -> Symbol(f.children[i].name), length(f.children))
-    return Struct{T,typeof(data),fnames}(validity, data, len, meta),
-    nodeidx,
-    bufferidx,
-    varbufferidx
-end
-
-function build(
-    f::Meta.Field,
-    L::Meta.Union,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
+    sf = src isa SourceFile ? src : SourceFile(src; limits=limits)
+    _isfilesource(sf, budget) && return _RangedFile(sf, budget)
+    return _StreamReader(_IOMessages(_SourceIO(sf), UInt8[], Int64(0)), sf.limits)
+end
+
+_nbatches(f::Union{ArrowFile,_RangedFile}) = length(f)
+_nbatches(r::_StreamReader{_RegionMessages}) = _countrecords(r)
+_nbatches(::_StreamReader) = throw(
+    ArgumentError(
+        "the number of batches of a stream read from an IO is unknown until it is " *
+        "read; iterate the Arrow.Stream, or collect it first",
+    ),
 )
-    @debug "building array: L = $L"
-    buffer = rb.buffers[bufferidx]
-    bytes, typeIds = reinterp(UInt8, batch, buffer, rb.compression)
-    bufferidx += 1
-    if L.mode == Meta.UnionMode.Dense
-        buffer = rb.buffers[bufferidx]
-        bytes2, offsets = reinterp(Int32, batch, buffer, rb.compression)
-        bufferidx += 1
+_batchfields(f::Union{ArrowFile,_RangedFile}) = f.fields
+_batchfields(r::_StreamReader) = r.st.fields
+_decoder(f::Union{ArrowFile,_RangedFile}) =
+    _Decoder(f.fields, f.fielddictids, f.validated, f.limits)
+_decoder(r::_StreamReader) =
+    _Decoder(r.st.fields, r.st.fielddictids, r.st.validated, r.limits)
+
+Base.length(s::Stream) = _nbatches(s.src)
+Base.eltype(::Type{Stream}) = Table
+Base.IteratorSize(::Type{Stream}) = Base.SizeUnknown()
+
+# Record batch `i` of the stream, what fetching its bodies needs (`nothing`
+# when they are in memory), and the allowance it decodes under; `nothing` past
+# the end. A stream-format source returns its batches in order (`i == 1`
+# starts over).
+function _streambatch(s::Stream, i::Int)
+    src = s.src
+    if src isa _StreamReader
+        return @lock src.lock begin
+            i == 1 && _restart!(src)
+            got = _nextrecord!(src)
+            got === nothing ? nothing :
+            (_ScanRecord(first(got).plan, first(got).dictionaries), nothing, last(got))
+        end
     end
-    vecs = []
-    nodeidx += 1
-    for child in f.children
-        A, nodeidx, bufferidx, varbufferidx =
-            build(child, batch, rb, de, nodeidx, bufferidx, varbufferidx, convert)
-        push!(vecs, A)
+    if src isa ImportedStream
+        b = AC.nextbatch!(src)
+        b === nothing && return nothing
+        return _DecodedRecord(b), nothing, _readbudget(src.limits, _databytes(b))
     end
-    data = Tuple(vecs)
-    meta = buildmetadata(f.custom_metadata)
-    T = juliaeltype(f, meta, convert)
-    UT = UnionT(f, convert)
-    if L.mode == Meta.UnionMode.Dense
-        B = DenseUnion{T,UT,typeof(data)}(bytes, bytes2, typeIds, offsets, data, meta)
-    else
-        B = SparseUnion{T,UT,typeof(data)}(bytes, typeIds, data, meta)
+    i > _nbatches(src) && return nothing
+    budget = _batchbudget(src, i)
+    record, bodies = _streamrecord(src, i, budget, getfield(s, :mask))
+    return record, bodies, budget
+end
+
+# The state is the next batch and, for a scan's window, the qualifying rows
+# skipped and yielded so far.
+function Base.iterate(s::Stream, state::NTuple{3,Int}=(1, 0, 0))
+    _checkstream(s)
+    i, skipped, yielded = state
+    scan = getfield(s, :scan)
+    scan === nothing || scan.limit === nothing || yielded < scan.limit || return nothing
+    src = s.src
+    # A stream-format source decodes against the stream's current state.
+    src isa _StreamReader && return @lock src.lock _iteratestream(s, i, skipped, yielded)
+    return _iteratestream(s, i, skipped, yielded)
+end
+
+function _iteratestream(s::Stream, i::Int, skipped::Int, yielded::Int)
+    got = _streambatch(s, i)
+    got === nothing && return nothing
+    record, bodies, budget = got
+    t, skipped, yielded = _scannedbatch(s, record, bodies, budget, skipped, yielded)
+    return t, (i + 1, skipped, yielded)
+end
+
+# Record batch `record` under the stream's scan, after `skipped` qualifying
+# rows of its offset and `yielded` rows of its limit: the batch's share of the
+# window.
+function _scannedbatch(s::Stream, record, bodies, budget, skipped::Int, yielded::Int)
+    _prunepools!(getfield(s, :views), _recorddictionaries(record), budget)
+    plan = getfield(s, :plan)
+    b = plan.bound
+    scan = getfield(s, :scan)
+    limit = scan === nothing || scan.limit === nothing ? nothing : scan.limit - yielded
+    offset = scan === nothing ? 0 : scan.offset - skipped
+    window = Tables.BoundScan(b.columns, b.filter, b.filtercols, limit, offset, b.validate)
+    t, skip = _batchscan(s, _ScanPlan(plan.names, window), [record], bodies, budget)
+    return t, skipped + skip, yielded + getfield(t, :nrows)
+end
+
+# Scan `plan` over record batches `records` of stream `s`. The ArrowTypes
+# caches outlive the batch: one batch at a time uses them, charging its own
+# allowance, and its new Symbols count against its own limit.
+function _batchscan(s::Stream, plan::_ScanPlan, records, bodies, budget; regions=s.regions)
+    src = s.src
+    arrowtypes = getfield(s, :arrowtypes)
+    return @lock getfield(s, :arrowtypeslock) begin
+        arrowtypes.budget = budget
+        arrowtypes.newsymbols = 0
+        route = arrowtypes.routeplan
+        route === nothing || (route.budget = budget)
+        views = _ViewContext(getfield(s, :views), budget)
+        ctx = _ScanContext(views, arrowtypes)
+        _scantable(
+            records,
+            _decoder(src),
+            plan,
+            bodies,
+            ctx,
+            _tableschema(src),
+            regions,
+            budget;
+            ntasks=getfield(s, :ntasks),
+            lazy=false,
+        )
     end
-    return B, nodeidx, bufferidx, varbufferidx
-end
-
-function build(
-    f::Meta.Field,
-    L::Meta.Null,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
-)
-    @debug "building array: L = $L"
-    meta = buildmetadata(f.custom_metadata)
-    T = juliaeltype(f, meta, convert)
-    return NullVector{maybemissing(T)}(MissingVector(rb.nodes[nodeidx].length), meta),
-    nodeidx + 1,
-    bufferidx,
-    varbufferidx
-end
-
-# primitives
-function build(
-    f::Meta.Field,
-    ::L,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
-) where {L}
-    @debug "building array: L = $L"
-    validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-    bufferidx += 1
-    buffer = rb.buffers[bufferidx]
-    meta = buildmetadata(f.custom_metadata)
-    # get storage type (non-converted)
-    T = juliaeltype(f, nothing, false)
-    @debug "storage type for primitive: T = $T"
-    bytes, A = reinterp(Base.nonmissingtype(T), batch, buffer, rb.compression)
-    len = rb.nodes[nodeidx].length
-    T = juliaeltype(f, meta, convert)
-    @debug "final julia type for primitive: T = $T"
-    return Primitive(T, bytes, validity, A, len, meta),
-    nodeidx + 1,
-    bufferidx + 1,
-    varbufferidx
-end
-
-function build(
-    f::Meta.Field,
-    L::Meta.Bool,
-    batch,
-    rb,
-    de,
-    nodeidx,
-    bufferidx,
-    varbufferidx,
-    convert,
-)
-    @debug "building array: L = $L"
-    validity = buildbitmap(batch, rb, nodeidx, bufferidx)
-    bufferidx += 1
-    buffer = rb.buffers[bufferidx]
-    meta = buildmetadata(f.custom_metadata)
-    # get storage type (non-converted)
-    T = juliaeltype(f, nothing, false)
-    @debug "storage type for primitive: T = $T"
-    buffer = rb.buffers[bufferidx]
-    voff = batch.pos + buffer.offset
-    node = rb.nodes[nodeidx]
-    if rb.compression === nothing
-        decodedbytes = batch.bytes
-        pos = voff
-        # return ValidityBitmap(batch.bytes, voff, node.length, node.null_count)
+end
+
+"""
+    stream[i] -> Arrow.Table
+
+Record batch `i` of a file-format `Arrow.Stream`, decoded on demand.
+"""
+function Base.getindex(s::Stream, i::Integer)
+    _checkstream(s)
+    src = s.src
+    src isa _StreamReader && throw(
+        ArgumentError(
+            "a stream-format source has no random access to its batches; iterate it",
+        ),
+    )
+    scan = getfield(s, :scan)
+    scan === nothing ||
+        (scan.limit === nothing && scan.offset == 0) ||
+        throw(
+            ArgumentError(
+                "which batches hold a Stream's limited or offset rows is known only " *
+                "while iterating; iterate the Stream",
+            ),
+        )
+    1 <= i <= _nbatches(src) || throw(BoundsError(s, i))
+    budget = _batchbudget(src, Int(i))
+    record, bodies = _streamrecord(src, Int(i), budget, getfield(s, :mask))
+    return first(_scannedbatch(s, record, bodies, budget, 0, 0))
+end
+
+function _checkstream(s::Stream)
+    closed = getfield(s, :closed)
+    (@atomic :acquire closed.closed) &&
+        throw(InvalidStateException("the stream was released", :closed))
+    return nothing
+end
+
+# A batch's allowance comes from its own bytes.
+function _batchbudget(f::Union{ArrowFile,_RangedFile}, i::Int)
+    _, metalen, bodylen = f.recordblocks[i]
+    return _readbudget(_configuredlimits(f), metalen + bodylen)
+end
+
+Tables.partitions(s::Stream) = s
+
+# A Stream is a sequence of record-batch tables, not one table. Without these
+# methods Tables.jl's iterator fallback reads each batch as one row whose
+# values are whole columns (so `DataFrame(stream)` would hold vectors).
+function _streamisnotatable()
+    throw(
+        ArgumentError(
+            "Arrow.Stream iterates record batches; read the whole table with " *
+            "Arrow.Table(source), or iterate the Stream (or Tables.partitions) " *
+            "for one batch at a time",
+        ),
+    )
+end
+Tables.columns(::Stream) = _streamisnotatable()
+Tables.rows(::Stream) = _streamisnotatable()
+
+# A zero-row table of the stream's schema: its column names, element types,
+# and metadata, without reading a batch.
+function _schematable(s::Stream)
+    plan = getfield(s, :plan)
+    b = plan.bound
+    window = Tables.BoundScan(b.columns, b.filter, b.filtercols, nothing, 0, b.validate)
+    budget = _readbudget(_configuredlimits(s.src), 0)
+    return first(
+        _batchscan(
+            s,
+            _ScanPlan(plan.names, window),
+            _ScanRecord{BufferSlice}[],
+            nothing,
+            budget;
+            regions=AC.OwnerRegion[],
+        ),
+    )
+end
+
+Tables.schema(s::Stream) = Tables.schema(_schematable(s))
+Tables.columnnames(s::Stream) = Symbol[c.name for c in getfield(s, :plan).bound.columns]
+
+DataAPI.ncol(s::Stream) = length(Tables.columnnames(s))
+function DataAPI.nrow(s::Stream)
+    src = s.src
+    scan = getfield(s, :scan)
+    scan === nothing ||
+        (scan.filter === nothing && scan.limit === nothing && scan.offset == 0) ||
+        throw(
+            ArgumentError(
+                "the row count of a Stream with a filter, limit, or offset is " *
+                "known once it is read; iterate it and add up its batches' rows",
+            ),
+        )
+    src isa _StreamReader && throw(
+        ArgumentError(
+            "the row count of a stream-format source is known once it is read; " *
+            "iterate the Arrow.Stream and add up its batches' rows",
+        ),
+    )
+    budget = _readbudget(_configuredlimits(src), 0)
+    return sum(i -> Int(_batchrows(src, i, budget)), 1:_nbatches(src); init=0)
+end
+
+DataAPI.metadatasupport(::Type{Stream}) = (read=true, write=false)
+DataAPI.colmetadatasupport(::Type{Stream}) = (read=true, write=false)
+DataAPI.metadatakeys(s::Stream) = DataAPI.metadatakeys(_schematable(s))
+DataAPI.metadata(s::Stream, key::AbstractString, default=_NO_DEFAULT; style::Bool=false) =
+    DataAPI.metadata(_schematable(s), key, default; style=style)
+DataAPI.colmetadatakeys(s::Stream, col::Union{Symbol,Int}) =
+    DataAPI.colmetadatakeys(_schematable(s), col)
+DataAPI.colmetadatakeys(s::Stream) = DataAPI.colmetadatakeys(_schematable(s))
+DataAPI.colmetadata(
+    s::Stream,
+    col::Union{Symbol,Int},
+    key::AbstractString,
+    default=_NO_DEFAULT;
+    style::Bool=false,
+) = DataAPI.colmetadata(_schematable(s), col, key, default; style=style)
+
+function Base.show(io::IO, s::Stream)
+    src = s.src
+    m = DataAPI.ncol(s)
+    cols = m == 1 ? "1 column" : "$m columns"
+    if src isa Union{_StreamReader,ImportedStream}
+        print(io, "Arrow.Stream with ", cols, " and schema:\n")
     else
-        # compressed
-        ptr = pointer(batch.bytes, voff)
-        _, decodedbytes = uncompress(ptr, buffer, rb.compression)
-        pos = 1
-        # return ValidityBitmap(decodedbytes, 1, node.length, node.null_count)
+        n = _nbatches(src)
+        print(io, "Arrow.Stream with ", n, n == 1 ? " record batch, " : " record batches, ")
+        print(io, cols, ", and schema:\n")
     end
-    len = rb.nodes[nodeidx].length
-    T = juliaeltype(f, meta, convert)
-    return BoolVector{T}(decodedbytes, pos, validity, len, meta),
-    nodeidx + 1,
-    bufferidx + 1,
-    varbufferidx
+    show(IOContext(io, :print_schema_header => false), Tables.schema(s))
 end
diff --git a/src/utils.jl b/src/utils.jl
deleted file mode 100644
index 8e2dfeed..00000000
--- a/src/utils.jl
+++ /dev/null
@@ -1,147 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Determines the total number of bytes needed to store `n` bytes with padding.
-# Note that the Arrow standard requires buffers to be aligned to 8-byte boundaries.
-padding(n::Integer, alignment) = ((n + alignment - 1) ÷ alignment) * alignment
-
-paddinglength(n::Integer, alignment) = padding(n, alignment) - n
-
-function writezeros(io::IO, n::Integer)
-    s = 0
-    for i ∈ 1:n
-        s += Base.write(io, 0x00)
-    end
-    s
-end
-
-if isdefined(Base, :waitall)
-    const _waitall = waitall
-else
-    _waitall(tasks) = foreach(wait, tasks)
-end
-
-# efficient writing of arrays
-writearray(io, col) = writearray(io, maybemissing(eltype(col)), col)
-
-function writearray(io::IO, ::Type{T}, col) where {T}
-    if col isa Vector{T}
-        n = Base.write(io, col)
-    elseif isbitstype(T) && (
-        col isa Vector{Union{T,Missing}} || col isa SentinelVector{T,T,Missing,Vector{T}}
-    )
-        # need to write the non-selector bytes of isbits Union Arrays
-        n = Base.unsafe_write(io, pointer(col), sizeof(T) * length(col))
-    elseif col isa ChainedVector
-        n = 0
-        for A in col.arrays
-            n += writearray(io, T, A)
-        end
-    else
-        n = 0
-        data = Vector{UInt8}(undef, sizeof(col))
-        buf = IOBuffer(data; write=true)
-        for x in col
-            n += Base.write(buf, coalesce(x, ArrowTypes.default(T)))
-        end
-        n = Base.write(io, take!(buf))
-    end
-    return n
-end
-
-getbit(v::UInt8, n::Integer) = (v & (1 << (n - 1))) > 0x00
-
-function setbit(v::UInt8, b::Bool, n::Integer)
-    if b
-        v | 0x02^(n - 1)
-    else
-        v & (0xff ⊻ 0x02^(n - 1))
-    end
-end
-
-# Determines the number of bytes used by `n` bits, optionally with padding.
-function bitpackedbytes(n::Integer, alignment)
-    ℓ = cld(n, 8)
-    return ℓ + paddinglength(ℓ, alignment)
-end
-
-# count # of missing elements in an iterable
-nullcount(col) = count(ismissing, col)
-
-# like startswith for strings, but on byte buffers
-function _startswith(a::AbstractVector{UInt8}, pos::Integer, b::AbstractVector{UInt8})
-    for i = 1:length(b)
-        @inbounds check = a[pos + i - 1] == b[i]
-        check || return false
-    end
-    return true
-end
-
-# read a single element from a byte vector
-# copied from read(::IOBuffer, T) in Base
-function readbuffer(t::AbstractVector{UInt8}, pos::Integer, ::Type{T}) where {T}
-    GC.@preserve t begin
-        ptr::Ptr{T} = pointer(t, pos)
-        x = unsafe_load(ptr)
-    end
-end
-
-# given a number of unique values; what dict encoding _index_ type is most appropriate
-encodingtype(n) =
-    n < div(typemax(Int8), 2) ? Int8 :
-    n < div(typemax(Int16), 2) ? Int16 : n < div(typemax(Int32), 2) ? Int32 : Int64
-
-maybemissing(::Type{T}) where {T} = T === Missing ? Missing : Base.nonmissingtype(T)
-withmissing(U::Union, S) = U >: Missing ? Union{Missing,S} : S
-withmissing(T, S) = T === Missing ? Union{Missing,S} : S
-
-function getfooter(filebytes)
-    len = readbuffer(filebytes, length(filebytes) - 9, Int32)
-    FlatBuffers.getrootas(Meta.Footer, filebytes[(end - (9 + len)):(end - 10)], 0)
-end
-
-function getrb(filebytes)
-    f = getfooter(filebytes)
-    rb = f.recordBatches[1]
-    return filebytes[(rb.offset + 1):(rb.offset + 1 + rb.metaDataLength)]
-    # FlatBuffers.getrootas(Meta.Message, filebytes, rb.offset)
-end
-
-function readmessage(filebytes, off=9)
-    @assert readbuffer(filebytes, off, UInt32) === 0xFFFFFFFF
-    len = readbuffer(filebytes, off + 4, Int32)
-
-    FlatBuffers.getrootas(Meta.Message, filebytes, off + 8)
-end
-
-function tobuffer(data; kwargs...)
-    io = IOBuffer()
-    write(io, data; kwargs...)
-    seekstart(io)
-    return io
-end
-
-toidict(x::Base.ImmutableDict) = x
-
-# ref https://github.com/apache/arrow-julia/pull/238#issuecomment-919415809
-function toidict(pairs)
-    isempty(pairs) && return Base.ImmutableDict{String,String}()
-    dict = Base.ImmutableDict(first(pairs))
-    for pair in Iterators.drop(pairs, 1)
-        dict = Base.ImmutableDict(dict, pair)
-    end
-    return dict
-end
diff --git a/src/write.jl b/src/write.jl
index 4c3800f2..218f7d40 100644
--- a/src/write.jl
+++ b/src/write.jl
@@ -14,799 +14,1962 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-const DEFAULT_MAX_DEPTH = 6
+# =============================================================================
+# The write facade: Tables.jl source -> Arrow IPC bytes.
+#
+# This file owns partition binding, retained-field alignment, schema and batch
+# assembly, compression selection, and IPC emission. Column construction is a
+# deep module behind `_constructcolumn`.
+# =============================================================================
 
 """
-    Arrow.write(io::IO, tbl)
-    Arrow.write(file::String, tbl)
-    tbl |> Arrow.write(io_or_file)
+    Arrow.DictEncode(v)
 
-Write any [Tables.jl](https://github.com/JuliaData/Tables.jl)-compatible `tbl` out as arrow formatted data.
-Providing an `io::IO` argument will cause the data to be written to it
-in the ["streaming" format](https://arrow.apache.org/docs/format/Columnar.html#ipc-streaming-format), unless `file=true` keyword argument is passed.
-Providing a `file::String` argument will result in the ["file" format](https://arrow.apache.org/docs/format/Columnar.html#ipc-file-format) being written.
-
-Multiple record batches will be written based on the number of
-`Tables.partitions(tbl)` that are provided; by default, this is just
-one for a given table, but some table sources support automatic
-partitioning. Note you can turn multiple table objects into partitions
-by doing `Tables.partitioner([tbl1, tbl2, ...])`, but note that
-each table must have the exact same `Tables.Schema`.
-
-By default, `Arrow.write` will use multiple threads to write multiple
-record batches simultaneously (e.g. if julia is started with `julia -t 8` or the `JULIA_NUM_THREADS` environment variable is set).
-
-Supported keyword arguments to `Arrow.write` include:
-  * `colmetadata=nothing`: the metadata that should be written as the table's columns' `custom_metadata` fields; must either be `nothing` or an `AbstractDict` of `column_name::Symbol => column_metadata` where `column_metadata` is an iterable of `<:AbstractString` pairs.
-  * `compress`: possible values include `:lz4`, `:zstd`, or your own initialized `LZ4FrameCompressor` or `ZstdCompressor` objects; will cause all buffers in each record batch to use the respective compression encoding
-  * `alignment::Int=8`: specify the number of bytes to align buffers to when written in messages; strongly recommended to only use alignment values of 8 or 64 for modern memory cache line optimization
-  * `dictencode::Bool=false`: whether all columns should use dictionary encoding when being written; to dict encode specific columns, wrap the column/array in `Arrow.DictEncode(col)`
-  * `dictencodenested::Bool=false`: whether nested data type columns should also dict encode nested arrays/buffers; other language implementations [may not support this](https://arrow.apache.org/docs/status.html)
-  * `denseunions::Bool=true`: whether Julia `Vector{<:Union}` arrays should be written using the dense union layout; passing `false` will result in the sparse union layout
-  * `largelists::Bool=false`: causes list column types to be written with Int64 offset arrays; mainly for testing purposes; by default, Int64 offsets will be used only if needed
-  * `maxdepth::Int=$DEFAULT_MAX_DEPTH`: deepest allowed nested serialization level; this is provided by default to prevent accidental infinite recursion with mutually recursive data structures
-  * `metadata=Arrow.getmetadata(tbl)`: the metadata that should be written as the table's schema's `custom_metadata` field; must either be `nothing` or an iterable of `<:AbstractString` pairs.
-  * `ntasks::Int`: number of buffered threaded tasks to allow while writing input partitions out as arrow record batches; default is no limit; for unbuffered writing, pass `ntasks=0`
-  * `file::Bool=false`: if a an `io` argument is being written to, passing `file=true` will cause the arrow file format to be written instead of just IPC streaming
-"""
-function write end
-
-write(io_or_file; kw...) = x -> write(io_or_file, x; kw...)
-
-function write(file_path, tbl; kwargs...)
-    open(Writer, file_path; file=true, kwargs...) do writer
-        write(writer, tbl)
-    end
-    file_path
-end
-
-struct Message
-    msgflatbuf::Any
-    columns::Any
-    bodylen::Any
-    isrecordbatch::Bool
-    blockmsg::Bool
-    headerType::Any
-end
-
-struct Block
-    offset::Int64
-    metaDataLength::Int32
-    bodyLength::Int64
-end
-
-"""
-    Arrow.Writer{T<:IO}
-
-An object that can be used to incrementally write Arrow partitions
-
-# Examples
-```julia
-julia> writer = open(Arrow.Writer, tempname())
-
-julia> partition1 = (col1 = [1, 2], col2 = ["A", "B"])
-(col1 = [1, 2], col2 = ["A", "B"])
-
-julia> Arrow.write(writer, partition1)
-
-julia> partition2 = (col1 = [3, 4], col2 = ["C", "D"])
-(col1 = [3, 4], col2 = ["C", "D"])
-
-julia> Arrow.write(writer, partition2)
-
-julia> close(writer)
-```
-
-It's also possible to automatically close the Writer using a do-block:
-
-```julia
-julia> open(Arrow.Writer, tempname()) do writer
-           partition1 = (col1 = [1, 2], col2 = ["A", "B"])
-           Arrow.write(writer, partition1)
-           partition2 = (col1 = [3, 4], col2 = ["C", "D"])
-           Arrow.write(writer, partition2)
-       end
-```
-"""
-mutable struct Writer{T<:IO}
-    io::T
-    closeio::Bool
-    compress::Union{Nothing,Symbol,LZ4FrameCompressor,ZstdCompressor}
-    writetofile::Bool
-    largelists::Bool
-    denseunions::Bool
-    dictencode::Bool
-    dictencodenested::Bool
-    threaded::Bool
-    alignment::Int32
-    maxdepth::Int64
-    meta::Union{Nothing,Base.ImmutableDict{String,String}}
-    colmeta::Union{Nothing,Base.ImmutableDict{Symbol,Base.ImmutableDict{String,String}}}
-    sync::OrderedSynchronizer
-    msgs::Channel{Message}
-    schema::Ref{Tables.Schema}
-    firstcols::Ref{Any}
-    dictencodings::Dict{Int64,Any}
-    blocks::NTuple{2,Vector{Block}}
-    task::Task
-    anyerror::Threads.Atomic{Bool}
-    errorref::Ref{Any}
-    partition_count::Int32
-    isclosed::Bool
-end
-
-function Base.open(
-    ::Type{Writer},
-    io::T,
-    compress::Union{Nothing,Symbol,LZ4FrameCompressor,ZstdCompressor},
-    writetofile::Bool,
-    largelists::Bool,
-    denseunions::Bool,
-    dictencode::Bool,
-    dictencodenested::Bool,
-    alignment::Integer,
-    maxdepth::Integer,
-    ntasks::Integer,
-    meta::Union{Nothing,Any},
-    colmeta::Union{Nothing,Any},
-    closeio::Bool,
-) where {T<:IO}
-    if compress isa Symbol && compress !== :lz4 && compress !== :zstd
-        throw(
-            ArgumentError(
-                "unsupported compress keyword argument value: $compress. Valid values include `:lz4` or `:zstd`",
-            ),
-        )
+Wrap a column to write it dictionary encoded: each distinct value is stored once, in the
+dictionary, and each row as an index into it. A wrapped column stays encoded with
+`dictencode=false`.
+"""
+struct DictEncode{T,V<:AbstractVector{T}} <: AbstractVector{T}
+    data::V
+end
+Base.size(d::DictEncode) = size(d.data)
+Base.getindex(d::DictEncode, i::Int) = d.data[i]
+
+include("columnconstruction.jl")
+
+"""
+    Arrow.write(sink, table; file=!(sink isa IO), compress=nothing,
+                compresslevel=nothing, batchsize=1_048_576, dictencode=nothing,
+                dictdeltas=false, largelists=false, stringview=false, metadata=nothing,
+                colmetadata=nothing, ntasks=Threads.nthreads())
+    Arrow.write(sink; kwargs...)
+
+Write any Tables.jl source as Arrow IPC to `sink`, a file path or an `IO`, and
+return `sink`. A FilePathsBase.jl `SystemPath` has the same behavior as a string path,
+including atomic replacement. Any other `sink` that `open(sink, "w")` accepts gets the
+file format, written in place through the `IO` that `open` returns. The one-argument
+form curries:
+`table |> Arrow.write(sink)`.
+
+Keywords:
+- `file`: `true` writes the random-access file format (`ARROW1` magic and
+  footer), `false` the stream format. A path gets the file format and an `IO`
+  the stream format by default, so a reader at the other end of a pipe or
+  socket (`Arrow.Stream`, pyarrow's `ipc.open_stream`) gets each record batch
+  as it is written.
+- `compress`: `nothing`, `:lz4`, or `:zstd`; `compresslevel` sets the codec's
+  level (LZ4 up to 12, Zstandard up to 22; `nothing` keeps the codec's
+  default, 0 for LZ4 and 3 for Zstandard).
+- `batchsize`: rows per record batch. Each `Tables.partitions` partition
+  becomes one or more batches of at most `batchsize` rows. A batch whose
+  strings, bytes, or lists would pass the 2 GiB that 32-bit offsets address
+  is cut smaller, so the declared types never change.
+- `dictencode`: which columns to dictionary-encode. By default, columns with
+  a `DataAPI.refpool` (`PooledArray`, `CategoricalArray`, a dictionary column
+  read from Arrow) and [`Arrow.DictEncode`](@ref) columns. `true` adds every
+  other column, and a column name or a collection of names adds those.
+  `false` writes pooled, categorical, and read dictionary columns as their
+  values (DuckDB's `read_arrow` refuses dictionaries); `Arrow.DictEncode`
+  columns stay encoded. A pooled column of UUIDs, or one `dictencode` names,
+  is written unencoded, since pyarrow cannot read a dictionary of
+  `arrow.uuid` values; an `Arrow.DictEncode` of UUIDs is an error, and a
+  dictionary of UUIDs read from Arrow keeps its encoding unless
+  `dictencode=false`.
+- `dictdeltas`: write the categories a dictionary gains in later partitions
+  as delta dictionary batches (see [`Arrow.Writer`](@ref)).
+- `largelists`: declare 64-bit offsets (LargeUtf8, LargeBinary, LargeList).
+- `stringview`: write strings and bytes as Utf8View/BinaryView instead of
+  Utf8/Binary.
+- `metadata`, `colmetadata`: schema and per-column key-value pairs (a `Dict`
+  or pairs; `colmetadata` maps column names, `Symbol`s or strings, to them;
+  values that are not strings are written as they print). They default to
+  the table's DataAPI metadata (a `DataFrame`'s `metadata` and `colmetadata`,
+  say), without keys under the reserved `ARROW:` prefix. An `Arrow.Table` or
+  `Arrow.Stream` keeps its own schema and field metadata.
+- `ntasks`: how many tasks build a batch's columns and compress its buffers
+  (default `Threads.nthreads()`; `ntasks=1`, or `0`, runs on the calling
+  task). The output bytes are the same for any `ntasks`.
+
+Strings, at any depth, must be valid UTF-8, as the format requires: a string
+that is not throws an `ArgumentError` naming the column and row. Write bytes
+that are not text as `Vector{UInt8}` values, a binary column.
+
+Writing to an existing file writes a temporary file in the same directory
+and renames it over the old one when the output is complete, so a failed
+write leaves the old file unchanged, and an `Arrow.Table` or `Arrow.Stream`
+that memory-maps the old file keeps reading it. The file keeps its mode, a
+symlink is written through, and a read-only file is refused with a
+`SystemError`, as opening it for writing is. If the operating system refuses
+the rename, `write` throws a `Base.IOError` and the old file is kept.
+
+Partitions are read, encoded, and published one at a time, so a partitioned
+source such as `CSV.Chunks` writes in about one partition's memory. A
+partition with no rows adds no record batch, so a table with no rows writes
+its schema alone, as pyarrow writes one. One
+partition declares each field's nullability from its element type; several
+partitions, or an iterator whose length is unknown, take their schema from the first,
+with every field nullable, and
+later partitions conform to it as later tables of an [`Arrow.Writer`](@ref)
+do. So a several-partition source of non-missing values reads back with
+`Union{Missing,T}` element types, as pyarrow and Polars write it. If writing
+fails, a path destination is left as it was; an `IO` sink may hold a partial
+output.
+
+The keywords `alignment`, `dictencodenested`, `denseunions`, and `maxdepth`,
+which Arrow 2.x took, are accepted with a one-time warning and ignored.
+"""
+function write(sink, tbl; kwargs...)
+    _writeall!(_writer(sink; oneshot=true, kwargs...), tbl)
+    return sink
+end
+
+"""
+`f(args...; kwargs...)` without inferring the call (it dispatches at run
+time, through `invokelatest`). Wherever a column's type is known only at run
+time, the reader and the writer call the typed work this way, as they do
+code that other packages extend (a table's DataAPI metadata methods): `f`
+then compiles for the concrete types alone, and methods loaded later
+(DataFrames and its dependencies add some that Base's generic code
+dispatches to) invalidate at most that code, instead of making the whole
+read or write path compile again.
+"""
+_uninferred(f, args...; kwargs...) = Base.invokelatest(f, args...; kwargs...)
+
+# One table through a one-shot writer: an error abandons the output (a path
+# destination keeps its old bytes or stays absent).
+Base.@nospecializeinfer function _writeall!(w, @nospecialize(tbl))
+    try
+        _writeparts!(w, tbl)
+    catch
+        _abandon!(w)
+        rethrow()
     end
-    sync = OrderedSynchronizer(2)
-    msgs = Channel{Message}(ntasks)
-    schema = Ref{Tables.Schema}()
-    firstcols = Ref{Any}()
-    dictencodings = Dict{Int64,Any}() # Lockable{DictEncoding}
-    blocks = (Block[], Block[])
-    # start message writing from channel
-    threaded = Threads.nthreads() > 1
-    task =
-        threaded ? (@wkspawn for msg in msgs
-            Base.write(io, msg, blocks, schema, alignment)
-        end) : (@async for msg in msgs
-            Base.write(io, msg, blocks, schema, alignment)
-        end)
-    anyerror = Threads.Atomic{Bool}(false)
-    errorref = Ref{Any}()
-    meta = _normalizemeta(meta)
-    colmeta = _normalizecolmeta(colmeta)
-    return Writer{T}(
-        io,
-        closeio,
-        compress,
-        writetofile,
-        largelists,
-        denseunions,
-        dictencode,
-        dictencodenested,
-        threaded,
-        alignment,
-        maxdepth,
-        meta,
-        colmeta,
-        sync,
-        msgs,
-        schema,
-        firstcols,
-        dictencodings,
-        blocks,
-        task,
-        anyerror,
-        errorref,
-        1,
-        false,
+    close(w)
+    return nothing
+end
+
+# An existing regular file is replaced by writing a temporary file in the
+# same directory and renaming it over the destination once the output is
+# complete. A live Arrow.Table or Arrow.Stream that memory-maps the old file
+# keeps reading the old inode, and a failed write leaves the old file as it
+# was. New paths and non-regular files (FIFOs, devices) are written in place,
+# as is any other object that `open(x, "w")` accepts (AWSS3's `S3Path`, for
+# example). The FilePathsBase extension sends local paths through `_openpath`.
+struct _PathSink
+    io::IO
+    path::String                # the destination, symlinks resolved
+    tmp::Union{Nothing,String}  # renamed over `path` on commit
+    created::Bool               # `path` did not exist before this write
+end
+
+_opensink(path::AbstractString) = _openpath(path)
+function _opensink(sink)
+    _checksink(sink)
+    return _PathSink(open(sink, "w"), string(sink), nothing, false)
+end
+
+_checksink(sink) =
+    sink isa Union{AbstractString,IO} ||
+    _openable(sink, "w") ||
+    throw(
+        ArgumentError(
+            "Arrow writes to a file path, an IO, or an object that open(x, \"w\") " *
+            "accepts, not $(typeof(sink))",
+        ),
     )
+
+function _openpath(path::AbstractString)
+    if !isfile(path)
+        created = !ispath(path) && !islink(path)
+        return _PathSink(open(path, "w"), String(path), nothing, created)
+    end
+    # The replacement below never opens the old file, so check it can be
+    # written, as `open(path, "w")` would: a read-only file refuses.
+    close(open(path, "a"))
+    dest = realpath(path)
+    tmp, io = mktemp(dirname(dest); cleanup=false)
+    try
+        chmod(tmp, filemode(dest) & 0o7777)
+    catch
+        close(io)
+        rm(tmp; force=true)
+        rethrow()
+    end
+    return _PathSink(io, dest, tmp, false)
+end
+
+function _commitpath(sink::_PathSink)
+    try
+        close(sink.io)
+    catch
+        sink.tmp === nothing || rm(sink.tmp; force=true)
+        rethrow()
+    end
+    sink.tmp === nothing && return nothing
+    err = ccall(:jl_fs_rename, Int32, (Cstring, Cstring), sink.tmp, sink.path)
+    err < 0 || return nothing
+    rm(sink.tmp; force=true)
+    hint = Sys.iswindows() ? " (close programs that hold it open, then retry)" : ""
+    throw(
+        Base.IOError(
+            "Arrow could not replace $(repr(sink.path)); it is unchanged$hint",
+            err,
+        ),
+    )
+end
+
+# Error cleanup: the destination keeps its old bytes (or stays absent).
+function _abortpath(sink::_PathSink)
+    try
+        close(sink.io)
+    catch
+        # Preserve the write error if closing also fails.
+    end
+    if sink.tmp !== nothing
+        rm(sink.tmp; force=true)
+    elseif sink.created
+        rm(sink.path; force=true)
+    end
+    return nothing
+end
+
+function write(sink; kwargs...)
+    _checksink(sink)
+    return tbl -> write(sink, tbl; kwargs...)
+end
+
+"""
+    Arrow.tobuffer(table; kwargs...)
+
+Write `table` in the IPC stream format to a new `IOBuffer`, positioned at its
+start. The keywords are those of [`Arrow.write`](@ref), except `file`.
+"""
+function tobuffer(tbl; kwargs...)
+    io = IOBuffer()
+    write(io, tbl; file=false, kwargs...)
+    seekstart(io)
+    return io
+end
+
+"""
+    Arrow.Writer(sink; file=!(sink isa IO), compress=nothing, compresslevel=nothing,
+                 batchsize=1_048_576, dictencode=nothing, largelists=false,
+                 stringview=false, nullable=true, metadata=nothing, colmetadata=nothing,
+                 dictdeltas=false, dictreplacement=false, ntasks=Threads.nthreads())
+    Arrow.Writer(f::Function, sink; kwargs...)
+
+An incremental IPC writer: batches publish to `sink` as they are written,
+so producing tables one at a time never holds more than one partition of
+the current table in memory. `sink` is a file path, or another object that
+`open(sink, "w")` accepts (the writer opens and owns the handle), or an `IO`
+(borrowed; `close` finishes the IPC output but leaves the `IO` open). The function
+form runs `f(writer)` and closes the writer. If `f` throws, the writer is abandoned
+instead, so a path's existing file keeps its bytes as after a failed
+[`Arrow.write`](@ref), unless the sink is an `IO` that already received a table:
+that output is closed, so it holds the tables written before the error. A sink
+that is not a path but is written in place (an object `open(sink, "w")` accepts)
+holds an incomplete file after an error, as after a failed `Arrow.write`. The
+keywords mean what they mean for [`Arrow.write`](@ref), whose metadata rules apply
+too. An existing file path is replaced as by [`Arrow.write`](@ref): the output goes
+to a temporary file that `close` renames over the old file.
+
+    w = Arrow.Writer(path)
+    for tbl in tables
+        Arrow.write(w, tbl)
+    end
+    close(w)
+
+The first table written fixes the schema, with the inference one
+`Arrow.write` of that table would use, except that every field is declared
+nullable (as pyarrow and Polars do), so later missing values conform;
+`nullable=false` keeps the first table's nullability instead. A table from
+`Arrow.Table` or `Arrow.Stream` keeps its own schema. Every later table must
+have the same column names in the same order and types that fit the schema:
+numbers widen losslessly (`Int32` into an `Int64` column, `Float32` into
+`Float64`), missing values fill nullable fields (nested ones too), and
+anything else is refused with an error naming the column and both types. A
+table's partitions publish one at a time: if a later partition is refused,
+the batches of its earlier partitions stay in the output, and the writer
+stays open.
+
+Dictionary-encoded columns (`Arrow.DictEncode`, `PooledArray`,
+`CategoricalArray`) keep one dictionary across tables: a later table's new
+categories are added after the earlier ones, and its indices refer to the
+combined categories. Such dictionaries use `Int32` indices. In the file
+format each dictionary is written once, complete, when the writer closes
+(after the record batches; the format allows a dictionary anywhere before
+the footer). In the stream format a dictionary that gained categories is
+written again whole before the batch that needs it. pyarrow and Polars read
+both. `dictdeltas=true` writes only the new categories, as delta dictionary
+batches (in both formats): smaller, read by pyarrow, refused by Polars 1.43.
+With `dictreplacement=true` (stream format only), each table instead replaces
+the dictionary with its own categories; the schema then declares the
+DictionaryReplacement feature, which strict readers such as nanoarrow refuse.
+
+`close` finishes the output, which then holds every batch written so far;
+closing again does nothing. A writer closed before it receives a table writes
+an output with no columns; one abandoned without `close` leaves a stream
+without its end marker or a file without its footer. A table, or partition,
+with no rows adds no record batch. One task owns a writer: overlapping calls
+are not synchronized.
+"""
+mutable struct Writer
+    const io::IO
+    const ownio::Bool
+    const path::Union{Nothing,_PathSink}
+    const file::Bool
+    const compress::Symbol
+    const metadata::Any
+    const colmetadata::Any
+    const dictreplacement::Bool
+    const dictdeltas::Bool
+    const compresslevel::Union{Nothing,Int}
+    const batchsize::Int
+    const largelists::Bool
+    const stringview::Bool
+    const nullable::Bool
+    const dictencode::Any
+    const ntasks::Int
+    # Arrow.write keeps input nullability and index types for a known
+    # single partition; other sources allow later partitions to extend them.
+    const oneshot::Bool
+    # The buffers each batch's columns rebuild, reused batch to batch.
+    const pool::Union{Nothing,_BufferPool}
+    # Where a C data export keeps each batch built; it then reuses no buffers.
+    const exported::Union{Nothing,Vector{AC.RecordBatch}}
+    # Per column, the last dictionary pool a later table grew: the pool, the
+    # stored-key index of its categories, and the categories it added.
+    const dictgrowth::Vector{Any}
+    st::Union{Nothing,IPCWriteState}
+    names::Vector{Symbol}
+    schema::Union{Nothing,AC.Schema}
+    # Arrow.append's writer, whose schema an earlier writer fixed.
+    appending::Bool
+    @atomic closed::Bool
 end
 
-function Base.open(
-    ::Type{Writer},
-    io::IO;
-    compress::Union{Nothing,Symbol,LZ4FrameCompressor,ZstdCompressor}=nothing,
-    file::Bool=true,
+function _writer(
+    sink;
+    file::Bool=(!isa(sink, IO)),
+    compress=nothing,
+    metadata=nothing,
+    colmetadata=nothing,
+    dictreplacement::Bool=false,
+    dictdeltas::Bool=false,
+    compresslevel::Union{Nothing,Integer}=nothing,
+    batchsize::Integer=DEFAULT_BATCHSIZE,
     largelists::Bool=false,
-    denseunions::Bool=true,
-    dictencode::Bool=false,
-    dictencodenested::Bool=false,
-    alignment::Integer=8,
-    maxdepth::Integer=DEFAULT_MAX_DEPTH,
-    ntasks::Integer=typemax(Int32),
-    metadata::Union{Nothing,Any}=nothing,
-    colmetadata::Union{Nothing,Any}=nothing,
-    closeio::Bool=false,
+    stringview::Bool=false,
+    nullable::Bool=true,
+    dictencode=nothing,
+    oneshot::Bool=false,
+    exported=nothing,
+    ntasks::Integer=Threads.nthreads(),
+    # Arrow 2.x writer keywords: accepted and ignored (with a one-time
+    # warning each) so 2.x call sites keep working during migration.
+    alignment=nothing,
+    dictencodenested=nothing,
+    denseunions=nothing,
+    maxdepth=nothing,
+    unknown...,
 )
-    open(
-        Writer,
-        io,
-        compress,
-        file,
-        largelists,
-        denseunions,
-        dictencode,
-        dictencodenested,
-        alignment,
-        maxdepth,
-        ntasks,
-        metadata,
-        colmetadata,
-        closeio,
+    isempty(unknown) || _unknownkeywords("write", keys(unknown))
+    for (name, value) in (
+        (:alignment, alignment),
+        (:dictencodenested, dictencodenested),
+        (:denseunions, denseunions),
+        (:maxdepth, maxdepth),
     )
+        value === nothing || _warnremovedkwarg(name)
+    end
+    codec = _codec(compress, compresslevel)
+    batchsize = _checkbatchsize(batchsize)
+    # Arrow 2.x's `ntasks=0` (unbuffered writing) is one task.
+    ntasks >= 0 || throw(ArgumentError("ntasks must be at least 1, got $ntasks"))
+    dictencode isa Union{Nothing,Bool,Symbol,AbstractString} ||
+        all(n -> n isa Union{Symbol,AbstractString}, dictencode) ||
+        throw(ArgumentError("dictencode must be true, false, or column names"))
+    if dictreplacement && file
+        throw(
+            ArgumentError(
+                "dictreplacement is a stream-format feature; the IPC file " *
+                "format carries one dictionary per column, extended only by deltas",
+            ),
+        )
+    end
+    # Open only after keyword dispatch and option checks.
+    ownio = !(sink isa IO)
+    path = ownio ? _opensink(sink) : nothing
+    io = ownio ? path.io : sink
+    try
+        return Writer(
+            io,
+            ownio,
+            path,
+            file,
+            codec,
+            metadata,
+            colmetadata,
+            dictreplacement,
+            dictdeltas,
+            compresslevel === nothing ? nothing : Int(compresslevel),
+            batchsize,
+            largelists,
+            stringview,
+            nullable,
+            dictencode,
+            max(Int(ntasks), 1),
+            oneshot,
+            exported === nothing ? _BufferPool() : nothing,
+            exported,
+            Any[],
+            nothing,
+            Symbol[],
+            nothing,
+            false,
+            false,
+        )
+    catch
+        ownio && _abortpath(path)
+        rethrow()
+    end
 end
 
-Base.open(::Type{Writer}, file_path; kwargs...) =
-    open(Writer, open(file_path, "w"); kwargs..., closeio=true)
+Writer(sink; kwargs...) = _writer(sink; kwargs...)
 
-function check_errors(writer::Writer)
-    if writer.anyerror[]
-        errorref = writer.errorref[]
-        @error "error writing arrow data on partition = $(errorref[3])" exception =
-            (errorref[1], errorref[2])
-        error("fatal error writing arrow data")
+function Writer(f::Function, sink; kwargs...)
+    w = Writer(sink; kwargs...)
+    result = try
+        f(w)
+    catch
+        try
+            # A path keeps its old file, as after a failed `Arrow.write`; an
+            # `IO` that got a table is ended, so it holds those tables.
+            w.ownio || w.st === nothing ? _abandon!(w) : close(w)
+        catch
+            # Preserve the body error if finalization or sink cleanup fails.
+        end
+        rethrow()
     end
+    close(w)
+    return result
 end
 
-function write(writer::Writer, source)
-    @sync for tbl in Tables.partitions(source)
-        check_errors(writer)
-        @debug "processing table partition $(writer.partition_count)"
-        tblcols = Tables.columns(tbl)
-        if !isassigned(writer.firstcols)
-            if writer.writetofile
-                @debug "starting write of arrow formatted file"
-                Base.write(writer.io, FILE_FORMAT_MAGIC_BYTES, b"\0\0")
-            end
-            meta = isnothing(writer.meta) ? getmetadata(source) : writer.meta
-            cols = toarrowtable(
-                tblcols,
-                writer.dictencodings,
-                writer.largelists,
-                writer.compress,
-                writer.denseunions,
-                writer.dictencode,
-                writer.dictencodenested,
-                writer.maxdepth,
-                meta,
-                writer.colmeta,
-            )
-            writer.schema[] = Tables.schema(cols)
-            writer.firstcols[] = cols
-            put!(writer.msgs, makeschemamsg(writer.schema[], cols))
-            if !isempty(writer.dictencodings)
-                des = sort!(collect(writer.dictencodings); by=x -> x.first, rev=true)
-                for (id, delock) in des
-                    # assign dict encoding ids
-                    de = delock.value
-                    dictsch = Tables.Schema((:col,), (eltype(de.data),))
-                    dictbatchmsg = makedictionarybatchmsg(
-                        dictsch,
-                        (col=de.data,),
-                        id,
-                        false,
-                        writer.alignment,
-                    )
-                    put!(writer.msgs, dictbatchmsg)
-                end
+# The Arrow 2.x opening idiom: `open(Arrow.Writer, sink)` constructs the
+# writer (the caller closes it), and the function form is `Writer(f, sink)`.
+Base.open(::Type{Writer}, sink; kwargs...) = Writer(sink; kwargs...)
+Base.open(f::Function, ::Type{Writer}, sink; kwargs...) = Writer(f, sink; kwargs...)
+
+Base.isopen(w::Writer) = !(@atomic w.closed)
+
+"""
+    Arrow.write(writer::Arrow.Writer, table)
+
+Write one Tables.jl source through an incremental [`Arrow.Writer`](@ref):
+each `Tables.partitions` partition becomes one or more record batches of at
+most the writer's `batchsize` rows, published to the sink before the call
+returns. Returns `writer`. See [`Arrow.Writer`](@ref)
+for the schema rules.
+"""
+function write(w::Writer, tbl)
+    (@atomic w.closed) && throw(ArgumentError("this Arrow.Writer is closed"))
+    _writeparts!(w, tbl)
+    return w
+end
+
+# Write `tbl` partition by partition: each partition is read, encoded, and
+# published before the next one is requested, so memory holds one partition
+# (and one record batch of encoded output) at a time.
+# The table and partition types are not specialized on: columns dispatch on
+# their own types, so a new table type compiles no new writer code.
+Base.@nospecializeinfer function _writeparts!(w::Writer, @nospecialize(tbl))
+    retained = _uninferred(_retainedschema, tbl)::Union{Nothing,AC.Schema}
+    w.dictencode === false &&
+        retained !== nothing &&
+        (retained = _plainschema(retained, Tables.schema(tbl)))
+    parts = Tables.partitions(tbl)
+    next = iterate(parts)
+    if next === nothing
+        # A zero-batch Arrow.Stream still carries its schema.
+        w.st === nothing && _beginwrite!(w, _schemaonly(retained, w.colmetadata), retained)
+        return nothing
+    end
+    # An unknown-length source may have later partitions. Do not fetch one
+    # to find out: iterators may reuse their column buffers or wait for the
+    # current batch to reach the consumer before producing another.
+    knownlength = Base.IteratorSize(typeof(parts)) isa Union{Base.HasLength,Base.HasShape}
+    several = !knownlength || length(parts) != 1
+    k = 1
+    try
+        while true
+            part, state = next
+            try
+                _writepartition!(w, part, retained, several)
+                # Compression tasks may still read the partition's buffers.
+                w.st === nothing || drainwrite!(w.st)
+            catch err
+                err isa _InvalidUTF8 || rethrow()
+                msg = _invalidutf8message(err.column, err.row, several ? k : 0)
+                throw(ArgumentError(msg))
             end
-            recbatchmsg = makerecordbatchmsg(writer.schema[], cols, writer.alignment)
-            put!(writer.msgs, recbatchmsg)
-        else
-            # XXX There is a race condition in the processing of dict encodings
-            # so we disable multithreaded writing until that can be addressed. See #582
-            # if writer.threaded
-            #     @wkspawn process_partition(
-            #         tblcols,
-            #         writer.dictencodings,
-            #         writer.largelists,
-            #         writer.compress,
-            #         writer.denseunions,
-            #         writer.dictencode,
-            #         writer.dictencodenested,
-            #         writer.maxdepth,
-            #         writer.sync,
-            #         writer.msgs,
-            #         writer.alignment,
-            #         $(writer.partition_count),
-            #         writer.schema,
-            #         writer.errorref,
-            #         writer.anyerror,
-            #         writer.meta,
-            #         writer.colmeta,
-            #     )
-            # else
-            @async process_partition(
-                tblcols,
-                writer.dictencodings,
-                writer.largelists,
-                writer.compress,
-                writer.denseunions,
-                writer.dictencode,
-                writer.dictencodenested,
-                writer.maxdepth,
-                writer.sync,
-                writer.msgs,
-                writer.alignment,
-                $(writer.partition_count),
-                writer.schema,
-                writer.errorref,
-                writer.anyerror,
-                writer.meta,
-                writer.colmeta,
-            )
-            # end
+            next = iterate(parts, state)
+            next === nothing && break
+            k += 1
         end
-        writer.partition_count += 1
-    end
-    check_errors(writer)
-    return
-end
-
-function Base.close(writer::Writer)
-    writer.isclosed && return
-    # close our message-writing channel, no further put!-ing is allowed
-    close(writer.msgs)
-    # now wait for our message-writing task to finish writing
-    !istaskfailed(writer.task) && wait(writer.task)
-    if (!isassigned(writer.schema) || !isassigned(writer.firstcols))
-        writer.closeio && close(writer.io)
-        writer.isclosed = true
-        return
-    end
-    # write empty message
-    if !writer.writetofile
-        msg = Message(UInt8[], nothing, 0, true, false, Meta.Schema)
-        Base.write(writer.io, msg, writer.blocks, writer.schema, writer.alignment)
-        writer.closeio && close(writer.io)
-        writer.isclosed = true
-        return
-    end
-    b = FlatBuffers.Builder(1024)
-    schfoot = makeschema(b, writer.schema[], writer.firstcols[])
-    recordbatches = if !isempty(writer.blocks[1])
-        N = length(writer.blocks[1])
-        Meta.footerStartRecordBatchesVector(b, N)
-        for blk in Iterators.reverse(writer.blocks[1])
-            Meta.createBlock(b, blk.offset, blk.metaDataLength, blk.bodyLength)
+    catch
+        # The batches written before the failure still publish; the failure
+        # is the error to report.
+        try
+            w.st === nothing || drainwrite!(w.st)
+        catch
         end
-        FlatBuffers.endvector!(b, N)
-    else
-        FlatBuffers.UOffsetT(0)
+        rethrow()
     end
-    dicts = if !isempty(writer.blocks[2])
-        N = length(writer.blocks[2])
-        Meta.footerStartDictionariesVector(b, N)
-        for blk in Iterators.reverse(writer.blocks[2])
-            Meta.createBlock(b, blk.offset, blk.metaDataLength, blk.bodyLength)
-        end
-        FlatBuffers.endvector!(b, N)
-    else
-        FlatBuffers.UOffsetT(0)
-    end
-    Meta.footerStart(b)
-    Meta.footerAddVersion(b, Meta.MetadataVersion.V5)
-    Meta.footerAddSchema(b, schfoot)
-    Meta.footerAddDictionaries(b, dicts)
-    Meta.footerAddRecordBatches(b, recordbatches)
-    foot = Meta.footerEnd(b)
-    FlatBuffers.finish!(b, foot)
-    footer = FlatBuffers.finishedbytes(b)
-    Base.write(writer.io, footer)
-    Base.write(writer.io, Int32(length(footer)))
-    Base.write(writer.io, "ARROW1")
-    writer.closeio && close(writer.io)
-    writer.isclosed = true
-    nothing
-end
-
-function write(io::IO, tbl; kwargs...)
-    open(Writer, io; file=false, kwargs...) do writer
-        write(writer, tbl)
-    end
-    io
-end
-
-function write(
-    io,
-    source,
-    writetofile,
-    largelists,
-    compress,
-    denseunions,
-    dictencode,
-    dictencodenested,
-    alignment,
-    maxdepth,
-    ntasks,
-    meta,
-    colmeta,
+    return nothing
+end
+
+Base.@nospecializeinfer function _writepartition!(
+    w::Writer,
+    @nospecialize(part),
+    retained,
+    several::Bool,
 )
-    open(
-        Writer,
-        io,
-        compress,
-        writetofile,
-        largelists,
-        denseunions,
-        dictencode,
-        dictencodenested,
-        alignment,
-        maxdepth,
-        ntasks,
-        meta,
-        colmeta,
-    ) do writer
-        write(writer, source)
-    end
-    io
-end
-
-function process_partition(
+    cols = Tables.columns(part)
+    names = collect(Symbol, Tables.columnnames(cols))
+    w.st === nothing ||
+        names == w.names ||
+        throw(
+            ArgumentError(
+                "table column names $(_uninferred(string, names)::String) do not match " *
+                "the schema columns $(_uninferred(string, w.names)::String) (same names, " *
+                "same order)",
+            ),
+        )
+    # Arrow permits duplicate field names. Tables.getcolumn(cols, name)
+    # cannot distinguish them, so bind every column by position.
+    columns = AbstractVector[Tables.getcolumn(cols, j) for j in eachindex(names)]
+    own = _partitiondictpools(part)
+    own === nothing ||
+        length(own) == length(names) ||
+        throw(
+            ArgumentError("retained dictionary pool count does not match partition width"),
+        )
+    n = Int(Tables.rowcount(cols))
+    # A zero-column partition has no column to count rows from, so ask the
+    # partition itself: Arrow legally allows zero fields with a positive
+    # row count (the reader carries that count on the Table).
+    n == 0 && isempty(names) && (n = Int(Tables.rowcount(part)))
+    for j in eachindex(columns)
+        m = length(columns[j])
+        m == n || throw(
+            ArgumentError(
+                "column $(names[j]) has $m rows, but column $(names[1]) has $n; every " *
+                "column of a table must have the same length",
+            ),
+        )
+    end
+    # A partition with no rows writes no record batch, as pyarrow writes an
+    # empty table; the first one still fixes the schema (`_writebatch!`).
+    n == 0 && w.st !== nothing && return nothing
+    encoded = _dictencodeflags(names, w.dictencode)
+    for j in eachindex(columns)
+        col = columns[j]
+        encoded[j] &&
+            !(col isa DictEncode) &&
+            !_uninferred(_hasrefpool, col)::Bool &&
+            !_uuidvalues(col) &&
+            (col = DictEncode(col))
+        # Inference from values sees the whole partition, not one batch.
+        columns[j] = _uninferred(_narrowcolumn, String(names[j]), col)
+    end
+    # The first partition's dictionaries hold all of its categories, so its
+    # batches share one pool. A later partition re-indexes its dictionaries into
+    # the written pools, except an Arrow source's, whose retained construction
+    # continues them from these hints.
+    hints =
+        w.st === nothing || retained !== nothing ?
+        _uninferred(_partitionhints, w, columns, own)::Vector{Any} :
+        Any[nothing for _ in columns]
+    # The partition is captured as `Any`, so `_eachbatch` compiles once, not
+    # once per table type.
+    anypart = Ref{Any}(part)
+    _eachbatch(columns, n, w.batchsize) do batchcols, nrows
+        _writebatch!(
+            w,
+            anypart[],
+            names,
+            batchcols,
+            nrows,
+            hints,
+            retained,
+            encoded,
+            several,
+        )
+    end
+    return nothing
+end
+
+"One record batch: the first fixes the schema; later ones must conform to it."
+Base.@nospecializeinfer function _writebatch!(
+    w::Writer,
+    @nospecialize(part),
+    names,
     cols,
-    dictencodings,
-    largelists,
-    compress,
-    denseunions,
-    dictencode,
-    dictencodenested,
-    maxdepth,
-    sync,
-    msgs,
-    alignment,
-    i,
-    sch,
-    errorref,
-    anyerror,
-    meta,
-    colmeta,
+    nrows,
+    hints,
+    retained,
+    encoded,
+    several,
 )
-    try
-        cols = toarrowtable(
+    if w.st === nothing
+        colmetadata = w.colmetadata
+        colmetadata === nothing &&
+            retained === nothing &&
+            (colmetadata = _uninferred(_inputcolmetadata, part, names))
+        fields, coldata = _constructcolumns(
+            names,
             cols,
-            dictencodings,
-            largelists,
-            compress,
-            denseunions,
-            dictencode,
-            dictencodenested,
-            maxdepth,
-            meta,
-            colmeta,
+            hints,
+            _retainedfieldfn(retained, names, encoded),
+            colmetadata;
+            refpools=w.dictencode !== false,
+            stringview=w.stringview,
+            largelists=w.largelists,
+            # A stream can be appended to, so its dictionaries may grow too.
+            growable=(!w.oneshot || several || !w.file),
+            ntasks=_batchtasks(w, nrows, length(names)),
+            w.pool,
         )
-        dictmsgs = nothing
-        if !isempty(cols.dictencodingdeltas)
-            dictmsgs = []
-            for de in cols.dictencodingdeltas
-                dictsch = Tables.Schema((:col,), (eltype(de.data),))
-                push!(
-                    dictmsgs,
-                    makedictionarybatchmsg(dictsch, (col=de.data,), de.id, true, alignment),
-                )
-            end
+        retained === nothing ||
+            _checkencodedstructs(fields, _retainedfieldfn(retained, names), names)
+        # Fields are nullable so later missing values conform (a Writer, or
+        # several input partitions); a retained schema keeps its own.
+        nullable = (w.oneshot ? several : w.nullable) && retained === nothing
+        nullable && (fields = AC.Field[_nullablefield(f) for f in fields])
+        _beginwrite!(w, fields, retained, names; several, input=part)
+        batch = AC.RecordBatch(w.schema, coldata, nrows)
+        w.exported === nothing || push!(w.exported, batch)
+        nrows == 0 && return nothing
+        writebatch!(w.st::IPCWriteState, batch; recycle=_handoff!(w.pool))
+        return nothing
+    end
+    sch = w.schema::AC.Schema
+    st = w.st::IPCWriteState
+    written = Any[
+        f.type isa AC.DictionaryType && !w.dictreplacement ?
+        get(st.current, st.ids[f], nothing) : nothing for f in sch.fields
+    ]
+    growth = w.dictgrowth
+    length(growth) == length(written) || fill!(resize!(growth, length(written)), nothing)
+    fields, coldata = _constructconforming(
+        names,
+        cols,
+        hints,
+        sch,
+        part;
+        w.stringview,
+        w.largelists,
+        written,
+        growth,
+        ntasks=_batchtasks(w, nrows, length(names)),
+        w.pool,
+        nullhint=_nullhint(w),
+    )
+    # A fresh Schema over the BUILT fields, so `writebatch!` re-checks them
+    # against the writer's schema instead of trusting construction.
+    batch = AC.RecordBatch(AC.Schema(fields; metadata=sch.metadata), coldata, nrows)
+    deltas = _uninferred(_dictionarydeltas, st, batch, growth)::Dict{Int64,AC.ArrayData}
+    w.exported === nothing || push!(w.exported, batch)
+    writebatch!(st, batch; deltas, recycle=_handoff!(w.pool))
+    return nothing
+end
+
+"""
+What a conformance refusal adds when the column would conform to its field
+declared nullable: how to start a stream that takes missing values later (an
+append's stream was started elsewhere), or that this writer kept the first
+table's nullability. A writer whose fields are nullable already adds nothing.
+"""
+_nullhint(w::Writer) =
+    w.appending ?
+    ", or, to add missing values to a column that had none, start the stream " *
+    "with Arrow.Writer(path; file=false), whose columns are all nullable (a " *
+    "one-table Arrow.write declares nullability from its values)" :
+    !w.oneshot && !w.nullable ?
+    "; this Arrow.Writer was created with nullable=false, so each column keeps " *
+    "the first table's nullability" : ""
+
+"""
+Refuse a `dictencode` column whose retained struct would write as a map: a
+reader gives some struct rows as ordered `name => value` pairs (structs with
+repeated field names or more than 1,024 fields, structs in a list view), and a
+fresh dictionary pool writes those as Arrow maps.
+"""
+function _checkencodedstructs(fields, retainedfield, names)
+    for (j, f) in enumerate(fields)
+        f.type isa AC.DictionaryType || continue
+        r = retainedfield(j)
+        r !== nothing &&
+            !(r.type isa AC.DictionaryType) &&
+            _structasmap(r, AC.dictvaluefield(f, f.type)) &&
+            throw(
+                ArgumentError(
+                    "column $(names[j]) holds struct rows that read as name => value " *
+                    "pairs, which dictionary encoding would write as an Arrow map; " *
+                    "write the column without dictionary encoding (leave it out of " *
+                    "dictencode)",
+                ),
+            )
+    end
+    return nothing
+end
+_structasmap(r::AC.Field, f::AC.Field) =
+    r.type isa AC.StructType && f.type isa AC.MapType ||
+    length(r.children) == length(f.children) &&
+    any(i -> _structasmap(r.children[i], f.children[i]), eachindex(r.children))
+
+"Fix the schema and publish its message (and the file preamble)."
+function _beginwrite!(
+    w::Writer,
+    fields,
+    retained,
+    names=nothing;
+    several::Bool=false,
+    input=nothing,
+)
+    # The bounded facade interning rule, as when the source was read.
+    names === nothing && (names = _fieldnamesymbols(fields))
+    sch = AC.Schema(fields; metadata=_writermetadata(w.metadata, retained, input))
+    w.st = beginwrite!(
+        w.io,
+        sch;
+        file=w.file,
+        compress=w.compress,
+        compresslevel=w.compresslevel,
+        dictreplacement=w.dictreplacement,
+        ntasks=w.ntasks,
+        growth=_dictgrowth(w, several),
+    )
+    w.schema = sch
+    w.names = names
+    return nothing
+end
+
+# `dictencode=false`: a retained top-level dictionary column writes as its
+# values, nullable when its values can be missing.
+function _plainschema(retained::AC.Schema, sch)
+    any(f -> f.type isa AC.DictionaryType, retained.fields) || return retained
+    types = sch === nothing ? nothing : sch.types
+    fields = AC.Field[
+        f.type isa AC.DictionaryType ?
+        AC.Field(
+            f.name,
+            f.type.valuetype;
+            nullable=f.nullable ||
+                     types === nothing ||
+                     length(types) != length(retained.fields) ||
+                     Missing <: types[j],
+            metadata=f.metadata,
+            children=collect(AC.Field, f.children),
+        ) : f for (j, f) in enumerate(retained.fields)
+    ]
+    return AC.Schema(fields; metadata=retained.metadata)
+end
+
+"""
+How a dictionary that gains categories is written (see `IPCWriteState`).
+Defaults every reader accepts: files write each final dictionary once, at
+the end; streams write a grown dictionary again whole. One table with one
+partition has all its categories from the start, so it keeps its
+dictionaries before the record batches.
+"""
+function _dictgrowth(w::Writer, several::Bool)
+    w.dictdeltas && return :delta
+    w.file || return :replace
+    return w.oneshot && !several ? :delta : :defer
+end
+
+"""
+Dictionary hints for the first partition, or a partition of an Arrow source:
+the categories written so far, then the categories the partition brings (a
+pool it retains from its Arrow source, a `PooledArray`'s pool, or a
+`DictEncode` column's values), so every batch of the partition shares one
+dictionary.
+"""
+function _partitionhints(w::Writer, columns, own)
+    hints = Vector{Any}(undef, length(columns))
+    written =
+        w.st === nothing || w.dictreplacement ? nothing :
+        _uninferred(_writtenpools, w.st::IPCWriteState)::Vector{Any}
+    for j in eachindex(columns)
+        prior = written === nothing ? nothing : written[j]
+        retainedown = own === nothing ? nothing : own[j]
+        hint = _extendpool(prior, retainedown)
+        # The written categories (or else an Arrow source's own pool) are kept
+        # exactly; the categories after them dedupe by storage value.
+        prefix =
+            prior !== nothing ? length(prior) :
+            retainedown !== nothing ? length(retainedown) : 0
+        col = columns[j]
+        if col isa DictEncode
+            T = Base.nonmissingtype(_eltypeof(col.data))
+            writetype = isconcretetype(T) ? T : nothing
+            all(ismissing, col.data) || (hint = _dictionarypool(col.data, hint; writetype))
+        elseif _hasrefpool(col) && (
+            w.st === nothing || (w.schema::AC.Schema).fields[j].type isa AC.DictionaryType
+        )
+            hint = _extendpool(hint, last(_uninferred(_refpoolvalues, col)))
+        end
+        hints[j] = hint === nothing ? nothing : _PoolHint(hint, prefix)
+    end
+    return hints
+end
+
+# A column whose element type no Arrow type holds (`Any`, `Real`) narrowed
+# from all its values, so every batch writes the same type.
+function _narrowcolumn(name::String, @nospecialize(col::AbstractVector))
+    T = eltype(col)
+    anylists = T === Any || (T <: AbstractVector && eltype(T) === Any)
+    # A dictionary column infers its abstract value type from its pool.
+    col isa DictEncode && return anylists ? DictEncode(_narrowlists(col.data, name)) : col
+    anylists && (col = _narrowlists(col, name))
+    narrowed = _uninferred(
+        _narrowabstractcolumn,
+        name,
+        col,
+        _WriterContext(name),
+    )::Union{Nothing,AbstractVector}
+    return narrowed === nothing ? col : narrowed
+end
+
+"""
+Call `f(cols, nrows)` for consecutive record batches of at most `batchsize`
+rows. A batch whose 32-bit offsets would pass the Int32 range throws
+`_OffsetOverflow` before it is written; it is then cut at the row that did not
+fit (every later batch of the partition too) and built again, so the declared
+types never change. A zero-row partition is one empty batch.
+"""
+function _eachbatch(f::F, cols::Vector{AbstractVector}, n::Int, batchsize::Int) where {F}
+    n == 0 && return f(AbstractVector[_uninferred(_rowslice, c, 1:0) for c in cols], 0)
+    size = batchsize
+    start = 1
+    while start <= n
+        r = start:min(start + size - 1, n)
+        try
+            f(AbstractVector[_uninferred(_rowslice, c, r) for c in cols], length(r))
+        catch err
+            err isa _InvalidUTF8 && throw(
+                _InvalidUTF8(err.column, 0, err.row == 0 ? 0 : first(r) - 1 + err.row),
+            )
+            err isa _OffsetOverflow || rethrow()
+            size = min(size, _smallerbatch(length(r), err))
+            continue
         end
-        put!(sync, i) do
-            if !isnothing(dictmsgs)
-                foreach(msg -> put!(msgs, msg), dictmsgs)
+        start = last(r) + 1
+    end
+    return nothing
+end
+
+"Release a writer after an error without finishing its output."
+function _abandon!(w::Writer)
+    @atomic w.closed = true
+    st = w.st
+    st === nothing || abortwrite!(st)
+    w.ownio && _abortpath(w.path)
+    return nothing
+end
+
+function Base.close(w::Writer)
+    (@atomic w.closed) && return nothing
+    @atomic w.closed = true
+    try
+        # A writer that got no table writes a valid output with no columns.
+        w.st === nothing && _beginwrite!(w, AC.Field[], nothing, Symbol[])
+    catch
+        w.ownio && _abortpath(w.path)
+        rethrow()
+    end
+    st = w.st
+    try
+        st === nothing || finishwrite!(st)
+    catch
+        if st !== nothing
+            try
+                abortwrite!(st)
+            catch
+                # Preserve the finalization error if codec cleanup also fails.
             end
-            put!(msgs, makerecordbatchmsg(sch[], cols, alignment))
         end
-    catch e
-        errorref[] = (e, catch_backtrace(), i)
-        anyerror[] = true
+        w.ownio && _abortpath(w.path)
+        rethrow()
     end
-    return
+    w.ownio ? _commitpath(w.path) : flush(w.io)
+    return nothing
 end
 
-struct ToArrowTable
-    sch::Tables.Schema
-    cols::Vector{Any}
-    metadata::Union{Nothing,Base.ImmutableDict{String,String}}
-    dictencodingdeltas::Vector{DictEncoding}
+"""
+    Arrow.append(sink, table; compress=nothing, compresslevel=nothing,
+                 batchsize=1_048_576, dictdeltas=false)
+    Arrow.append(sink; kwargs...)
+
+Add `table`'s record batches to an existing IPC STREAM (`sink` is a file
+path or a seekable read/write `IO`). The existing stream's message metadata
+is checked and its dictionaries are decoded first; its record batch bodies
+are not read, so a corrupt batch already in the stream is not detected. The
+new columns are constructed against the stream's schema (same
+names and order; types fit as for a later table of [`Arrow.Writer`](@ref),
+or the append is refused), and the new batches are published after the last
+existing message (over its end-of-stream marker, if it has one), followed by a
+new end-of-stream marker.
+
+A dictionary-encoded column continues the stream's latest dictionary, within
+the range of its index type: a dictionary that gains categories is written
+again whole (`dictdeltas=true` writes only the new categories, as a delta
+dictionary batch). A stream whose schema declares DictionaryReplacement
+(`Arrow.Writer(sink; file=false, dictreplacement=true)`) gets a replacement
+dictionary instead. The file format does not support appending: rewrite the
+file, or produce it incrementally with [`Arrow.Writer`](@ref). A missing or
+empty `sink` starts a new stream, as `Arrow.write(sink, table; file=false)`
+does. The one-argument form curries: `table |> Arrow.append(path)`.
+"""
+function append(path::AbstractString, tbl; kwargs...)
+    # Appending to nothing starts a stream.
+    isfile(path) && filesize(path) > 0 || return write(path, tbl; file=false, kwargs...)
+    # Mapped, so only the bytes framing reads (metadata, dictionaries) are read.
+    region = open(io -> AC._mmapregion(io, path; eager=false), path)
+    # The tail is owned bytes, so the mapping goes before the file is written:
+    # Windows refuses to delete or replace a mapped file.
+    keep, tail = try
+        _appendbytes(region, tbl; kwargs...)
+    finally
+        AC._unmap!(region)
+    end
+    open(path, "r+") do io
+        seek(io, keep)
+        Base.write(io, tail)
+    end
+    return path
 end
 
-function toarrowtable(
-    cols,
-    dictencodings,
-    largelists,
-    compress,
-    denseunions,
-    dictencode,
-    dictencodenested,
-    maxdepth,
-    meta,
-    colmeta,
+function append(io::IO, tbl; kwargs...)
+    seekstart(io)
+    bytes = Base.read(io)
+    isempty(bytes) && return write(io, tbl; file=false, kwargs...)
+    keep, tail = _appendbytes(AC.heapregion(bytes), tbl; kwargs...)
+    seek(io, keep)
+    Base.write(io, tail)
+    return io
+end
+
+append(sink::Union{AbstractString,IO}; kwargs...) = tbl -> append(sink, tbl; kwargs...)
+
+function _appendbytes(
+    region::AC.OwnerRegion,
+    tbl;
+    compress=nothing,
+    compresslevel::Union{Nothing,Integer}=nothing,
+    batchsize::Integer=DEFAULT_BATCHSIZE,
+    dictdeltas::Bool=false,
+    unknown...,
 )
-    @debug "converting input table to arrow formatted columns"
-    sch = Tables.schema(cols)
-    types = collect(sch.types)
-    N = length(types)
-    newcols = Vector{Any}(undef, N)
-    newtypes = Vector{Type}(undef, N)
-    dictencodingdeltas = DictEncoding[]
-    Tables.eachcolumn(sch, cols) do col, i, nm
-        oldcolmeta = getmetadata(col)
-        newcolmeta = isnothing(colmeta) ? oldcolmeta : get(colmeta, nm, oldcolmeta)
-        newcol = toarrowvector(
-            col,
-            i,
-            dictencodings,
-            dictencodingdeltas,
-            newcolmeta;
-            compression=compress,
-            largelists=largelists,
-            denseunions=denseunions,
-            dictencode=dictencode,
-            dictencodenested=dictencodenested,
-            maxdepth=maxdepth,
+    isempty(unknown) || _unknownkeywords("append", keys(unknown))
+    region.len >= 6 &&
+        AC.slicebytes(AC.BufferSlice(region, 0, 6)) == FILE_MAGIC &&
+        throw(
+            ArgumentError(
+                "Arrow.append supports the IPC stream format; this sink holds " *
+                "the file format (ARROW1) — produce it incrementally with " *
+                "Arrow.Writer, or rewrite it with Arrow.write",
+            ),
         )
-        newtypes[i] = eltype(newcol)
-        newcols[i] = newcol
-    end
-    minlen, maxlen = isempty(newcols) ? (0, 0) : extrema(length, newcols)
-    minlen == maxlen ||
-        throw(ArgumentError("columns with unequal lengths detected: $minlen < $maxlen"))
-    meta = _normalizemeta(meta)
-    return ToArrowTable(
-        Tables.Schema(sch.names, newtypes),
-        newcols,
-        meta,
-        dictencodingdeltas,
+    codec = _codec(compress, compresslevel)
+    batchsize = _checkbatchsize(batchsize)
+    # Check the existing stream's message metadata and dictionaries before
+    # extending it (a stream whose schema or dictionaries are corrupt is
+    # refused); record batch bodies, which an append never uses, are not read.
+    st, msgs = _appendstate(region)
+    sch = st.schema
+    # Retain the schema's declared features when resuming the writer.
+    features = Int64[Int64(x) for x in msgs[1].features]
+    # New messages start where the last framed message ends: over the
+    # end-of-stream marker when the stream has one, else at the end.
+    keep = last(msgs).body.offset + last(msgs).body.len
+    io = IOBuffer()
+    w = _writer(
+        io;
+        file=false,
+        compress,
+        compresslevel,
+        batchsize,
+        dictdeltas,
+        dictreplacement=FEATURE_DICTIONARY_REPLACEMENT in features,
+        ntasks=1,
+    )
+    w.schema = sch
+    w.names = Symbol[_fieldsymbol(f.name) for f in sch.fields]
+    w.appending = true
+    w.st = resumestream!(
+        io,
+        sch,
+        st.fielddictids,
+        features;
+        compress=codec,
+        compresslevel,
+        current=st.dicts,
+        growth=dictdeltas ? :delta : :replace,
     )
+    # Build the tail before touching the destination, using the same
+    # partition ownership and schema rules as an incremental write.
+    _writeall!(w, tbl)
+    return keep, take!(io)
 end
 
-Tables.columns(x::ToArrowTable) = x
-Tables.rowcount(x::ToArrowTable) = length(x.cols) == 0 ? 0 : length(x.cols[1])
-Tables.schema(x::ToArrowTable) = x.sch
-Tables.columnnames(x::ToArrowTable) = x.sch.names
-Tables.getcolumn(x::ToArrowTable, i::Int) = x.cols[i]
+"""
+A stream's state after its last message (schema, dictionaries) and its framed
+messages: every message's metadata is checked and every dictionary batch
+decoded, but record batch bodies are not read.
+"""
+function _appendstate(region::AC.OwnerRegion)
+    limits = Limits()
+    msgs = framemessages(region, limits)
+    isempty(msgs) && throw(ValidationError("empty IPC stream"))
+    st = _StreamState(msgs[1], limits)
+    for fm in Iterators.drop(msgs, 1)
+        _checkstreammessage(st, fm)
+        header = fm.msg.header
+        if header isa Meta.DictionaryBatch
+            budget = _readbudget(limits, fm.body.len)
+            state = DecodeState(budget)
+            try
+                _applydictionary!(st, fm, budget, state)
+            finally
+                close(state)
+            end
+        elseif !(header isa Meta.RecordBatch)
+            throw(ValidationError("unsupported IPC message header $(typeof(header))"))
+        end
+    end
+    return st, msgs
+end
 
-function Base.write(io::IO, msg::Message, blocks, sch, alignment)
-    metalen = padding(length(msg.msgflatbuf), alignment)
-    @debug "writing message: metalen = $metalen, bodylen = $(msg.bodylen), isrecordbatch = $(msg.isrecordbatch), headerType = $(msg.headerType)"
-    if msg.blockmsg
-        push!(
-            blocks[msg.isrecordbatch ? 1 : 2],
-            Block(position(io), metalen + 8, msg.bodylen),
-        )
+# --- dictionaries that grow across tables -----------------------------------
+
+"Each top-level dictionary column's written categories (public values), else nothing."
+function _writtenpools(st::IPCWriteState)
+    ctx = _ArrowTypesContext(; warn=false)
+    return Any[
+        f.type isa AC.DictionaryType ?
+        _retainedsnapshotpool(f, get(st.current, st.ids[f], nothing), ctx) : nothing for
+        f in st.schema.fields
+    ]
+end
+
+function _extendpool(written, own)
+    written === nothing && return own
+    own === nothing && return written
+    T = _widenedtype(eltype(written), eltype(own))
+    return _mergecategorypools(
+        AbstractVector[T === eltype(written) ? written : _collectas(T, written), own],
+    )
+end
+
+"""
+`written` with `delta`'s categories after it. A flat pool without nulls
+(fixed-width values, utf8, binary) grows in place, in buffers that double
+when full, so a table copies only its new categories: the pools written
+before keep their prefixes of the same buffers, which are never resized.
+Other pools are copied whole. Returns the growth state for the next table and
+the pool.
+"""
+function _growpool(vf::AC.Field, written::AC.ArrayData, delta::AC.ArrayData, grown)
+    t = written.type
+    var = t isa Union{AC.Utf8Type,AC.BinaryType}
+    spec = AC.layoutspec_of(t)
+    if !(var || spec.fixedwidth > 0 && spec.buffers == [AC.VALIDITY, AC.DATA]) ||
+       AC.nullcount(written) > 0 ||
+       AC.nullcount(delta) > 0
+        ranges = [
+            _DictionaryRange(written, 0, written.len),
+            _DictionaryRange(delta, 0, delta.len),
+        ]
+        return nothing, _dictionaryconcat(vf, ranges, Limits(), nothing)
+    end
+    if grown === nothing || grown.pool !== written
+        O = var && t.large ? Int64 : Int32
+        grown = _appendpool!(_GrowingPool{O}(written, 0, O[0], UInt8[]), written)
     end
-    # now write the final message spec out
-    # continuation byte
-    n = Base.write(io, CONTINUATION_INDICATOR_BYTES)
-    # metadata length
-    n += Base.write(io, Int32(metalen))
-    # message flatbuffer
-    n += Base.write(io, msg.msgflatbuf)
-    n += writezeros(io, paddinglength(length(msg.msgflatbuf), alignment))
-    # message body
-    if msg.columns !== nothing
-        # write out buffers
-        for col in Tables.Columns(msg.columns)
-            writebuffer(io, col, alignment)
+    return grown, _appendpool!(grown, delta).pool
+end
+
+mutable struct _GrowingPool{O}
+    pool::AC.ArrayData
+    len::Int
+    offsets::Vector{O}
+    data::Vector{UInt8}
+end
+
+# `buf` if it holds `n` more entries after `used`, else a new buffer of twice
+# the size with its first `used` entries.
+function _room(buf::Vector{T}, used::Int, n::Int) where {T}
+    used + n <= length(buf) && return buf
+    out = Vector{T}(undef, max(2 * length(buf), used + n, 64))
+    copyto!(out, 1, buf, 1, used)
+    return out
+end
+
+function _appendpool!(g::_GrowingPool{O}, d::AC.ArrayData) where {O}
+    t = d.type
+    n = Int(d.len)
+    var = t isa Union{AC.Utf8Type,AC.BinaryType}
+    if var
+        wide = t.large
+        used = Int(g.offsets[g.len + 1])
+        lo = n == 0 ? 0 : Int(first(AC._offsets_at(d, Int64(1), wide)))
+        g.offsets = _room(g.offsets, g.len + 1, n)
+        for i = 1:n
+            g.offsets[g.len + 1 + i] =
+                O(used + Int(last(AC._offsets_at(d, Int64(i), wide))) - lo)
         end
+        start, nbytes = lo, Int(g.offsets[g.len + 1 + n]) - used
+    else
+        width = AC.primwidth(t)
+        used = g.len * width
+        start, nbytes = Int(d.offset) * width, n * width
     end
-    return n
-end
-
-function makemessage(b, headerType, header, columns=nothing, bodylen=0)
-    # write the message flatbuffer object
-    Meta.messageStart(b)
-    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
-    Meta.messageAddHeaderType(b, headerType)
-    Meta.messageAddHeader(b, header)
-    Meta.messageAddBodyLength(b, Int64(bodylen))
-    # Meta.messageAddCustomMetadata(b, meta)
-    # Meta.messageStartCustomMetadataVector(b, num_meta_elems)
-    msg = Meta.messageEnd(b)
-    FlatBuffers.finish!(b, msg)
-    return Message(
-        FlatBuffers.finishedbytes(b),
-        columns,
-        bodylen,
-        headerType == Meta.RecordBatch,
-        headerType == Meta.RecordBatch || headerType == Meta.DictionaryBatch,
-        headerType,
+    g.data = _room(g.data, used, nbytes)
+    src = AC.rolebuffer(d, AC.DATA)
+    GC.@preserve d g unsafe_copyto!(
+        pointer(g.data, used + 1),
+        AC.sliceptr(src) + start,
+        nbytes,
     )
+    g.len += n
+    data = AC.BufferSlice(AC.heapregion(g.data), 0, used + nbytes)
+    buffers =
+        var ?
+        [
+            AC.BufferSlice(),
+            AC.BufferSlice(AC.heapregion(g.offsets), 0, (g.len + 1) * sizeof(O)),
+            data,
+        ] : [AC.BufferSlice(), data]
+    # Its parts passed validation when they were built.
+    g.pool = _constructedvalid(AC.ArrayData(t, g.len, buffers; nullcount=0))
+    return g
 end
 
-function makeschema(b, sch::Tables.Schema, columns)
-    # build Field objects
-    names = sch.names
-    N = length(names)
-    fieldoffsets = [fieldoffset(b, names[i], columns.cols[i]) for i = 1:N]
-    Meta.schemaStartFieldsVector(b, N)
-    for off in Iterators.reverse(fieldoffsets)
-        FlatBuffers.prependoffset!(b, off)
-    end
-    fields = FlatBuffers.endvector!(b, N)
-    if columns.metadata !== nothing
-        kvs = columns.metadata
-        kvoffs = Vector{FlatBuffers.UOffsetT}(undef, length(kvs))
-        for (i, (k, v)) in enumerate(kvs)
-            koff = FlatBuffers.createstring!(b, String(k))
-            voff = FlatBuffers.createstring!(b, String(v))
-            Meta.keyValueStart(b)
-            Meta.keyValueAddKey(b, koff)
-            Meta.keyValueAddValue(b, voff)
-            kvoffs[i] = Meta.keyValueEnd(b)
-        end
-        Meta.schemaStartCustomMetadataVector(b, length(kvs))
-        for off in Iterators.reverse(kvoffs)
-            FlatBuffers.prependoffset!(b, off)
+"The 0-based index of each distinct stored category of `pool`."
+function _poolindex(vf::AC.Field, pool::AC.ArrayData)
+    index = Dict{Any,Int64}()
+    for i = 1:(pool.len)
+        get!(index, _storedkey(vf, pool, Int64(i)), Int64(i - 1))
+    end
+    return index
+end
+
+"""
+Delta dictionaries for a batch whose pools extend, value by value, the pools
+already written under their ids (`current`): the new categories as storage,
+by id.
+"""
+function _dictionarydeltas(current, fields, ids, batch::AC.RecordBatch, growth=())
+    deltas = Dict{Int64,AC.ArrayData}()
+    for (f, pool) in dictionarypools(fields, batch.columns)
+        id = ids[f]
+        old = get(current, id, nothing)
+        (old === nothing || old === pool || pool.len <= old.len) && continue
+        haskey(deltas, id) && continue
+        # A pool `_conformdictionary` grew knows its new categories.
+        k = findfirst(g -> g !== nothing && g[1] === pool && g[3] !== nothing, growth)
+        if k !== nothing
+            deltas[id] = growth[k][3]
+            continue
         end
-        meta = FlatBuffers.endvector!(b, length(kvs))
+        vf = AC.dictvaluefield(f, f.type::AC.DictionaryType)
+        _poolrangeequal(vf, old, Int64(0), pool, Int64(0), old.len) || continue
+        deltas[id] = _dictionaryconcat(
+            vf,
+            [_DictionaryRange(pool, old.len, pool.len - old.len)],
+            Limits(),
+            nothing,
+        )
+    end
+    return deltas
+end
+_dictionarydeltas(st::IPCWriteState, batch::AC.RecordBatch, growth=()) =
+    _dictionarydeltas(st.current, st.schema.fields, st.ids, batch, growth)
+
+"""
+A schema field declared nullable, with its descendants, except the children
+the format requires to be non-null (map entries and keys, run ends), also
+under a dictionary, whose children are its values'.
+"""
+function _nullablefield(f::AC.Field)
+    t = f.type
+    vt = t isa AC.DictionaryType ? t.valuetype : t
+    children = if vt isa AC.MapType && length(f.children) == 1
+        entries = only(f.children)
+        kv = entries.children
+        AC.Field[AC.Field(
+            entries.name,
+            entries.type;
+            nullable=false,
+            metadata=entries.metadata,
+            children=AC.Field[kv[1], (_nullablefield(c) for c in kv[2:end])...],
+        )]
+    elseif vt isa AC.RunEndEncodedType && length(f.children) == 2
+        AC.Field[f.children[1], _nullablefield(f.children[2])]
     else
-        meta = FlatBuffers.UOffsetT(0)
+        AC.Field[_nullablefield(c) for c in f.children]
     end
-    # write schema object
-    Meta.schemaStart(b)
-    Meta.schemaAddEndianness(b, Meta.Endianness.Little)
-    Meta.schemaAddFields(b, fields)
-    Meta.schemaAddCustomMetadata(b, meta)
-    return Meta.schemaEnd(b)
+    return AC.Field(f.name, t; nullable=true, metadata=f.metadata, children=children)
 end
 
-function makeschemamsg(sch::Tables.Schema, columns)
-    @debug "building schema message: sch = $sch"
-    b = FlatBuffers.Builder(1024)
-    schema = makeschema(b, sch, columns)
-    return makemessage(b, Meta.Schema, schema)
+# The retained Arrow schema when the source is a facade read, else nothing.
+# Called through `_uninferred` with tables of any type, so the writer's
+# compiled code does not depend on the Stream scan code (methods other
+# packages add there would make it recompile).
+_retainedschema(t::Table) = getfield(t, :schema)
+_retainedschema(s::Stream) =
+    getfield(s, :scan) === nothing ? _tableschema(getfield(s, :src)) :
+    getfield(_schematable(s), :schema)
+_retainedschema(::Any) = nothing
+
+function _writermetadata(metadata, retained, input=nothing)
+    metadata !== nothing && return _metapairs(metadata)
+    retained === nothing && return _uninferred(
+        _inputmetadata,
+        input,
+    )::Union{Nothing,Vector{Pair{String,String}}}
+    retained.metadata === nothing && return nothing
+    # Keep user metadata in order, including duplicate keys.
+    return Pair{String,String}[kv for kv in retained.metadata]
 end
 
-function fieldoffset(b, name, col)
-    nameoff = FlatBuffers.createstring!(b, string(name))
-    T = eltype(col)
-    nullable = T >: Missing
-    # check for custom metadata
-    if getmetadata(col) !== nothing
-        kvs = getmetadata(col)
-        kvoffs = Vector{FlatBuffers.UOffsetT}(undef, length(kvs))
-        for (i, (k, v)) in enumerate(kvs)
-            koff = FlatBuffers.createstring!(b, String(k))
-            voff = FlatBuffers.createstring!(b, String(v))
-            Meta.keyValueStart(b)
-            Meta.keyValueAddKey(b, koff)
-            Meta.keyValueAddValue(b, voff)
-            kvoffs[i] = Meta.keyValueEnd(b)
-        end
-        Meta.fieldStartCustomMetadataVector(b, length(kvs))
-        for off in Iterators.reverse(kvoffs)
-            FlatBuffers.prependoffset!(b, off)
+# A table's DataAPI metadata, as the schema's key-value pairs. Keys under the
+# reserved `ARROW:` prefix (an extension label a column was read with, say)
+# describe the source's encoding, not the table, and are left out.
+Base.@nospecializeinfer function _inputmetadata(@nospecialize(tbl))
+    (tbl === nothing || !DataAPI.metadatasupport(typeof(tbl)).read) && return nothing
+    out = Pair{String,String}[
+        String(string(k)) => string(DataAPI.metadata(tbl, k)) for
+        k in DataAPI.metadatakeys(tbl) if !startswith(string(k), "ARROW:")
+    ]
+    return isempty(out) ? nothing : out
+end
+
+Base.@nospecializeinfer function _inputcolmetadata(@nospecialize(tbl), names)
+    DataAPI.colmetadatasupport(typeof(tbl)).read || return nothing
+    out = Dict{Symbol,Vector{Pair{String,String}}}()
+    for name in names
+        pairs = Pair{String,String}[
+            String(string(k)) => string(DataAPI.colmetadata(tbl, name, k)) for
+            k in DataAPI.colmetadatakeys(tbl, name) if !startswith(string(k), "ARROW:")
+        ]
+        isempty(pairs) || (out[name] = pairs)
+    end
+    return isempty(out) ? nothing : out
+end
+
+"Dictionary pools retained by one facade partition, in column order."
+_partitiondictpools(t::Table) = getfield(t, :retainedpools)
+_partitiondictpools(::Any) = nothing
+
+# One warning per removed-keyword name for the whole session, so a write
+# loop does not flood the log.
+function _warnremovedkwarg(name::Symbol)
+    @warn "Arrow.write keyword `$(name)` was removed in Arrow 3.0 and is " *
+          "ignored; see docs/src/migration.md" _id = Symbol(:arrow_removed_kwarg_, name) maxlog =
+        1
+    return nothing
+end
+
+# Other tools' names for keywords (pyarrow, Polars) and Arrow 2.x's, for
+# the unknown-keyword error.
+const _KEYWORD_HINTS = Dict(
+    :compression => "use `compress`",
+    :compression_level => "use `compresslevel`",
+    :compressionlevel => "use `compresslevel`",
+    :max_chunksize => "use `batchsize`",
+    :chunksize => "use `batchsize`",
+    :columns => "use `select`",
+    :filters => "use `filter`",
+    :n_rows => "use `limit`",
+    :memory_map => "use `mmap`",
+    :use_threads => "use `ntasks`",
+    :convert => "removed in Arrow 3.0, which reads Julia values; see the migration guide",
+)
+
+const _KEYWORDS = Dict(
+    "write" =>
+        "file, compress, compresslevel, batchsize, dictencode, dictdeltas, " *
+        "largelists, stringview, metadata, colmetadata, and ntasks, plus nullable " *
+        "and dictreplacement for Arrow.Writer",
+    "append" => "compress, compresslevel, batchsize, and dictdeltas",
+    "read" => "select, drop, filter, limit, scan, mmap, stringtype, limits, and ntasks",
+)
+
+@noinline function _unknownkeywords(what::String, names)
+    listed = join(
+        (
+            haskey(_KEYWORD_HINTS, name) ? "`$name` ($(_KEYWORD_HINTS[name]))" : "`$name`" for name in names
+        ),
+        ", ",
+    )
+    throw(
+        ArgumentError(
+            "unknown $what keyword$(length(names) == 1 ? "" : "s") $listed. " *
+            "The keywords are $(_KEYWORDS[what])",
+        ),
+    )
+end
+
+"The bytes `Arrow.write` writes for `tbl`."
+_writebytes(tbl; kwargs...) = take!(write(IOBuffer(), tbl; kwargs...))
+
+"Rows per record batch when `batchsize` is not given: 1,048,576 (as pyarrow's chunks)."
+const DEFAULT_BATCHSIZE = 1 << 20
+
+function _checkbatchsize(batchsize::Integer)
+    batchsize >= 1 || throw(ArgumentError("batchsize must be at least 1, got $batchsize"))
+    return Int(batchsize)
+end
+
+function _codec(compress, compresslevel)
+    codec = compress === nothing ? :none : compress
+    codec isa Symbol && haskey(CODEC_NAMES, codec) || throw(
+        ArgumentError(
+            "compress must be nothing, :lz4, or :zstd, got $(repr(compress))" * (
+                compress isa Symbol ? "" :
+                "; Arrow 2.x took a compressor object, Arrow 3.0 takes the codec's name"
+            ),
+        ),
+    )
+    compresslevel === nothing ||
+        codec !== :none ||
+        throw(ArgumentError("compresslevel needs compress=:lz4 or compress=:zstd"))
+    return codec
+end
+
+# Which top-level columns `dictencode` asks to encode beyond the pooled ones:
+# all (`true`), none (`nothing`, `false`), or those named (Symbols or Strings).
+function _dictencodeflags(names::Vector{Symbol}, dictencode)
+    dictencode === nothing && return fill(false, length(names))
+    dictencode isa Bool && return fill(dictencode, length(names))
+    dictencode isa Union{Symbol,AbstractString} && (dictencode = (dictencode,))
+    wanted = Set{Symbol}(Symbol(n) for n in dictencode)
+    for n in wanted
+        n in names || throw(
+            ArgumentError("dictencode names column $n, which the table does not have"),
+        )
+    end
+    return Bool[n in wanted for n in names]
+end
+
+# Cut a batch before the overflowing row (in half when a nested row is unknown).
+function _smallerbatch(n::Int, err::_OffsetOverflow)
+    hint = "write it with largelists=true, which declares 64-bit offsets"
+    err.part > 0 || throw(
+        ArgumentError(
+            "column $(err.column) holds more than 2 GiB of data that cannot be split " *
+            "across record batches (a dictionary pool, say); $hint",
+        ),
+    )
+    (n <= 1 || err.row == 1) &&
+        throw(ArgumentError("column $(err.column) has a value of more than 2 GiB; $hint"))
+    return err.row > 1 ? err.row - 1 : cld(n, 2)
+end
+
+# Rows `r` (1-based positions) of a column, without copying when it can.
+function _rowslice(@nospecialize(col::AbstractVector), r::UnitRange{Int})
+    length(r) == length(col) && return col
+    return _rowview(col, (firstindex(col) - 1) .+ r)
+end
+_rowview(@nospecialize(col::AbstractVector), r) = view(col, r)
+_rowview(col::DictEncode, r) = DictEncode(_rowslice(col.data, r .- (firstindex(col) - 1)))
+# A record batch that is exactly one of a chained column's arrays (one batch it
+# was read from, say) is that array.
+function _rowview(@nospecialize(col::ChainedVector), r)
+    start = 1
+    for a in col.arrays
+        start > first(r) && break
+        stop = start + length(a) - 1
+        start == first(r) && stop == last(r) && eltype(a) === eltype(col) && return a
+        start = stop + 1
+    end
+    return view(col, r)
+end
+
+"""
+Fields for a source with no partitions. A zero-batch `Arrow.Stream` still
+carries its retained schema, so the output keeps that schema and has no
+record batches; any other partition-free source has no schema to write.
+"""
+function _schemaonly(retained, colmetadata)
+    retained === nothing &&
+        throw(ArgumentError("table has no partitions; cannot infer a schema"))
+    # Match colmetadata by name without interning the source's field names.
+    colmetamap =
+        colmetadata === nothing ? nothing :
+        _uninferred(Dict, (String(k)::String => v for (k, v) in Dict(colmetadata)))
+    fields = AC.Field[]
+    for f in retained.fields
+        meta =
+            colmetamap === nothing ? nothing : _metapairs(get(colmetamap, f.name, nothing))
+        push!(fields, meta === nothing ? f : _withfieldmetadata(f, meta))
+    end
+    return fields
+end
+
+# Position is the only unambiguous identity for a retained field, because
+# Arrow permits duplicate names. Fall back to a name match only when the
+# name is unique on both sides; otherwise treat the column as un-retained.
+function _retainedfieldfn(retained, names, encoded=nothing)
+    ncols = length(names)
+    retainedaligned =
+        retained !== nothing &&
+        length(retained.fields) == ncols &&
+        all(j -> retained.fields[j].name == String(names[j]), 1:ncols)
+    function retainedfield(j)
+        retained === nothing && return nothing
+        f = _retainedfieldat(retained, names, retainedaligned, j)
+        # A column `dictencode` encodes gets a fresh dictionary field.
+        f === nothing ||
+            encoded === nothing ||
+            !encoded[j] ||
+            f.type isa AC.DictionaryType ||
+            return nothing
+        return f
+    end
+    return retainedfield
+end
+
+function _retainedfieldat(retained, names, retainedaligned::Bool, j::Int)
+    retainedaligned && return _unsharedfield(retained.fields[j])
+    count(==(names[j]), names) == 1 || return nothing
+    name = String(names[j])::String
+    matches = findall(f -> f.name == name, collect(retained.fields))
+    return length(matches) == 1 ? _unsharedfield(retained.fields[only(matches)]) : nothing
+end
+
+# The written schema needs one Field object per position (dictionary ids key
+# on Field identity), but a retained schema can share child subtrees between
+# positions, as a scan that selects one column twice does.
+_unsharedfield(f::AC.Field) = AC.Field(
+    f.name,
+    f.type;
+    nullable=f.nullable,
+    metadata=f.metadata,
+    children=AC.Field[_unsharedfield(c) for c in f.children],
+)
+
+# Phase 2: construct each column of the batch. The column module owns
+# inference, retained reconstruction, ArrowTypes, dictionary pooling, and
+# field metadata.
+function _constructcolumns(
+    names,
+    cols,
+    hints,
+    retainedfield::F,
+    colmetadata;
+    refpools::Bool=true,
+    stringview::Bool=false,
+    largelists::Bool=false,
+    growable::Bool=false,
+    ntasks::Int=1,
+    pool=nothing,
+) where {F}
+    colmetamap = _colmetadatamap(colmetadata, names)
+    built = _tasksmap(length(names), ntasks) do j, _
+        columnmeta = colmetamap === nothing ? nothing : get(colmetamap, names[j], nothing)
+        return _uninferred(
+            _constructcolumn,
+            names[j],
+            cols[j];
+            retained=retainedfield(j),
+            poolhint=hints[j],
+            metadata=_metapairs(columnmeta),
+            refpools=refpools,
+            stringview=stringview,
+            largelists=largelists,
+            growable=growable,
+            pool,
+        )::Tuple{AC.Field,AC.ArrayData}
+    end
+    return AC.Field[first(b) for b in built], AC.ArrayData[last(b) for b in built]
+end
+
+# Columns build in parallel when a batch holds enough values for the tasks to
+# pay for themselves (writing many small tables stays on one task).
+const _PARALLEL_CELLS = 1 << 16
+_batchtasks(w::Writer, nrows::Int, ncols::Int) =
+    nrows * ncols >= _PARALLEL_CELLS ? w.ntasks : 1
+
+# Construct the columns of a table that must conform to an existing schema:
+# a later `Arrow.Writer` table or an `Arrow.append` table. A facade source
+# (`Arrow.Table`, `Arrow.Stream`) holds public values, which the retained
+# construction lowers. Any other source holds writer values (`DateTime`,
+# `NamedTuple` rows, tuples, `Dict`s, any `AbstractString`): build each such
+# column the way the first batch was built and use it when it conforms to
+# the schema field. A dictionary column built that way is re-indexed into
+# `written[j]`, the pool its field last wrote (storage; `nothing` starts a
+# replacement pool). Columns that cannot be built that way, such as one
+# whose own mapping differs from the field, take the retained construction.
+Base.@nospecializeinfer function _constructconforming(
+    names,
+    cols,
+    hints,
+    sch::AC.Schema,
+    @nospecialize(tbl);
+    stringview::Bool=false,
+    largelists::Bool=false,
+    written=nothing,
+    growth=nothing,
+    ntasks::Int=1,
+    pool=nothing,
+    nullhint::String="",
+)
+    retainedfield = j -> sch.fields[j]
+    _uninferred(_retainedschema, tbl) === nothing ||
+        return _constructcolumns(names, cols, hints, retainedfield, nothing; ntasks, pool)
+    built = _tasksmap(length(names), ntasks) do j, _
+        w = written === nothing ? nothing : written[j]
+        return _uninferred(
+            _conformcolumn,
+            names[j],
+            cols[j],
+            hints[j],
+            sch.fields[j],
+            w;
+            stringview,
+            largelists,
+            pool,
+            growth=growth === nothing ? nothing : (growth, j),
+            nullhint,
+        )::Tuple{AC.Field,AC.ArrayData}
+    end
+    return AC.Field[first(b) for b in built], AC.ArrayData[last(b) for b in built]
+end
+
+"One column of `_constructconforming`: its field and its data."
+function _conformcolumn(
+    name::Symbol,
+    col,
+    poolhint,
+    expected::AC.Field,
+    written;
+    stringview::Bool,
+    largelists::Bool,
+    pool=nothing,
+    growth=nothing,
+    nullhint::String="",
+)
+    dictmismatch = nothing
+    if expected.type isa AC.DictionaryType && written !== nothing
+        conformed, dictmismatch =
+            _uninferred(_conformdictionary, name, col, expected, written; growth)
+        conformed === nothing || return conformed
+    end
+    if _holdsnull(expected) &&
+       !(expected.type isa AC.DictionaryType) &&
+       _eltypeof(col) === Missing
+        # An all-missing column is all nulls of the field's type.
+        context = _WriterContext(String(name))
+        return expected, last(_constructhiddenpart(expected, length(col), context))
+    end
+    fresh =
+        expected.type isa AC.DictionaryType ? nothing :
+        _freshcolumn(name, col; stringview, largelists, pool)
+    mismatch =
+        fresh === nothing ? dictmismatch : _conformancemismatch(expected, first(fresh))
+    if fresh !== nothing && mismatch !== nothing
+        # Missing values conform wherever the field is nullable, nested too.
+        fresh = _fillnulls(expected, fresh..., _WriterContext(String(name)))
+        mismatch = _conformancemismatch(expected, first(fresh))
+    end
+    if fresh !== nothing && mismatch !== nothing
+        # Numbers widen losslessly into the field's type (Int32 into Int64).
+        widened = _uninferred(_widenparts, expected, col)
+        if widened !== nothing
+            fresh = _freshcolumn(name, widened; stringview, largelists, pool)
+            fresh === nothing ||
+                _conformancemismatch(expected, first(fresh)) !== nothing ||
+                (mismatch = nothing)
         end
-        meta = FlatBuffers.endvector!(b, length(kvs))
-    else
-        meta = FlatBuffers.UOffsetT(0)
-    end
-    # build dictionary
-    if isdictencoded(col)
-        encodingtype = indtype(col)
-        IT, inttype, _ = arrowtype(b, encodingtype)
-        Meta.dictionaryEncodingStart(b)
-        Meta.dictionaryEncodingAddId(b, Int64(getid(col)))
-        Meta.dictionaryEncodingAddIndexType(b, inttype)
-        # TODO: support isOrdered?
-        Meta.dictionaryEncodingAddIsOrdered(b, false)
-        dict = Meta.dictionaryEncodingEnd(b)
-    else
-        dict = FlatBuffers.UOffsetT(0)
     end
-    type, typeoff, children = arrowtype(b, col)
-    if children !== nothing
-        Meta.fieldStartChildrenVector(b, length(children))
-        for off in Iterators.reverse(children)
-            FlatBuffers.prependoffset!(b, off)
+    fresh !== nothing && mismatch === nothing && return expected, last(fresh)
+    try
+        return _constructcolumn(name, col; retained=expected, poolhint, pool)
+    catch err
+        # Report the schema difference of a column the writer mapping could
+        # build instead of the retained construction's value-domain error.
+        (err isa ArgumentError && mismatch !== nothing) || rethrow()
+        # The hint, only when the column conforms to its field declared nullable.
+        hint = try
+            isempty(nullhint) || _conformcolumn(
+                name,
+                col,
+                poolhint,
+                _nullablefield(expected),
+                written;
+                stringview,
+                largelists,
+            )
+            nullhint
+        catch trial
+            trial isa ArgumentError || rethrow()
+            ""
         end
-        children = FlatBuffers.endvector!(b, length(children))
-    else
-        Meta.fieldStartChildrenVector(b, 0)
-        children = FlatBuffers.endvector!(b, 0)
+        T = Base.nonmissingtype(_eltypeof(col))
+        values = T === Union{} ? "" : " of $T values"
+        throw(
+            ArgumentError(
+                "column $name$values does not conform to the existing schema: " *
+                "$mismatch. The first table written fixed each column's type and " *
+                "nullability: convert the column to the schema's type$hint",
+            ),
+        )
     end
-    # build field object
-    if isdictencoded(col)
-        @debug "building field: name = $name, nullable = $nullable, T = $T, type = $type, inttype = $IT, dictionary id = $(getid(col))"
-    else
-        @debug "building field: name = $name, nullable = $nullable, T = $T, type = $type"
-    end
-    Meta.fieldStart(b)
-    Meta.fieldAddName(b, nameoff)
-    Meta.fieldAddNullable(b, nullable)
-    Meta.fieldAddTypeType(b, type)
-    Meta.fieldAddType(b, typeoff)
-    Meta.fieldAddDictionary(b, dict)
-    Meta.fieldAddChildren(b, children)
-    Meta.fieldAddCustomMetadata(b, meta)
-    return Meta.fieldEnd(b)
-end
-
-struct FieldNode
-    length::Int64
-    null_count::Int64
-end
-
-struct Buffer
-    offset::Int64
-    length::Int64
-end
-
-function makerecordbatchmsg(
-    sch::Tables.Schema{names,types},
-    columns,
-    alignment,
-) where {names,types}
-    b = FlatBuffers.Builder(1024)
-    recordbatch, bodylen = makerecordbatch(b, sch, columns, alignment)
-    return makemessage(b, Meta.RecordBatch, recordbatch, columns, bodylen)
-end
-
-function makerecordbatch(
-    b,
-    sch::Tables.Schema{names,types},
-    columns,
-    alignment,
-) where {names,types}
-    nrows = Tables.rowcount(columns)
-
-    compress = nothing
-    fieldnodes = FieldNode[]
-    fieldbuffers = Buffer[]
-    bufferoffset = 0
-    for col in Tables.Columns(columns)
-        if col isa Compressed
-            compress = compressiontype(col)
+end
+
+"""
+A later table's dictionary column built the way the first table's was (as its
+own dictionary, with the large offsets or views of the field's values), then
+re-indexed into `written`, the categories its field already wrote (storage;
+`nothing` for a replacement pool): those keep their order and new categories
+follow, so the column refers to the extended pool.
+Returns the field and data, or `nothing` and why the column does not conform
+(`nothing` too when the values do not build as a dictionary at all).
+"""
+function _conformdictionary(name::Symbol, col, expected::AC.Field, written; growth=nothing)
+    context = _WriterContext(String(name))
+    et = expected.type::AC.DictionaryType
+    vf = AC.dictvaluefield(expected, et)
+    # The stream may have been started by another writer (an append's), so
+    # the field, not this writer, says how its values are laid out.
+    stringview = _anytype(t -> t isa AC.ViewType, vf)
+    largelists = _anytype(
+        t ->
+            t isa Union{AC.Utf8Type,AC.BinaryType,AC.ListType,AC.ListViewType} && t.large,
+        vf,
+    )
+    written === nothing && (written = last(_constructhiddenpart(vf, 0, context)))
+    if _eltypeof(col) === Missing
+        expected.nullable || return nothing, nothing
+        return (expected, _nulldictionary(et, length(col), written)), nothing
+    end
+    dictcol = col isa DictEncode || _hasrefpool(col) ? col : DictEncode(col)
+    fresh = try
+        _constructcolumn(name, dictcol; stringview, largelists)
+    catch err
+        err isa ArgumentError || rethrow()
+        return nothing, nothing
+    end
+    field, data = fresh
+    ft = field.type
+    ft isa AC.DictionaryType || return nothing, nothing
+    localvf = AC.dictvaluefield(field, ft)
+    mismatch = _conformancemismatch(vf, localvf)
+    mismatch === nothing || return nothing, mismatch
+    # A dictionary's extension label sits on the dictionary field itself.
+    _arrowtypesextension(expected) == _arrowtypesextension(field) ||
+        return nothing, "$name has a different extension type than the schema field"
+    !expected.nullable &&
+        AC.nullcount(data) > 0 &&
+        return nothing, "$name holds missing values, but the schema field is not nullable"
+    localpool = data.dictionary::AC.ArrayData
+    # The written categories keep their indices; the local ones not among
+    # them follow. The written pool's index stays on the writer (`growth`),
+    # so a table costs its own categories, not the pool's.
+    slots, j = something(growth, (Any[nothing], 1))
+    cached = slots[j]
+    index =
+        cached !== nothing && cached[1] === written ? cached[2] : _poolindex(vf, written)
+    new = Int[]
+    remap = Vector{Int64}(undef, localpool.len)
+    for i = 1:(localpool.len)
+        remap[i] = get!(index, _storedkey(localvf, localpool, Int64(i))) do
+            push!(new, i)
+            return Int64(written.len + length(new) - 1)
         end
-        bufferoffset =
-            makenodesbuffers!(col, fieldnodes, fieldbuffers, bufferoffset, alignment)
-    end
-    @debug "building record batch message: nrows = $nrows, sch = $sch, compress = $compress"
-
-    # write field nodes objects
-    FN = length(fieldnodes)
-    Meta.recordBatchStartNodesVector(b, FN)
-    for fn in Iterators.reverse(fieldnodes)
-        Meta.createFieldNode(b, fn.length, fn.null_count)
-    end
-    nodes = FlatBuffers.endvector!(b, FN)
-
-    # write buffer objects
-    bodylen = 0
-    BN = length(fieldbuffers)
-    Meta.recordBatchStartBuffersVector(b, BN)
-    for buf in Iterators.reverse(fieldbuffers)
-        Meta.createBuffer(b, buf.offset, buf.length)
-        bodylen += padding(buf.length, alignment)
-    end
-    buffers = FlatBuffers.endvector!(b, BN)
-
-    # compression
-    if compress !== nothing
-        Meta.bodyCompressionStart(b)
-        Meta.bodyCompressionAddCodec(b, compress)
-        Meta.bodyCompressionAddMethod(b, Meta.BodyCompressionMethod.BUFFER)
-        compression = Meta.bodyCompressionEnd(b)
-    else
-        compression = FlatBuffers.UOffsetT(0)
-    end
-
-    # write record batch object
-    @debug "built record batch message: nrows = $nrows, nodes = $fieldnodes, buffers = $fieldbuffers, compress = $compress, bodylen = $bodylen"
-    Meta.recordBatchStart(b)
-    Meta.recordBatchAddLength(b, Int64(nrows))
-    Meta.recordBatchAddNodes(b, nodes)
-    Meta.recordBatchAddBuffers(b, buffers)
-    Meta.recordBatchAddCompression(b, compression)
-    return Meta.recordBatchEnd(b), bodylen
-end
-
-function makedictionarybatchmsg(sch, columns, id, isdelta, alignment)
-    @debug "building dictionary message: id = $id, sch = $sch, isdelta = $isdelta"
-    b = FlatBuffers.Builder(1024)
-    recordbatch, bodylen = makerecordbatch(b, sch, columns, alignment)
-    Meta.dictionaryBatchStart(b)
-    Meta.dictionaryBatchAddId(b, Int64(id))
-    Meta.dictionaryBatchAddData(b, recordbatch)
-    Meta.dictionaryBatchAddIsDelta(b, isdelta)
-    dictionarybatch = Meta.dictionaryBatchEnd(b)
-    return makemessage(b, Meta.DictionaryBatch, dictionarybatch, columns, bodylen)
+    end
+    delta = isempty(new) ? nothing : _takerows(localvf, localpool, new)
+    grown = cached === nothing ? nothing : cached[4]
+    grown, pool =
+        delta === nothing ? (grown, written) : _growpool(vf, written, delta, grown)
+    slots[j] = (pool, index, delta, grown)
+    IT = AC.juliatype(et.indextype)
+    pool.len - 1 <= typemax(IT) || throw(
+        ArgumentError(
+            "column $name has $(pool.len) dictionary categories, more than " *
+            "its $IT indices address",
+        ),
+    )
+    # The index types are known at run time; see `_uninferred`.
+    LT = AC.juliatype((data.type::AC.DictionaryType).indextype)
+    reindexed = _uninferred(_reindexdictionary, data, et, IT, LT, remap, pool)
+    return (expected, reindexed), nothing
+end
+
+# Whether field `f` or a descendant has a type that `pred` accepts.
+_anytype(pred, f::AC.Field) = pred(f.type) || any(c -> _anytype(pred, c), f.children)
+
+"`n` null slots of dictionary type `t` that refer to `pool`."
+function _nulldictionary(t::AC.DictionaryType, n::Int, pool::AC.ArrayData)
+    IT = AC.juliatype(t.indextype)
+    validity = n == 0 ? AC.BufferSlice() : AC._databuffer(zeros(UInt8, cld(n, 8)))
+    return AC.ArrayData(
+        t,
+        n,
+        # `IT` is known at run time; see `_uninferred`.
+        [validity, _uninferred(AC._databuffer, zeros(IT, n))::AC.BufferSlice];
+        dictionary=pool,
+        nullcount=n,
+    )
+end
+
+# A dictionary part's `LT` indices mapped through `remap` into index type
+# `IT`, referring to `pool`.
+function _reindexdictionary(
+    d::AC.ArrayData,
+    t,
+    ::Type{IT},
+    ::Type{LT},
+    remap::Vector{Int64},
+    pool,
+) where {IT,LT}
+    validity = d.buffers[1]
+    codes = reinterpret(LT, AC.slicebytes(d.buffers[2]))
+    out = Vector{IT}(undef, d.len)
+    for i = 1:(d.len)
+        valid = AC.isempty_buffer(validity) || AC.getbit(validity, Int64(i - 1))
+        out[i] = valid ? IT(remap[Int(codes[i]) + 1]) : zero(IT)
+    end
+    return AC.ArrayData(
+        t,
+        d.len,
+        [validity, AC._databuffer(out)];
+        dictionary=pool,
+        nullcount=AC.nullcount(d),
+    )
+end
+
+"""
+A fresh column (field and data) whose all-missing values inferred the null
+type where `expected` (or a descendant) is a nullable typed field: those
+values become null slots of the expected type. Anything else is unchanged.
+"""
+function _fillnulls(expected::AC.Field, actual::AC.Field, d::AC.ArrayData, context)
+    # A labelled Null column (`nothing`s) holds values, not nulls.
+    if actual.type isa AC.NullType && _holdsnull(actual)
+        (expected.type isa AC.NullType || !_holdsnull(expected)) && return actual, d
+        return _constructhiddenpart(expected, Int(d.len), context)
+    end
+    n = length(actual.children)
+    (
+        actual.type isa AC.DictionaryType ||
+        n != length(expected.children) ||
+        n != length(d.children)
+    ) && return actual, d
+    fields = collect(AC.Field, actual.children)
+    children = collect(AC.ArrayData, d.children)
+    for i = 1:n
+        fields[i], children[i] =
+            _fillnulls(expected.children[i], fields[i], children[i], context)
+    end
+    all(i -> fields[i] === actual.children[i], 1:n) && return actual, d
+    return AC.Field(
+        actual.name,
+        actual.type;
+        nullable=actual.nullable,
+        metadata=_fieldmetadata(actual),
+        children=fields,
+    ),
+    AC.ArrayData(
+        d.type,
+        d.len,
+        d.buffers;
+        offset=d.offset,
+        children,
+        dictionary=d.dictionary,
+        nullcount=AC.nullcount(d),
+    )
+end
+
+"""
+A later table's number column converted to a schema field's wider number
+type, when every value converts exactly (`Int32` into `Int64`, `Float32` into
+`Float64`, `Int32` into `Float64`); nothing otherwise.
+"""
+function _widenparts(expected::AC.Field, p)
+    t = expected.type
+    t isa Union{AC.IntType,AC.FloatType} || return nothing
+    T = AC.juliatype(t)
+    S = Base.nonmissingtype(eltype(p))
+    S === T && return p
+    S === Union{} || _widens(S, T) || return nothing
+    return Missing <: eltype(p) ? convert(Vector{Union{Missing,T}}, p) :
+           convert(Vector{T}, p)
+end
+_widens(::Type{S}, ::Type{T}) where {S<:Integer,T<:Integer} =
+    S !== Bool && typemin(T) <= typemin(S) && typemax(S) <= typemax(T)
+_widens(::Type{S}, ::Type{T}) where {S<:AbstractFloat,T<:AbstractFloat} =
+    sizeof(S) <= sizeof(T)
+_widens(::Type{S}, ::Type{T}) where {S<:Integer,T<:AbstractFloat} =
+    S !== Bool && 8 * sizeof(S) < precision(T)
+_widens(::Type, ::Type) = false
+
+function _freshcolumn(
+    name::Symbol,
+    col;
+    stringview::Bool=false,
+    largelists::Bool=false,
+    pool=nothing,
+)
+    try
+        return _constructcolumn(name, col; refpools=false, stringview, largelists, pool)
+    catch err
+        # The retained construction reports why this column cannot be written.
+        err isa ArgumentError || rethrow()
+        return nothing
+    end
+end
+
+# A schema field's Arrow type, and for a leaf the Julia type it reads as.
+function _typename(f::AC.Field)
+    isempty(f.children) || return _typename(f.type)
+    return "$(_typename(f.type)) (reads as $(Base.nonmissingtype(_declaredeltype(f))))"
+end
+
+"An Arrow type's name for messages, as pyarrow spells it."
+function _typename(t::AC.ArrowType)
+    unit(u) =
+        u == AC.SECOND ? "s" :
+        u == AC.MILLISECOND ? "ms" : u == AC.MICROSECOND ? "us" : "ns"
+    t isa AC.IntType && return (t.signed ? "int" : "uint") * string(t.bits)
+    t isa AC.FloatType &&
+        return t.bits == 16 ? "halffloat" : t.bits == 32 ? "float" : "double"
+    t isa AC.BoolType && return "bool"
+    t isa AC.Utf8Type && return t.large ? "large_string" : "string"
+    t isa AC.BinaryType && return t.large ? "large_binary" : "binary"
+    t isa AC.ViewType && return t.utf8 ? "string_view" : "binary_view"
+    t isa AC.FixedSizeBinaryType && return "fixed_size_binary[$(t.nbytes)]"
+    t isa AC.DateType && return t.unit == AC.DAY ? "date32" : "date64"
+    t isa AC.TimeType && return "time$(t.bits)[$(unit(t.unit))]"
+    t isa AC.TimestampType &&
+        return "timestamp[$(unit(t.unit))$(t.timezone === nothing ? "" : ", tz=$(t.timezone)")]"
+    t isa AC.DurationType && return "duration[$(unit(t.unit))]"
+    t isa AC.DecimalType && return "decimal$(t.bits)($(t.precision), $(t.scale))"
+    t isa AC.IntervalType && return "interval"
+    t isa AC.ListType && return t.large ? "large_list" : "list"
+    t isa AC.ListViewType && return t.large ? "large_list_view" : "list_view"
+    t isa AC.FixedSizeListType && return "fixed_size_list[$(t.listsize)]"
+    t isa AC.StructType && return "struct"
+    t isa AC.MapType && return "map"
+    t isa AC.UnionType && return "union"
+    t isa AC.DictionaryType && return "dictionary<$(_typename(t.valuetype))>"
+    t isa AC.RunEndEncodedType && return "run_end_encoded"
+    t isa AC.NullType && return "null (all missing)"
+    return String(AC.descriptorname(t))
+end
+
+"""
+Why data built for `actual` is not valid under `expected`, or `nothing`. Valid
+data has equal descriptors, child names, and extension types at every level,
+with nullability only widened. Nested metadata must match; the top-level user
+metadata is `expected`'s. `exact` asks for equal fields instead: nullability
+and metadata equal at every level.
+"""
+function _conformancemismatch(
+    expected::AC.Field,
+    actual::AC.Field;
+    path::String=expected.name,
+    top::Bool=true,
+    exact::Bool=false,
+)
+    expected.name == actual.name || return "$path is named $(repr(actual.name))"
+    if !AC.typeequal(expected.type, actual.type)
+        actual.type isa AC.NullType &&
+            !_holdsnull(actual) &&
+            return "$path writes as null labelled " *
+                   "$(first(_arrowtypesextension(actual))), not as missing values, but " *
+                   "the schema has $(_typename(expected))"
+        expected.type isa AC.NullType &&
+            return "$path writes as $(_typename(actual.type)), but the schema " *
+                   "declared it null because it held only missing values (or no " *
+                   "rows) when the schema was set; give it a concrete element type"
+        expected.type isa AC.UnionType &&
+            actual.type isa Union{AC.UnionType,AC.NullType} &&
+            _holdsnull(actual) &&
+            !_holdsnull(expected) &&
+            return "$path holds missing values, but no child of the schema's union " *
+                   "holds a null (a union column whose element type includes Missing " *
+                   "declares one)"
+        expected.type isa AC.UnionType &&
+            actual.type isa AC.UnionType &&
+            return "$path writes as a union with other members than the schema's union"
+        actual.type isa AC.NullType &&
+            !expected.nullable &&
+            return "$path holds only missing values, but the schema field is not nullable"
+        return "$path writes as $(_typename(actual.type)), but the schema has " *
+               _typename(expected)
+    end
+    actual.nullable &&
+        !expected.nullable &&
+        return "$path holds missing values, but the schema field is not nullable"
+    exact && expected.nullable && !actual.nullable && return "$path is not nullable"
+    _arrowtypesextension(expected) == _arrowtypesextension(actual) ||
+        return "$path has a different extension type than the schema field"
+    (top && !exact) ||
+        something(_fieldmetadata(expected), Pair{String,String}[]) ==
+        something(_fieldmetadata(actual), Pair{String,String}[]) ||
+        return "$path has different field metadata than the schema"
+    length(expected.children) == length(actual.children) ||
+        return "$path has $(length(actual.children)) children where the schema has " *
+               "$(length(expected.children))"
+    for i in eachindex(expected.children)
+        child = expected.children[i]
+        mismatch = _conformancemismatch(
+            child,
+            actual.children[i];
+            path="$path.$(child.name)",
+            top=false,
+            exact,
+        )
+        mismatch === nothing || return mismatch
+    end
+    return nothing
+end
+
+_metapairs(::Nothing) = nothing
+function _metapairs(m)
+    # A dict iterates as its pairs (`pairs` of one has a single method, which
+    # other packages specialize, so a call here would make this recompile).
+    entries = m isa NamedTuple ? Base.pairs(m) : m
+    out = Pair{String,String}[]
+    for kv in entries
+        kv isa Pair || throw(ArgumentError("metadata sequences must contain Pair values"))
+        # Keys and values that are not strings are written as they print, as
+        # DataAPI metadata is.
+        push!(out, _metastring(first(kv))::String => _metastring(last(kv))::String)
+    end
+    return out
+end
+_metastring(x::AbstractString) = String(x)
+_metastring(x) = string(x)
+
+# `colmetadata` keyed by column `Symbol`, given by `Symbol` or string; a name
+# that is not a column is an error, as in `dictencode`.
+function _colmetadatamap(colmetadata, names)
+    colmetadata === nothing && return nothing
+    out = Dict{Symbol,Any}()
+    for kv in (colmetadata isa NamedTuple ? Base.pairs(colmetadata) : colmetadata)
+        kv isa Pair ||
+            throw(ArgumentError("colmetadata must map column names to key-value pairs"))
+        name = Symbol(first(kv))
+        name in names || throw(
+            ArgumentError("colmetadata names column $name, which the table does not have"),
+        )
+        out[name] = last(kv)
+    end
+    return out
 end
diff --git a/test/Project.toml b/test/Project.toml
index c2e02aa8..bc7632c4 100644
--- a/test/Project.toml
+++ b/test/Project.toml
@@ -15,37 +15,43 @@
 # limitations under the License.
 
 [deps]
+Serialization = "9e88b42a-f829-5b0c-bbe9-9e923198166b"
+DataDecimals = "3e2245cb-6932-498d-a7cf-39d39de8bde3"
+Durations = "41ac09f5-0a95-4810-aa18-c88bf48ee130"
+Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"
 ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd"
 CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597"
+CloudBaseTest = "40fa5d0e-b06b-47c4-9127-3a501b82bf72"
+CloudStore = "3365d9ee-d53b-4a56-812d-5344d5b716d7"
+CodecZlib = "944b1d66-785c-5afd-91f1-9de20f533193"
 DataAPI = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a"
-DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
+DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
+DataStrings = "48204bd6-5611-42ea-b167-fc1d713f9be2"
+FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549"
 FilePathsBase = "48062228-2e41-5def-b9a4-89aafe57970f"
-JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1"
-Mmap = "a63ad114-7e13-5084-954f-fe012c677804"
-OffsetArrays = "6fe1bfb0-de20-5000-8ca7-80f57d26f881"
+InlineStrings = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48"
+Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 PooledArrays = "2dfb63ee-cc39-5dd5-95bd-886bf059d720"
+Profile = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79"
+JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
+Logging = "56ddb016-857b-54e1-b83d-db4d58db5568"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
-Sockets = "6462fe0b-24de-5631-8697-dd941f90decc"
-StructTypes = "856f2bd8-1eba-4b0a-8007-ebc267875bd4"
-SentinelArrays = "91c51154-3ec4-41a3-a24f-3f23e20d615c"
 Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c"
-TimeZones = "f269a46b-ccf7-5d73-abea-4c690281aa53"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
-TestSetExtensions = "98d24dd4-01ad-11ea-1b02-c9a08f80db04"
+TimeZones = "f269a46b-ccf7-5d73-abea-4c690281aa53"
 UUIDs = "cf7118a7-6976-5b1a-9a39-7adc72f591a4"
 
 [compat]
-ArrowTypes = "2.3"
-CategoricalArrays = "1"
-DataAPI = "1"
+CategoricalArrays = "0.10, 1"
+CloudBaseTest = "1"
+DataDecimals = "1"
 DataFrames = "1"
+DataStrings = "1"
+Durations = "1.4"
+FileIO = "1.16"
 FilePathsBase = "0.9"
-JSON3 = "1"
-OffsetArrays = "1"
-PooledArrays = "1"
-StructTypes = "1"
-SentinelArrays = "1"
-Tables = "1"
-TestSetExtensions = "3"
+InlineStrings = "1, 2"
+Aqua = "0.8"
+ArrowTypes = "2.4"
 TimeZones = "1"
diff --git a/test/arrowjson.jl b/test/arrowjson.jl
deleted file mode 100644
index 1d0bb2f8..00000000
--- a/test/arrowjson.jl
+++ /dev/null
@@ -1,737 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-module ArrowJSON
-
-using Mmap
-using StructTypes, JSON3, Tables, SentinelArrays, Arrow
-
-# read json files as "table"
-# write to arrow stream/file
-# read arrow stream/file back
-
-abstract type Type end
-Type() = Null("null")
-StructTypes.StructType(::Base.Type{Type}) = StructTypes.AbstractType()
-
-children(::Base.Type{T}) where {T} = Field[]
-
-mutable struct Int <: Type
-    name::String
-    bitWidth::Int64
-    isSigned::Base.Bool
-end
-
-Int() = Int("", 0, true)
-Type(::Base.Type{T}) where {T<:Integer} = Int("int", 8 * sizeof(T), T <: Signed)
-StructTypes.StructType(::Base.Type{Int}) = StructTypes.Mutable()
-function juliatype(f, x::Int)
-    T =
-        x.bitWidth == 8 ? Int8 :
-        x.bitWidth == 16 ? Int16 :
-        x.bitWidth == 32 ? Int32 : x.bitWidth == 64 ? Int64 : Int128
-    return x.isSigned ? T : unsigned(T)
-end
-
-struct FloatingPoint <: Type
-    name::String
-    precision::String
-end
-
-Type(::Base.Type{T}) where {T<:AbstractFloat} = FloatingPoint(
-    "floatingpoint",
-    T == Float16 ? "HALF" : T == Float32 ? "SINGLE" : "DOUBLE",
-)
-StructTypes.StructType(::Base.Type{FloatingPoint}) = StructTypes.Struct()
-juliatype(f, x::FloatingPoint) =
-    x.precision == "HALF" ? Float16 : x.precision == "SINGLE" ? Float32 : Float64
-
-struct FixedSizeBinary <: Type
-    name::String
-    byteWidth::Int64
-end
-
-Type(::Base.Type{NTuple{N,UInt8}}) where {N} = FixedSizeBinary("fixedsizebinary", N)
-children(::Base.Type{NTuple{N,UInt8}}) where {N} = Field[]
-StructTypes.StructType(::Base.Type{FixedSizeBinary}) = StructTypes.Struct()
-juliatype(f, x::FixedSizeBinary) = NTuple{x.byteWidth,UInt8}
-
-struct Decimal <: Type
-    name::String
-    precision::Int32
-    scale::Int32
-end
-
-Type(::Base.Type{Arrow.Decimal{P,S,T}}) where {P,S,T} = Decimal("decimal", P, S)
-StructTypes.StructType(::Base.Type{Decimal}) = StructTypes.Struct()
-juliatype(f, x::Decimal) = Arrow.Decimal{x.precision,x.scale,Int128}
-
-mutable struct Timestamp <: Type
-    name::String
-    unit::String
-    timezone::Union{Nothing,String}
-end
-
-Timestamp() = Timestamp("", "", nothing)
-unit(U) =
-    U == Arrow.Meta.TimeUnit.SECOND ? "SECOND" :
-    U == Arrow.Meta.TimeUnit.MILLISECOND ? "MILLISECOND" :
-    U == Arrow.Meta.TimeUnit.MICROSECOND ? "MICROSECOND" : "NANOSECOND"
-Type(::Base.Type{Arrow.Timestamp{U,TZ}}) where {U,TZ} =
-    Timestamp("timestamp", unit(U), TZ === nothing ? nothing : String(TZ))
-StructTypes.StructType(::Base.Type{Timestamp}) = StructTypes.Mutable()
-unitT(u) =
-    u == "SECOND" ? Arrow.Meta.TimeUnit.SECOND :
-    u == "MILLISECOND" ? Arrow.Meta.TimeUnit.MILLISECOND :
-    u == "MICROSECOND" ? Arrow.Meta.TimeUnit.MICROSECOND : Arrow.Meta.TimeUnit.NANOSECOND
-juliatype(f, x::Timestamp) =
-    Arrow.Timestamp{unitT(x.unit),x.timezone === nothing ? nothing : Symbol(x.timezone)}
-
-struct Duration <: Type
-    name::String
-    unit::String
-end
-
-Type(::Base.Type{Arrow.Duration{U}}) where {U} = Duration("duration", unit(U))
-StructTypes.StructType(::Base.Type{Duration}) = StructTypes.Struct()
-juliatype(f, x::Duration) = Arrow.Duration{unit % (x.unit)}
-
-struct Date <: Type
-    name::String
-    unit::String
-end
-
-Type(::Base.Type{Arrow.Date{U,T}}) where {U,T} =
-    Date("date", U == Arrow.Meta.DateUnit.DAY ? "DAY" : "MILLISECOND")
-StructTypes.StructType(::Base.Type{Date}) = StructTypes.Struct()
-juliatype(f, x::Date) = Arrow.Date{
-    x.unit == "DAY" ? Arrow.Meta.DateUnit.DAY : Arrow.Meta.DateUnit.MILLISECOND,
-    x.unit == "DAY" ? Int32 : Int64,
-}
-
-struct Time <: Type
-    name::String
-    unit::String
-    bitWidth::Int64
-end
-
-Type(::Base.Type{Arrow.Time{U,T}}) where {U,T} = Time("time", unit(U), 8 * sizeof(T))
-StructTypes.StructType(::Base.Type{Time}) = StructTypes.Struct()
-juliatype(f, x::Time) =
-    Arrow.Time{unitT(x.unit),x.unit == "SECOND" || x.unit == "MILLISECOND" ? Int32 : Int64}
-
-struct Interval <: Type
-    name::String
-    unit::String
-end
-
-Type(::Base.Type{Arrow.Interval{U,T}}) where {U,T} = Interval(
-    "interval",
-    U == Arrow.Meta.IntervalUnit.YEAR_MONTH ? "YEAR_MONTH" : "DAY_TIME",
-)
-StructTypes.StructType(::Base.Type{Interval}) = StructTypes.Struct()
-juliatype(f, x::Interval) = Arrow.Interval{
-    x.unit == "YEAR_MONTH" ? Arrow.Meta.IntervalUnit.YEAR_MONTH :
-    Arrow.Meta.IntervalUnit.DAY_TIME,
-    x.unit == "YEAR_MONTH" ? Int32 : Int64,
-}
-
-struct UnionT <: Type
-    name::String
-    mode::String
-    typIds::Vector{Int64}
-end
-
-Type(::Base.Type{Arrow.UnionT{T,typeIds,U}}) where {T,typeIds,U} =
-    UnionT("union", T == Arrow.Meta.UnionMode.Dense ? "DENSE" : "SPARSE", collect(typeIds))
-children(::Base.Type{Arrow.UnionT{T,typeIds,U}}) where {T,typeIds,U} =
-    Field[Field("", fieldtype(U, i), nothing) for i = 1:fieldcount(U)]
-StructTypes.StructType(::Base.Type{UnionT}) = StructTypes.Struct()
-juliatype(f, x::UnionT) = Arrow.UnionT{
-    x.mode == "DENSE" ? Arrow.Meta.UnionMode.DENSE : Arrow.Meta.UnionMode.SPARSE,
-    Tuple(x.typeIds),
-    Tuple{(juliatype(y) for y in f.children)...},
-}
-
-struct List <: Type
-    name::String
-end
-
-Type(::Base.Type{Vector{T}}) where {T} = List("list")
-children(::Base.Type{Vector{T}}) where {T} = [Field("item", T, nothing)]
-StructTypes.StructType(::Base.Type{List}) = StructTypes.Struct()
-juliatype(f, x::List) = Vector{juliatype(f.children[1])}
-
-struct LargeList <: Type
-    name::String
-end
-
-StructTypes.StructType(::Base.Type{LargeList}) = StructTypes.Struct()
-juliatype(f, x::LargeList) = Vector{juliatype(f.children[1])}
-
-struct FixedSizeList <: Type
-    name::String
-    listSize::Int64
-end
-
-Type(::Base.Type{NTuple{N,T}}) where {N,T} = FixedSizeList("fixedsizelist", N)
-children(::Base.Type{NTuple{N,T}}) where {N,T} = [Field("item", T, nothing)]
-StructTypes.StructType(::Base.Type{FixedSizeList}) = StructTypes.Struct()
-juliatype(f, x::FixedSizeList) = NTuple{x.listSize,juliatype(f.children[1])}
-
-struct Struct <: Type
-    name::String
-end
-
-Type(::Base.Type{NamedTuple{names,types}}) where {names,types} = Struct("struct")
-children(::Base.Type{NamedTuple{names,types}}) where {names,types} =
-    [Field(names[i], fieldtype(types, i), nothing) for i = 1:length(names)]
-StructTypes.StructType(::Base.Type{Struct}) = StructTypes.Struct()
-juliatype(f, x::Struct) = NamedTuple{
-    Tuple(Symbol(x.name) for x in f.children),
-    Tuple{(juliatype(y) for y in f.children)...},
-}
-
-struct Map <: Type
-    name::String
-    keysSorted::Base.Bool
-end
-
-Type(::Base.Type{Dict{K,V}}) where {K,V} = Map("map", false)
-children(::Base.Type{Dict{K,V}}) where {K,V} =
-    [Field("entries", Arrow.KeyValue{K,V}, nothing)]
-StructTypes.StructType(::Base.Type{Map}) = StructTypes.Struct()
-juliatype(f, x::Map) =
-    Dict{juliatype(f.children[1].children[1]),juliatype(f.children[1].children[2])}
-
-Type(::Base.Type{Arrow.KeyValue{K,V}}) where {K,V} = Struct("struct")
-children(::Base.Type{Arrow.KeyValue{K,V}}) where {K,V} =
-    [Field("key", K, nothing), Field("value", V, nothing)]
-
-struct Null <: Type
-    name::String
-end
-
-Type(::Base.Type{Missing}) = Null("null")
-StructTypes.StructType(::Base.Type{Null}) = StructTypes.Struct()
-juliatype(f, x::Null) = Missing
-
-struct Utf8 <: Type
-    name::String
-end
-
-Type(::Base.Type{<:String}) = Utf8("utf8")
-StructTypes.StructType(::Base.Type{Utf8}) = StructTypes.Struct()
-juliatype(f, x::Utf8) = String
-
-struct LargeUtf8 <: Type
-    name::String
-end
-
-StructTypes.StructType(::Base.Type{LargeUtf8}) = StructTypes.Struct()
-juliatype(f, x::LargeUtf8) = String
-
-struct Binary <: Type
-    name::String
-end
-
-Type(::Base.Type{Vector{UInt8}}) = Binary("binary")
-children(::Base.Type{Vector{UInt8}}) = Field[]
-StructTypes.StructType(::Base.Type{Binary}) = StructTypes.Struct()
-juliatype(f, x::Binary) = Vector{UInt8}
-
-struct LargeBinary <: Type
-    name::String
-end
-
-StructTypes.StructType(::Base.Type{LargeBinary}) = StructTypes.Struct()
-juliatype(f, x::LargeBinary) = Vector{UInt8}
-
-struct Bool <: Type
-    name::String
-end
-
-Type(::Base.Type{Base.Bool}) = Bool("bool")
-StructTypes.StructType(::Base.Type{Bool}) = StructTypes.Struct()
-juliatype(f, x::Bool) = Base.Bool
-
-StructTypes.subtypekey(::Base.Type{Type}) = :name
-
-const SUBTYPES = @eval (
-    int=Int,
-    floatingpoint=FloatingPoint,
-    fixedsizebinary=FixedSizeBinary,
-    decimal=Decimal,
-    timestamp=Timestamp,
-    duration=Duration,
-    date=Date,
-    time=Time,
-    interval=Interval,
-    union=UnionT,
-    list=List,
-    largelist=LargeList,
-    fixedsizelist=FixedSizeList,
-    ($(Symbol("struct")))=Struct,
-    map=Map,
-    null=Null,
-    utf8=Utf8,
-    largeutf8=LargeUtf8,
-    binary=Binary,
-    largebinary=LargeBinary,
-    bool=Bool,
-)
-
-StructTypes.subtypes(::Base.Type{Type}) = SUBTYPES
-
-const Metadata = Union{Nothing,Vector{NamedTuple{(:key, :value),Tuple{String,String}}}}
-Metadata() = nothing
-
-mutable struct DictEncoding
-    id::Int64
-    indexType::Type
-    isOrdered::Base.Bool
-end
-
-DictEncoding() = DictEncoding(0, Type(), false)
-StructTypes.StructType(::Base.Type{DictEncoding}) = StructTypes.Mutable()
-
-mutable struct Field
-    name::String
-    nullable::Base.Bool
-    type::Type
-    children::Vector{Field}
-    dictionary::Union{DictEncoding,Nothing}
-    metadata::Metadata
-end
-
-Field() = Field("", true, Type(), Field[], nothing, Metadata())
-StructTypes.StructType(::Base.Type{Field}) = StructTypes.Mutable()
-Base.copy(f::Field) =
-    Field(f.name, f.nullable, f.type, f.children, f.dictionary, f.metadata)
-
-function juliatype(f::Field)
-    T = juliatype(f, f.type)
-    return f.nullable ? Union{T,Missing} : T
-end
-
-function Field(nm, ::Base.Type{T}, dictencodings) where {T}
-    S = Arrow.maybemissing(T)
-    type = Type(S)
-    ch = children(S)
-    if dictencodings !== nothing && haskey(dictencodings, nm)
-        dict = dictencodings[nm]
-    else
-        dict = nothing
-    end
-    return Field(nm, T !== S, type, ch, dict, nothing)
-end
-
-mutable struct Schema
-    fields::Vector{Field}
-    metadata::Metadata
-end
-
-Schema() = Schema(Field[], Metadata())
-StructTypes.StructType(::Base.Type{Schema}) = StructTypes.Mutable()
-
-struct Offsets{T} <: AbstractVector{T}
-    data::Vector{T}
-end
-
-Base.size(x::Offsets) = size(x.data)
-Base.getindex(x::Offsets, i::Base.Int) = getindex(x.data, i)
-
-mutable struct FieldData
-    name::String
-    count::Int64
-    VALIDITY::Union{Nothing,Vector{Int8}}
-    OFFSET::Union{Nothing,Offsets}
-    TYPE_ID::Union{Nothing,Vector{Int8}}
-    DATA::Union{Nothing,Vector{Any}}
-    children::Vector{FieldData}
-end
-
-FieldData() = FieldData("", 0, nothing, nothing, nothing, nothing, FieldData[])
-StructTypes.StructType(::Base.Type{FieldData}) = StructTypes.Mutable()
-
-function FieldData(nm, ::Base.Type{T}, col, dictencodings) where {T}
-    if dictencodings !== nothing && haskey(dictencodings, nm)
-        refvals = DataAPI.refarray(col.data)
-        if refvals !== col.data
-            IT = eltype(refvals)
-            col = (x - one(T) for x in refvals)
-        else
-            _, de = dictencodings[nm]
-            IT = de.indexType
-            vals = unique(col)
-            col = Arrow.DictEncoder(col, vals, Arrow.encodingtype(length(vals)))
-        end
-        return FieldData(nm, IT, col, nothing)
-    end
-    S = Arrow.maybemissing(T)
-    len = Arrow._length(col)
-    VALIDITY = OFFSET = TYPE_ID = DATA = nothing
-    children = FieldData[]
-    if S <: Pair
-        return FieldData(
-            nm,
-            Vector{Arrow.KeyValue{Arrow._keytype(S),Arrow._valtype(S)}},
-            (Arrow.KeyValue(k, v) for (k, v) in pairs(col)),
-        )
-    elseif S !== Missing
-        # VALIDITY
-        VALIDITY = Int8[!ismissing(x) for x in col]
-        # OFFSET
-        if S <: Vector || S == String
-            lenfun =
-                S == String ? x -> ismissing(x) ? 0 : sizeof(x) :
-                x -> ismissing(x) ? 0 : length(x)
-            tot = sum(lenfun, col)
-            if tot > 2147483647
-                OFFSET = String[String(lenfun(x)) for x in col]
-                pushfirst!(OFFSET, "0")
-            else
-                OFFSET = Int32[ismissing(x) ? 0 : lenfun(x) for x in col]
-                pushfirst!(OFFSET, 0)
-            end
-            OFFSET = Offsets(OFFSET)
-            push!(
-                children,
-                FieldData(
-                    "item",
-                    eltype(S),
-                    Arrow.flatten(skipmissing(col)),
-                    dictencodings,
-                ),
-            )
-        elseif S <: NTuple
-            if Arrow.ArrowTypes.gettype(Arrow.ArrowTypes.ArrowKind(S)) == UInt8
-                DATA = [
-                    ismissing(x) ? Arrow.ArrowTypes.default(S) : String(collect(x)) for
-                    x in col
-                ]
-            else
-                push!(
-                    children,
-                    FieldData(
-                        "item",
-                        Arrow.ArrowTypes.gettype(Arrow.ArrowTypes.ArrowKind(S)),
-                        Arrow.flatten(
-                            coalesce(x, Arrow.ArrowTypes.default(S)) for x in col
-                        ),
-                        dictencodings,
-                    ),
-                )
-            end
-        elseif S <: NamedTuple
-            for (nm, typ) in zip(fieldnames(S), fieldtypes(S))
-                push!(
-                    children,
-                    FieldData(
-                        String(nm),
-                        typ,
-                        (getfield(x, nm) for x in col),
-                        dictencodings,
-                    ),
-                )
-            end
-        elseif S <: Arrow.UnionT
-            U = eltype(S)
-            tids = Arrow.typeids(S) === nothing ? (0:fieldcount(U)) : Arrow.typeids(S)
-            TYPE_ID = [x === missing ? 0 : tids[Arrow.isatypeid(x, U)] for x in col]
-            if Arrow.unionmode(S) == Arrow.Meta.UnionMode.Dense
-                offs = zeros(Int32, fieldcount(U))
-                OFFSET = Int32[]
-                for x in col
-                    idx = x === missing ? 1 : Arrow.isatypeid(x, U)
-                    push!(OFFSET, offs[idx])
-                    offs[idx] += 1
-                end
-                for i = 1:fieldcount(U)
-                    SS = fieldtype(U, i)
-                    push!(
-                        children,
-                        FieldData(
-                            "$i",
-                            SS,
-                            Arrow.filtered(
-                                i == 1 ? Union{SS,Missing} : Arrow.maybemissing(SS),
-                                col,
-                            ),
-                            dictencodings,
-                        ),
-                    )
-                end
-            else
-                for i = 1:fieldcount(U)
-                    SS = fieldtype(U, i)
-                    push!(
-                        children,
-                        FieldData("$i", SS, Arrow.replaced(SS, col), dictencodings),
-                    )
-                end
-            end
-        elseif S <: KeyValue
-            push!(
-                children,
-                FieldData("key", Arrow.keyvalueK(S), (x.key for x in col), dictencodings),
-            )
-            push!(
-                children,
-                FieldData(
-                    "value",
-                    Arrow.keyvalueV(S),
-                    (x.value for x in col),
-                    dictencodings,
-                ),
-            )
-        end
-    end
-    return FieldData(nm, len, VALIDITY, OFFSET, TYPE_ID, DATA, children)
-end
-
-mutable struct RecordBatch
-    count::Int64
-    columns::Vector{FieldData}
-end
-
-RecordBatch() = RecordBatch(0, FieldData[])
-StructTypes.StructType(::Base.Type{RecordBatch}) = StructTypes.Mutable()
-
-mutable struct DictionaryBatch
-    id::Int64
-    data::RecordBatch
-end
-
-DictionaryBatch() = DictionaryBatch(0, RecordBatch())
-StructTypes.StructType(::Base.Type{DictionaryBatch}) = StructTypes.Mutable()
-
-mutable struct DataFile <: Tables.AbstractColumns
-    schema::Schema
-    batches::Vector{RecordBatch}
-    dictionaries::Vector{DictionaryBatch}
-end
-
-Base.propertynames(x::DataFile) = (:schema, :batches, :dictionaries)
-
-function Base.getproperty(df::DataFile, nm::Symbol)
-    if nm === :schema
-        return getfield(df, :schema)
-    elseif nm === :batches
-        return getfield(df, :batches)
-    elseif nm === :dictionaries
-        return getfield(df, :dictionaries)
-    end
-    return Tables.getcolumn(df, nm)
-end
-
-DataFile() = DataFile(Schema(), RecordBatch[], DictionaryBatch[])
-StructTypes.StructType(::Base.Type{DataFile}) = StructTypes.Mutable()
-
-parsefile(file) = JSON3.read(Mmap.mmap(file), DataFile)
-
-# make DataFile satisfy Tables.jl interface
-function Tables.partitions(x::DataFile)
-    if isempty(x.batches)
-        # special case empty batches by producing a single DataFile w/ schema
-        return (DataFile(x.schema, RecordBatch[], x.dictionaries),)
-    else
-        return (
-            DataFile(x.schema, [x.batches[i]], x.dictionaries) for i = 1:length(x.batches)
-        )
-    end
-end
-
-Tables.columns(x::DataFile) = x
-
-function Tables.schema(x::DataFile)
-    names = map(x -> x.name, x.schema.fields)
-    types = map(x -> juliatype(x), x.schema.fields)
-    return Tables.Schema(names, types)
-end
-
-Tables.columnnames(x::DataFile) = map(x -> Symbol(x.name), x.schema.fields)
-
-function Tables.getcolumn(x::DataFile, i::Base.Int)
-    field = x.schema.fields[i]
-    type = juliatype(field)
-    return ChainedVector(
-        ArrowArray{type}[
-            ArrowArray{type}(
-                field,
-                length(x.batches) > 0 ? x.batches[j].columns[i] : FieldData(),
-                x.dictionaries,
-            ) for j = 1:length(x.batches)
-        ],
-    )
-end
-
-function Tables.getcolumn(x::DataFile, nm::Symbol)
-    i = findfirst(x -> x.name == String(nm), x.schema.fields)
-    return Tables.getcolumn(x, i)
-end
-
-struct ArrowArray{T} <: AbstractVector{T}
-    field::Field
-    fielddata::FieldData
-    dictionaries::Vector{DictionaryBatch}
-end
-ArrowArray(f::Field, fd::FieldData, d) = ArrowArray{juliatype(f)}(f, fd, d)
-Base.size(x::ArrowArray) = (x.fielddata.count,)
-
-function Base.getindex(x::ArrowArray{T}, i::Base.Int) where {T}
-    @boundscheck checkbounds(x, i)
-    S = Base.nonmissingtype(T)
-    if x.field.dictionary !== nothing
-        fielddata =
-            x.dictionaries[findfirst(y -> y.id == x.field.dictionary.id, x.dictionaries)].data.columns[1]
-        field = copy(x.field)
-        field.dictionary = nothing
-        idx = x.fielddata.DATA[i] + 1
-        return ArrowArray(field, fielddata, x.dictionaries)[idx]
-    end
-    if T === Missing
-        return missing
-    elseif S <: UnionT
-        U = eltype(S)
-        tids = Arrow.typeids(S) === nothing ? (0:fieldcount(U)) : Arrow.typeids(S)
-        typeid = tids[x.fielddata.TYPE_ID[i]]
-        if Arrow.unionmode(S) == Arrow.Meta.UnionMode.DENSE
-            off = x.fielddata.OFFSET[i]
-            return ArrowArray(
-                x.field.children[typeid + 1],
-                x.fielddata.children[typeid + 1],
-                x.dictionaries,
-            )[off]
-        else
-            return ArrowArray(
-                x.field.children[typeid + 1],
-                x.fielddata.children[typeid + 1],
-                x.dictionaries,
-            )[i]
-        end
-    end
-    x.fielddata.VALIDITY[i] == 0 && return missing
-    if S <: Vector{UInt8}
-        return copy(codeunits(x.fielddata.DATA[i]))
-    elseif S <: String
-        return x.fielddata.DATA[i]
-    elseif S <: Vector
-        offs = x.fielddata.OFFSET
-        A = ArrowArray{eltype(S)}(
-            x.field.children[1],
-            x.fielddata.children[1],
-            x.dictionaries,
-        )
-        return A[(offs[i] + 1):offs[i + 1]]
-    elseif S <: Dict
-        offs = x.fielddata.OFFSET
-        A = ArrowArray(x.field.children[1], x.fielddata.children[1], x.dictionaries)
-        return Dict(y.key => y.value for y in A[(offs[i] + 1):offs[i + 1]])
-    elseif S <: Tuple
-        if Arrow.ArrowTypes.gettype(Arrow.ArrowTypes.ArrowKind(S)) == UInt8
-            A = x.fielddata.DATA
-            return Tuple(map(UInt8, collect(A[i][1:(x.field.type.byteWidth)])))
-        else
-            sz = x.field.type.listSize
-            A = ArrowArray{Arrow.ArrowTypes.gettype(Arrow.ArrowTypes.ArrowKind(S))}(
-                x.field.children[1],
-                x.fielddata.children[1],
-                x.dictionaries,
-            )
-            off = (i - 1) * sz + 1
-            return Tuple(A[off:(off + sz - 1)])
-        end
-    elseif S <: NamedTuple
-        data = (
-            ArrowArray(x.field.children[j], x.fielddata.children[j], x.dictionaries)[i] for
-            j = 1:length(x.field.children)
-        )
-        return NamedTuple{fieldnames(S)}(Tuple(data))
-    elseif S == Int64 || S == UInt64
-        return parse(S, x.fielddata.DATA[i])
-    elseif S <: Arrow.Decimal
-        str = x.fielddata.DATA[i]
-        return S(parse(Int128, str))
-    elseif S <: Arrow.Date || S <: Arrow.Time
-        val = x.fielddata.DATA[i]
-        return Arrow.storagetype(S) == Int32 ? S(val) : S(parse(Int64, val))
-    elseif S <: Arrow.Timestamp
-        return S(parse(Int64, x.fielddata.DATA[i]))
-    else
-        return S(x.fielddata.DATA[i])
-    end
-end
-
-# take any Tables.jl source and write out arrow json datafile
-function DataFile(source)
-    fields = Field[]
-    metadata = nothing # TODO?
-    batches = RecordBatch[]
-    dictionaries = DictionaryBatch[]
-    dictencodings = Dict{String,Tuple{Base.Type,DictEncoding}}()
-    dictid = Ref(0)
-    for (i, tbl1) in Tables.partitions(source)
-        tbl = Arrow.toarrowtable(Table.Columns(tbl1))
-        if i == 1
-            sch = Tables.schema(tbl)
-            for (nm, T, col) in zip(sch.names, sch.types, tbl)
-                if col isa Arrow.DictEncode
-                    id = dictid[]
-                    dictid[] += 1
-                    codes = DataAPI.refarray(col.data)
-                    if codes !== col.data
-                        IT = Type(eltype(codes))
-                    else
-                        IT = Type(Arrow.encodingtype(length(unique(col))))
-                    end
-                    dictencodings[String(nm)] = (T, DictEncoding(id, IT, false))
-                end
-                push!(fields, Field(String(nm), T, dictencodings))
-            end
-        end
-        # build record batch
-        len = Tables.rowcount(tbl)
-        columns = FieldData[]
-        for (nm, T, col) in zip(sch.names, sch.types, tbl)
-            push!(columns, FieldData(String(nm), T, col, dictencodings))
-        end
-        push!(batches, RecordBatch(len, columns))
-        # build dictionaries
-        for (nm, (T, dictencoding)) in dictencodings
-            column = FieldData(nm, T, Tables.getcolumn(tbl, nm), nothing)
-            recordbatch = RecordBatch(len, [column])
-            push!(dictionaries, DictionaryBatch(dictencoding.id, recordbatch))
-        end
-    end
-    schema = Schema(fields, metadata)
-    return DataFile(schema, batches, dictionaries)
-end
-
-function Base.isequal(df::DataFile, tbl::Arrow.Table)
-    Arrow.is_equivalent_schema(Tables.schema(df), Tables.schema(tbl)) || return false
-    i = 1
-    for (col1, col2) in zip(Tables.Columns(df), Tables.Columns(tbl))
-        if !isequal(col1, col2)
-            @show i
-            return false
-        end
-        i += 1
-    end
-    return true
-end
-
-end
diff --git a/test/arrowjson/datetime.json b/test/arrowjson/datetime.json
deleted file mode 100644
index f6907834..00000000
--- a/test/arrowjson/datetime.json
+++ /dev/null
@@ -1,911 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "f0",
-        "type": {
-          "name": "date",
-          "unit": "DAY"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f1",
-        "type": {
-          "name": "date",
-          "unit": "MILLISECOND"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f2",
-        "type": {
-          "name": "time",
-          "unit": "SECOND",
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f3",
-        "type": {
-          "name": "time",
-          "unit": "MILLISECOND",
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f4",
-        "type": {
-          "name": "time",
-          "unit": "MICROSECOND",
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f5",
-        "type": {
-          "name": "time",
-          "unit": "NANOSECOND",
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f6",
-        "type": {
-          "name": "timestamp",
-          "unit": "SECOND"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f7",
-        "type": {
-          "name": "timestamp",
-          "unit": "MILLISECOND"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f8",
-        "type": {
-          "name": "timestamp",
-          "unit": "MICROSECOND"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f9",
-        "type": {
-          "name": "timestamp",
-          "unit": "NANOSECOND"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f10",
-        "type": {
-          "name": "timestamp",
-          "unit": "MILLISECOND"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f11",
-        "type": {
-          "name": "timestamp",
-          "unit": "SECOND",
-          "timezone": "UTC"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f12",
-        "type": {
-          "name": "timestamp",
-          "unit": "MILLISECOND",
-          "timezone": "US/Eastern"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f13",
-        "type": {
-          "name": "timestamp",
-          "unit": "MICROSECOND",
-          "timezone": "Europe/Paris"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f14",
-        "type": {
-          "name": "timestamp",
-          "unit": "NANOSECOND",
-          "timezone": "US/Pacific"
-        },
-        "nullable": true,
-        "children": []
-      }
-    ]
-  },
-  "batches": [
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            -719162,
-            2932896,
-            1251583,
-            -354578,
-            1947695,
-            -669151,
-            26653
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "-2820221740189",
-            "71549882314362",
-            "125067746235030",
-            "-27038791348254",
-            "42137473450326"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            0,
-            86400,
-            76127,
-            6700,
-            27103,
-            56151,
-            56654
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            0,
-            86400000,
-            17984286,
-            76370591,
-            60937117,
-            2240575,
-            8788989
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "0",
-            "86400000000",
-            "74085029005",
-            "23058796418",
-            "5827157574",
-            "30753386088",
-            "41165364667"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "0",
-            "86400000000000",
-            "23907445718784",
-            "74345421086418",
-            "75233481254444",
-            "82172159793710",
-            "58497242525071"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-62135596800",
-            "253402214400",
-            "-61131551586",
-            "109841560561",
-            "-3916465142",
-            "146694684650",
-            "138850275868"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "73881152631437",
-            "69908713976427",
-            "252339755754438",
-            "-24746530024729",
-            "169302540975380"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-62135596800000000",
-            "253402214400000000",
-            "201464679490582249",
-            "168126161155504013",
-            "-23403778250906066",
-            "205706554937392102",
-            "45776665091115087"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-9223372036854775808",
-            "9223372036854775807",
-            "-6357255048670867880",
-            "-8661447973993819541",
-            "-8212788386909103318",
-            "-8530954041419345600",
-            "-4218486829304453721"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "206983911256609",
-            "94973546379549",
-            "-18473207641060",
-            "36529119814530",
-            "143273969098011"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-62135596800",
-            "253402214400",
-            "225567855249",
-            "18090198256",
-            "-18645631593",
-            "1683299996",
-            "240974238031"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "-41888047432132",
-            "142167692985706",
-            "96450253340232",
-            "-28800292871111",
-            "31551906541089"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-62135596800000000",
-            "253402214400000000",
-            "-55035741541368439",
-            "110555619232926841",
-            "13584197914180451",
-            "-40099398122556776",
-            "154575532939365500"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-9223372036854775808",
-            "9223372036854775807",
-            "5175948389020765869",
-            "5557679156666679724",
-            "4250919303876106324",
-            "9160676477011889469",
-            "8585006913301874724"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            -719162,
-            2932896,
-            1879965,
-            -566367,
-            37728,
-            1761040,
-            279144,
-            1056794,
-            756303,
-            525725
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "-38092110755085",
-            "-28445105640862",
-            "82150583163219",
-            "54419670636015",
-            "157522888788052",
-            "-41135178703404",
-            "-55692081078291",
-            "23161948344048"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            0,
-            86400,
-            68158,
-            43645,
-            82390,
-            63272,
-            8687,
-            73663,
-            41080,
-            16606
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            0,
-            86400000,
-            4300160,
-            71414742,
-            77204018,
-            20632726,
-            31365614,
-            66601445,
-            59573489,
-            62138475
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "0",
-            "86400000000",
-            "28651881349",
-            "76962235570",
-            "72557141940",
-            "81551970477",
-            "20740172257",
-            "69927019990",
-            "76743031592",
-            "82821335874"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "0",
-            "86400000000000",
-            "69757112637445",
-            "57552711513942",
-            "29426946816946",
-            "34878855922929",
-            "33344575898987",
-            "80887006335433",
-            "34037765279999",
-            "51577535310194"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-62135596800",
-            "253402214400",
-            "17362133914",
-            "-45891238920",
-            "184875963653",
-            "189805054827",
-            "-58368591641",
-            "11979945774",
-            "-42159999942",
-            "-40114167869"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "228991365143433",
-            "169961535994833",
-            "200469360821110",
-            "69234108321383",
-            "198319780924526",
-            "191497586634193",
-            "175427870270356",
-            "57342673854963"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-62135596800000000",
-            "253402214400000000",
-            "56980200145982394",
-            "181929648203745781",
-            "139102923751831867",
-            "208997257530770666",
-            "16136961511557279",
-            "41555612864958844",
-            "13419848118557598",
-            "87383692083185618"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-9223372036854775808",
-            "9223372036854775807",
-            "-7031715621840828119",
-            "6059066797068981521",
-            "-1646261793033501417",
-            "-4220806875454311426",
-            "-5197114782094970725",
-            "-8786449967831538943",
-            "2974021310284646715",
-            "-8065049992539820014"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "178310981489839",
-            "-57632494932898",
-            "-49036210908585",
-            "52895117552494",
-            "171282515196488",
-            "132014017559614",
-            "37589110284897",
-            "-58565057255450"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-62135596800",
-            "253402214400",
-            "-25861647763",
-            "225566577159",
-            "239974631847",
-            "9594019763",
-            "195861877033",
-            "-19961060193",
-            "75621579368",
-            "-37516489502"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-62135596800000",
-            "253402214400000",
-            "197770622812426",
-            "195993483135189",
-            "187243903796151",
-            "193213107363200",
-            "83570298570259",
-            "252571502045214",
-            "129428288356579",
-            "-6553516468568"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-62135596800000000",
-            "253402214400000000",
-            "227405247332731417",
-            "-23876629555725661",
-            "172967389442803645",
-            "214366955371313241",
-            "86933375268516953",
-            "162567381239071692",
-            "40270626452354761",
-            "-9766478375147980"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-9223372036854775808",
-            "9223372036854775807",
-            "-3367778002617009344",
-            "-921482854487607004",
-            "1280046021732622411",
-            "-2084512789553264359",
-            "6774927372092824293",
-            "2301253808511314195",
-            "-447823511949250637",
-            "-9137589927882857097"
-          ]
-        }
-      ]
-    }
-  ]
-}
diff --git a/test/arrowjson/decimal.json b/test/arrowjson/decimal.json
deleted file mode 100644
index 6c27800a..00000000
--- a/test/arrowjson/decimal.json
+++ /dev/null
@@ -1,32948 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "f0",
-        "type": {
-          "name": "decimal",
-          "precision": 3,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f1",
-        "type": {
-          "name": "decimal",
-          "precision": 4,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f2",
-        "type": {
-          "name": "decimal",
-          "precision": 5,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f3",
-        "type": {
-          "name": "decimal",
-          "precision": 6,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f4",
-        "type": {
-          "name": "decimal",
-          "precision": 7,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f5",
-        "type": {
-          "name": "decimal",
-          "precision": 8,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f6",
-        "type": {
-          "name": "decimal",
-          "precision": 9,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f7",
-        "type": {
-          "name": "decimal",
-          "precision": 10,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f8",
-        "type": {
-          "name": "decimal",
-          "precision": 11,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f9",
-        "type": {
-          "name": "decimal",
-          "precision": 12,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f10",
-        "type": {
-          "name": "decimal",
-          "precision": 13,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f11",
-        "type": {
-          "name": "decimal",
-          "precision": 14,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f12",
-        "type": {
-          "name": "decimal",
-          "precision": 15,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f13",
-        "type": {
-          "name": "decimal",
-          "precision": 16,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f14",
-        "type": {
-          "name": "decimal",
-          "precision": 17,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f15",
-        "type": {
-          "name": "decimal",
-          "precision": 18,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f16",
-        "type": {
-          "name": "decimal",
-          "precision": 19,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f17",
-        "type": {
-          "name": "decimal",
-          "precision": 20,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f18",
-        "type": {
-          "name": "decimal",
-          "precision": 21,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f19",
-        "type": {
-          "name": "decimal",
-          "precision": 22,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f20",
-        "type": {
-          "name": "decimal",
-          "precision": 23,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f21",
-        "type": {
-          "name": "decimal",
-          "precision": 24,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f22",
-        "type": {
-          "name": "decimal",
-          "precision": 25,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f23",
-        "type": {
-          "name": "decimal",
-          "precision": 26,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f24",
-        "type": {
-          "name": "decimal",
-          "precision": 27,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f25",
-        "type": {
-          "name": "decimal",
-          "precision": 28,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f26",
-        "type": {
-          "name": "decimal",
-          "precision": 29,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f27",
-        "type": {
-          "name": "decimal",
-          "precision": 30,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f28",
-        "type": {
-          "name": "decimal",
-          "precision": 31,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f29",
-        "type": {
-          "name": "decimal",
-          "precision": 32,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f30",
-        "type": {
-          "name": "decimal",
-          "precision": 33,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f31",
-        "type": {
-          "name": "decimal",
-          "precision": 34,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f32",
-        "type": {
-          "name": "decimal",
-          "precision": 35,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f33",
-        "type": {
-          "name": "decimal",
-          "precision": 36,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f34",
-        "type": {
-          "name": "decimal",
-          "precision": 37,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "f35",
-        "type": {
-          "name": "decimal",
-          "precision": 38,
-          "scale": 2
-        },
-        "nullable": true,
-        "children": []
-      }
-    ]
-  },
-  "batches": [
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-14265",
-            "-3301",
-            "-20359",
-            "5259",
-            "-10833",
-            "-19794",
-            "22904"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7020",
-            "7396",
-            "9702",
-            "-29862",
-            "25915",
-            "17934",
-            "23441"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-6799031",
-            "-6350361",
-            "-7919057",
-            "-2688856",
-            "-2460218",
-            "-5498780",
-            "5580928"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-3533649",
-            "643928",
-            "2739361",
-            "-2006582",
-            "7501109",
-            "-2029241",
-            "-6554749"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1383097445",
-            "-317364446",
-            "39137303",
-            "-203304373",
-            "284864794",
-            "-1902924832",
-            "694509255"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1445584597",
-            "-1479256303",
-            "1986678586",
-            "653640925",
-            "-1377647126",
-            "163472005",
-            "-985666433"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1032313347",
-            "1968833128",
-            "2108909581",
-            "1727353475",
-            "912414766",
-            "-635823470",
-            "1712241290"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "154945363887",
-            "416184610386",
-            "339640718067",
-            "517615365091",
-            "-225329280656",
-            "170183803130",
-            "-151819857736"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "415862710871",
-            "-497367616337",
-            "-513589024815",
-            "365532163027",
-            "162771025458",
-            "-217545761908",
-            "-177764161272"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "139749710369981",
-            "-83794245890178",
-            "-91856283653391",
-            "136480936919831",
-            "139751556918685",
-            "-128711073562986",
-            "57528145123438"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "52917228652967",
-            "-94943960868145",
-            "-95787469176401",
-            "138513251818631",
-            "72391840904205",
-            "15456369093039",
-            "43627762817987"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-55939733680307",
-            "109774177882810",
-            "-18751094013174",
-            "66217182114674",
-            "54552088012955",
-            "10184533351464",
-            "-42623419179005"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "5323426016158598",
-            "-14889118959500841",
-            "17725275930019497",
-            "8976278451851381",
-            "-13047873474817232",
-            "-35698038632707430",
-            "35553131382011652"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "22248347423524568",
-            "21382628128477388",
-            "10729166497278728",
-            "33552782977485637",
-            "-27049764851522362",
-            "-22662588671534830",
-            "34450594992450092"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "1793092340943680288",
-            "6687492261570159758",
-            "-8215335212004105263",
-            "4478178378408252470",
-            "163214921176454093",
-            "8663994206540321487",
-            "-7336047061160684053"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8553613303342920727",
-            "2303004565228604365",
-            "4387581718276767427",
-            "-9190240538897215152",
-            "-2359611618219705826",
-            "-4394705260138635628",
-            "-5098494694180487526"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2066857943452927830158",
-            "903014216615599800157",
-            "-550458216531247342288",
-            "2017634601926315282348",
-            "848752616371714143556",
-            "1142061465959813542452",
-            "1385502695475659971908"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-2114118262682166206082",
-            "1902359162690886678168",
-            "416686278682682920537",
-            "1670406372017974831657",
-            "1672178198289799650411",
-            "1290828393749566925129",
-            "477509832520793484657"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-761286776745227142069",
-            "-519173571795485925518",
-            "-1152371818412313184820",
-            "-1693854308571834153795",
-            "-2338147549154180008842",
-            "-722980793690531284755",
-            "-308453791763555488903"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-363139155978036972417607",
-            "-67592154020748584606597",
-            "229641197562527780640996",
-            "-346708211516644122649482",
-            "-1250859224618770910347",
-            "-324094365896255288686912",
-            "587754147918610672847722"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-260044582391618089260319",
-            "-571174996847059618302630",
-            "-109712997473546598340520",
-            "-504887878361994310822232",
-            "-79933142040493800702044",
-            "391593215117382882517477",
-            "253411954510878438009626"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "78355683904145007775288840",
-            "-119384708322041630321535990",
-            "-100920737167981116982294279",
-            "83826802691186830123887155",
-            "-142861875795075155563507787",
-            "-145798388286082279657253594",
-            "-25329913740178438718347749"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "2728894406873273319876599",
-            "-26824077854062930008319059",
-            "59282342970725803527905051",
-            "-102858143095488614827267122",
-            "-86746033992194633744162126",
-            "151758737255322612002715481",
-            "-7882766239372883938103148"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-79786812518583385435068134",
-            "-60631765880118763666388680",
-            "-6864681441231111204611249",
-            "13050926774682302829016376",
-            "-70829524080848069150697712",
-            "-82269446396753351313982437",
-            "-64035656687419899366647308"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "3955725931924121460907631531",
-            "-21274213085809772733586643935",
-            "-12093030231048856037056919233",
-            "1591415318816864321772119800",
-            "15686477033795236409156083537",
-            "35545421326820517900037881163",
-            "22425766368694890650567525141"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "29018707613584242707294878326",
-            "17791141760763489912825555133",
-            "16531138885547875931113958621",
-            "-30513053118126324165999828125",
-            "15960846333545963474586001659",
-            "36917332355702074649716398096",
-            "-23564003365919469704120973292"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "9213099815853647106837374141135",
-            "-2927321977169069503340222047887",
-            "6334956127042213437236348937051",
-            "421008034487997672364705982278",
-            "-8216535847017377542720322569325",
-            "9010595708854142678424220967811",
-            "4188490944857456828411574213081"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-8400462145843923761912990483225",
-            "-9532520685799568447195818877630",
-            "6941627626857671447061360399506",
-            "-1279966284289260405732779325351",
-            "1498483597016609631513149683949",
-            "-1529118713555007787773854671666",
-            "8107117611898163619507416633696"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2915756808824546582752189119657",
-            "689849096940399949037495607644",
-            "6949792968358403147068782203692",
-            "-9209851065708847333103701669232",
-            "-9846735769797668003358129310662",
-            "-828325389508874726576445634733",
-            "-548287410953591263203641276502"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2329344668638312257280241058269271",
-            "-752344765844397811032529707212356",
-            "147451832276294483763966453842451",
-            "2043297198679260475716881353145488",
-            "-1700852196536476328772217191241342",
-            "395231723125832272118398102832808",
-            "1021064751191444192162606435133102"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1059349538643979619795009909676873",
-            "1077517333972932491341963859241254",
-            "-1269329697335528941024149247301687",
-            "1492334714292199711015081732157237",
-            "1164940978846205931486582828955479",
-            "1226701026828005364221866490976254",
-            "-2246642220670050837117291416085961"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-453427466718461089284644212936857043",
-            "401968647744354893846373970134628607",
-            "296564973980089833086319484394180932",
-            "300255396607176659100995955356045655",
-            "-128210286701929565620215086982795175",
-            "-76575845460847329054975157675278272",
-            "150610860039362064995272346289079343"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "421046835537097379208584523685561537",
-            "-12336249922904854000276177315936166",
-            "-643245709818789885569562430725515554",
-            "28125849177083902136768190312091645",
-            "-144070901322770869842559076535428168",
-            "404632889001498427711768281303970316",
-            "484413224979251839912542328701460679"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-74076465584946023556734876157740408561",
-            "48775465105440153520372738047296715437",
-            "-27256511570535798216063178902711504522",
-            "17556306662405983159878112274642973563",
-            "-100278707484244689483962841662232621044",
-            "61342616787415403733699116416597761322",
-            "65469616326882669620827062523697818819"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "160988666415816646705442929165000844171",
-            "-150079614246235114587531344502672720143",
-            "130458754430497218349443163826152965786",
-            "162593370774960128510764087469483971628",
-            "100335479568560073327353331226427021396",
-            "154469868317889131666703500879972187378",
-            "109851602321776291877341624608658829262"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "90507703396950205824782315866890653146",
-            "33101701517846982239639071710846694736",
-            "-162364169137146690363873495754205930932",
-            "6552361136224904568043204720462599330",
-            "55934073603932057089039430724186991179",
-            "-40518421289171987097923903446970623529",
-            "21964873705187790865866750301783750442"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-4326",
-            "-4742",
-            "24127",
-            "-28455",
-            "-25093",
-            "18893",
-            "6010",
-            "18847",
-            "-29502",
-            "32119"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-4350",
-            "6406",
-            "-22249",
-            "-3026",
-            "-27892",
-            "12582",
-            "-26038",
-            "-26810",
-            "-10412",
-            "12059"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-5437050",
-            "-2975935",
-            "-2708551",
-            "5905122",
-            "7598831",
-            "1837938",
-            "3161296",
-            "4144482",
-            "7971237",
-            "3812932"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "8307058",
-            "5437059",
-            "7848415",
-            "210888",
-            "-7438002",
-            "1251661",
-            "1558298",
-            "-8295786",
-            "-1337540",
-            "4329127"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "2143281149",
-            "1036205716",
-            "-483960365",
-            "464783350",
-            "44702295",
-            "1500496151",
-            "2007499481",
-            "-1980167635",
-            "-491561248",
-            "137927958"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "385115557",
-            "-468314229",
-            "-1806182189",
-            "826968059",
-            "1973820915",
-            "-1678321968",
-            "282860534",
-            "-429116070",
-            "-485370474",
-            "-1175964348"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1660401943",
-            "858637970",
-            "1954585251",
-            "896247082",
-            "-1324508546",
-            "1856733620",
-            "-508486488",
-            "-2144890404",
-            "-595464217",
-            "-541883970"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-475292084638",
-            "-151527930749",
-            "-136244496864",
-            "475724641544",
-            "490808185901",
-            "-380524076056",
-            "347742169602",
-            "-208359763265",
-            "500407573029",
-            "-390649746248"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-463878565883",
-            "-440350084389",
-            "-489309228695",
-            "403236358497",
-            "22420180364",
-            "461550541832",
-            "166802945594",
-            "-75395045157",
-            "349097107753",
-            "-31923850582"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "13351341741346",
-            "132672835377977",
-            "-104121852651737",
-            "-116578873884859",
-            "-93368786381550",
-            "-130866514927019",
-            "-130245922532357",
-            "119422720388976",
-            "39514069962031",
-            "129449354245745"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "117562734639864",
-            "-69335041870511",
-            "88065868490266",
-            "-88825080775852",
-            "-33000609471354",
-            "45253821354104",
-            "-19572766862990",
-            "-20998291433421",
-            "-138710717300131",
-            "105346771642837"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "23613726765605",
-            "-122540956874454",
-            "43298244246934",
-            "38914627030131",
-            "-96822287655033",
-            "-117561922155895",
-            "-116901550232631",
-            "-33238646153535",
-            "87255230245952",
-            "-103811103056354"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "14326292611678389",
-            "11679216137082255",
-            "30602968082225040",
-            "-35083463698552038",
-            "13793460528237121",
-            "29475754221579432",
-            "11956818381525770",
-            "25264515687485849",
-            "-9442305734363215",
-            "32709604673194504"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "10752127983223695",
-            "-17671172332493417",
-            "23204581064269137",
-            "25912317958066911",
-            "-6684281122027701",
-            "-5393708227406178",
-            "-705876736520327",
-            "-8271615012961841",
-            "-2359308340581953",
-            "-10178212042804721"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-785858494820999025",
-            "-1596606269767712061",
-            "-1418974761760001783",
-            "5406463592868106826",
-            "8383949914321587435",
-            "-8953833508549969767",
-            "7221522693757617783",
-            "7517732845880583602",
-            "-919064621805709634",
-            "-5495596733594283265"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-8483275882311463690",
-            "8973190785377545539",
-            "5542339023127975216",
-            "-1516710247958149161",
-            "-6505879801430717005",
-            "2140391223240971073",
-            "-582269641777058598",
-            "-5184242226957355683",
-            "5206992463328246120",
-            "-6079741749013867959"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "1593226799266187966947",
-            "-1812161934828717889262",
-            "-2122590131716118763227",
-            "-1027437168205961683538",
-            "1846540008444089681004",
-            "-1156292451907349126710",
-            "-1957435108076953499486",
-            "-950458759560036353191",
-            "-1125440584483224915212",
-            "2247219347276423832973"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-635230024201890240957",
-            "180963226287776474583",
-            "-1878152791054730240606",
-            "-1904422293952570992101",
-            "1052835439226626094544",
-            "-1858821189756108906198",
-            "1853668161015001150059",
-            "511899624049166705494",
-            "610084498432376101375",
-            "-1029828641365425116105"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1885658882244978382784",
-            "565125911580367694969",
-            "-1652560178353597573029",
-            "2133173545067165238416",
-            "-486940365592293262895",
-            "-2060709217874894710408",
-            "1586493850244052619259",
-            "2178470762303491581080",
-            "-1293832362817784170345",
-            "-1858110114261315174517"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-369225411953896208185462",
-            "-432125813663454581808312",
-            "-144256737060926287909147",
-            "437531850902150565537267",
-            "-135152047695882388519227",
-            "200989985671128391254839",
-            "412064182108667107703143",
-            "155783836458581176854752",
-            "-227172778832455276260133",
-            "212767460062823457968604"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "403503153546865033134324",
-            "286440584824595490396339",
-            "191634056603308191156299",
-            "530416421236246257260161",
-            "-317587706869080743041040",
-            "-171530648886789759204250",
-            "222798032246148363279215",
-            "72219173848107712300756",
-            "-281960273386152702267354",
-            "-495494776734887426338667"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "122137352759155073399221518",
-            "-78109201384474477075454853",
-            "-119068241308521301444272353",
-            "-108756965225823937786847241",
-            "-15428358494009873779245484",
-            "19614899796809003767318009",
-            "-115295286224016867112586811",
-            "-8633742807795124483538483",
-            "-150410722825301769338372723",
-            "124250719445278286695627796"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-99183180993590467578076798",
-            "-36808132925962854413539892",
-            "-125679607816807665333773367",
-            "-136622111609623584591267546",
-            "-17266188400280841341905013",
-            "-71769330665427864647331885",
-            "-145814031084605056753603019",
-            "-125056942233093610827766296",
-            "9249166279701860198655516",
-            "126878824313892664602568663"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "69744825329510933906746340",
-            "-30122586028854363823971329",
-            "22212149164944035060004867",
-            "-25973928380545009708020589",
-            "50567555142199657207098957",
-            "-40021098669624532176421808",
-            "-33330934345289112585983041",
-            "-124012214741805393399462125",
-            "-138226312121129798637686830",
-            "2273005251425309465489619"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "26842282533862498382939405997",
-            "17787994211657168910392131484",
-            "7523952681100831594207033636",
-            "18257283108725825658512455316",
-            "-15469531382712880431453128966",
-            "-5009369258227088832031787745",
-            "-35598690213497115663830724084",
-            "22246953732785347649151349772",
-            "9330915514049730010034508310",
-            "-26800441656550330938009306707"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-36331212919615640889272411104",
-            "36192450254329815033783240839",
-            "37749265523377026412760210674",
-            "1776086174556031952147671519",
-            "15362218353534633991283119679",
-            "34413146026389235392142970662",
-            "14292777901465553588604435837",
-            "-17090082469158479303098433453",
-            "18688801441734020761551793736",
-            "-23859805527670127110643731069"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2220103303731789573334199701663",
-            "6237111177014715580774407162796",
-            "-6338471790385983381447055194941",
-            "2250388387229112362557012222382",
-            "-3919498269201660475165992143963",
-            "-1799934177913445118487985955729",
-            "-2323304519983949754039480799426",
-            "-1301131662575316944670816531905",
-            "-4265160933868529886993472786495",
-            "-4292953046034527295812111533975"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-3484925219213002239805523064883",
-            "6528552859477682991951516050785",
-            "-765962107198382441283095455373",
-            "-1397137479831402026027607048248",
-            "3961682476407229854971103624981",
-            "5975195883181022585096451556775",
-            "-9676800477604513004081790052790",
-            "-5703219619447316623534739055181",
-            "6129137758274201914352345247446",
-            "771936840958552475578155475366"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "7726836802487400261012835642739",
-            "-2899737712900797452349686903367",
-            "-4699841764135292946953397202917",
-            "7418179251651709234455608105088",
-            "8120397131521471010221697932900",
-            "6526213244777384369820937871939",
-            "-3774567743925527043971960901589",
-            "-8873736034246294395374537274419",
-            "488289844645088756680442972516",
-            "-2388144175550709792515001316277"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-47477340538926222211104914237698",
-            "320639937921939986635581989855928",
-            "861736289842228881011999521004060",
-            "-1205256013177842982651274099236361",
-            "-39643995957385740378372042150003",
-            "-1210790336528949301250817830946444",
-            "1182423445445031739603473987778350",
-            "-640337212803879852231150942968813",
-            "-567587726713873060654848198630762",
-            "280641360776654488558911759135115"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-866285575875610221959113146637304",
-            "2344770413948196340883160931087052",
-            "1889857580890564350097047877514790",
-            "-2568726710340227178480991779371723",
-            "-2485213596075291138559974328614959",
-            "-62378076407090361966505761644273",
-            "-2113433394374145039336066697772466",
-            "-2389429054181728925012886258903305",
-            "-2525262726376576108925615177598533",
-            "-604526323558062739370715910785200"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-411175611485478784812936027850047826",
-            "457804241550769132910430204506150717",
-            "1549607974636127184352732575182742",
-            "390025168459008888512891394303962448",
-            "-490664276836807094735857019444661312",
-            "-450640457243898505844766529165221166",
-            "-553339316764622659577593048830066531",
-            "19986969431028149966548563329309114",
-            "512190967497020823088167980283378342",
-            "-587244163212803971173675798133411979"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "246512063483920590600659938977719645",
-            "483324212708049237205831199756205159",
-            "195186088040813738593870463346937474",
-            "-331572691964567402179138728488891845",
-            "466186594735574058231047101478621597",
-            "80512186957271594252263140708656889",
-            "-621018503026533776126752549530840325",
-            "-484705410290628923401085082564299400",
-            "-322852670767952007714303037031011136",
-            "306969564371703225579907932616560177"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "52513592802194657300546985265901321701",
-            "32396354459564619210286503831104805894",
-            "-152800597997887046528471654246818061800",
-            "16886738551251131147537573820997523099",
-            "-108529890244550965992486427743581407764",
-            "-107805100101953838884357149548341742683",
-            "-152428185005223769908895650096091179800",
-            "38697638049920608411728929261890502602",
-            "-53183835204559125450983905289890638199",
-            "-25198915522830164616311861007733226015"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-29473659368749332611063061562898178665",
-            "-64181392425515474831866849063339846755",
-            "90557155313004461723928910484647118568",
-            "69982410088115917703700629187142714952",
-            "137281427883875761429267863353473899975",
-            "66221749426872522877433672036305282198",
-            "139898216716793863940328165403822713329",
-            "-17999019985160863257629297875199464798",
-            "74582888771441381839018581558057879959",
-            "153431389525940565745457493557728519648"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "132130437221517226508875210221998086214",
-            "-53955540660976668373224815268780394481",
-            "-94671974318719360571824313264981742616",
-            "75940549933612625873217731049581943788",
-            "-58970299111050400318748873232294460623",
-            "106861808580585226388022589188291458328",
-            "151810935532684619700572858784852122078",
-            "147244409300271119764509412340177481716",
-            "139138676242120433411406371456479693081",
-            "58927563101546159870009467050083778558"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "25114",
-            "-12925",
-            "-1074",
-            "28646",
-            "-16569",
-            "-16770",
-            "-27151"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "26533",
-            "12085",
-            "25312",
-            "23445",
-            "13356",
-            "-2369",
-            "-29785"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-4380859",
-            "-157657",
-            "-4200925",
-            "6061632",
-            "1972423",
-            "-3016747",
-            "2864606"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7045373",
-            "-7371800",
-            "1427921",
-            "-7601068",
-            "2525157",
-            "-6433403",
-            "-2477014"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-141345816",
-            "1543059503",
-            "1211501603",
-            "369888761",
-            "894246844",
-            "736166799",
-            "409408642"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1553193945",
-            "1491657644",
-            "376067040",
-            "-1100453955",
-            "1763626627",
-            "1237652218",
-            "-1680624462"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "102290167",
-            "1044278987",
-            "501196467",
-            "32275276",
-            "-1384353672",
-            "594927697",
-            "-1482240101"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "431716525885",
-            "-396649752792",
-            "-252538061544",
-            "148825582538",
-            "536082535524",
-            "-135755487371",
-            "425356768774"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "137916147840",
-            "21393720222",
-            "-325824439981",
-            "278743651518",
-            "-49501503483",
-            "-419736800011",
-            "503854890502"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-137642247974694",
-            "-126053382015273",
-            "32896127803947",
-            "17450989064436",
-            "-120690899531858",
-            "109217312768874",
-            "-79259001409277"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "114207744387703",
-            "-79306413416767",
-            "139536513022560",
-            "-98423452444221",
-            "78791182271051",
-            "-35285009371089",
-            "41940974948329"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-27264096490547",
-            "136834819442083",
-            "-27088394932437",
-            "-98987047379901",
-            "125550952272750",
-            "-104804800493942",
-            "8768888141448"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "23677368293754508",
-            "-30279797614274598",
-            "-30317510840672041",
-            "-3538291640098903",
-            "-2087381848617356",
-            "-23713764981307104",
-            "-11713886893415435"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-26406417185878787",
-            "-14282719185754107",
-            "-34042541212866444",
-            "24219940349910515",
-            "-23950715983191837",
-            "9125287296093962",
-            "1340350995572397"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1175386256159753067",
-            "9132036865814002849",
-            "2073302245565101007",
-            "5198424551239400626",
-            "1162180176286851142",
-            "-5469754044264044482",
-            "6861255327733562384"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "6025723723135521005",
-            "-7217621567135194958",
-            "-875939541579707257",
-            "8236552400788004405",
-            "-4353971909177851416",
-            "4189966288831554693",
-            "-2170856197554954993"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "1984509802579054321521",
-            "-1041998696764751045250",
-            "501861238173417097382",
-            "2266100162043156929049",
-            "1092677900985431385639",
-            "2290545820208575246231",
-            "-1929677784513148966088"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2343674427840265383765",
-            "2230129800929309514822",
-            "1298773822649292467354",
-            "-1658379353955811152293",
-            "460872411226138227967",
-            "-366025556585308681996",
-            "2303266251171038691928"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1553211803508188723315",
-            "-307288386314104261659",
-            "-147859719179575239406",
-            "316737260848156543682",
-            "1901202079912459192862",
-            "-2066795118493461325326",
-            "1097271871910371248765"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "60159431599803576006229",
-            "-349523214568312595512352",
-            "-479410413534686721947634",
-            "-438205000235664595511857",
-            "71434087716492159731908",
-            "313701681861148862347175",
-            "592529110781630294785385"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-41073349320046663529611",
-            "-460196612402794801624059",
-            "-85219737286050217930644",
-            "-430653003445193867062723",
-            "212772177419770007462828",
-            "533773505614581994442892",
-            "588510537528110040152211"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "31643252440554433191940460",
-            "-93699577774061168478202291",
-            "24154537866604719834628304",
-            "30696729192090200230120983",
-            "-99615616997150346574018879",
-            "-570384960873190266772386",
-            "60124053065001805618112484"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "43634928021314649415598611",
-            "-71376931904073326185512276",
-            "-24045621000779198743707062",
-            "6686912739698933453916262",
-            "-154458317914070878667147081",
-            "-48373280695426803475799028",
-            "76169691954204618596160986"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-114582957647416816237217281",
-            "-12748630690377976467956388",
-            "111731504296816655416680693",
-            "4019447671331190931268009",
-            "82801431291231910751983771",
-            "108497088164927504518108753",
-            "19137086084026561540969316"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "11411634354069865542863757714",
-            "4367992064855387626281818334",
-            "21423224512954024770097152486",
-            "-32916059460547773682793752250",
-            "-37598962143905700881222660514",
-            "-26791606874412750044572561764",
-            "-1640980913390047815572783266"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "34745452020371732029340755584",
-            "38633937182521363276851366299",
-            "13907386367292796497248233421",
-            "3516712513415277325145153684",
-            "3056849635253718194064084992",
-            "4551068805171087267034288791",
-            "-17898292752703455443559461457"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-782556900320991870801777710984",
-            "1691629456944775593578700272292",
-            "-3817502570462777233621604475255",
-            "-4582592814198566350977961347647",
-            "-8757778015646360699558792162096",
-            "-3372484932226680791305443517921",
-            "-6773601661940427910934854617600"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-3034111110316845464241842333639",
-            "-1781275911958673372639492265462",
-            "-1931637931243318072822423804991",
-            "-2889899890039585265079105752268",
-            "8441716411760182969194644963692",
-            "7571628885131553956380784504990",
-            "6417570389157484165557130988430"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8637275815739683704408877390855",
-            "-5205784754631510403458931812287",
-            "5903473813623392609711242445408",
-            "2196392642166569937732303950298",
-            "4322897470867933044080337659838",
-            "-295215953845026604294742492576",
-            "-9707682435519997757567927666374"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1371746941161753233161616198879974",
-            "1982136493212029919715565342281105",
-            "-1917002754487970574686778478783266",
-            "-57865905347137694987990288364929",
-            "2249945384795180946501174810954490",
-            "-428951216116914987102881673111066",
-            "-2274002923925825152016895839891593"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "1092814442698298966273488282610980",
-            "1144413745884554568972739530468097",
-            "-75300812750583864582975138768425",
-            "789050129071516591209015420836704",
-            "-1164029127634305816704854164256453",
-            "2432154715761013584642826292686689",
-            "-1892357160522293273795945838702878"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-122183630549108645927458587184832899",
-            "-243792853164469971347092559188097429",
-            "586041069230257431808895634457019729",
-            "643508290616316791666365172242311322",
-            "140267869100082091472571196986321703",
-            "367901398863058047260102259430609991",
-            "663427402521611050810057766609452801"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "442484503124860279043087511624488704",
-            "-281538291396564587147893059598980836",
-            "-346402069367877555608660697944397703",
-            "121136520298204023131218573046733183",
-            "-297635365268234967618402017598530084",
-            "-374122180189017501660740031013019545",
-            "-581737813428791636660311570131585053"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "133154724605091554639809801656916837785",
-            "75830729335101076443136841481038070489",
-            "120313524491479335277638759335459890905",
-            "61287945625316584877200472317882946434",
-            "101401636551502086495943764753580195892",
-            "-67491973819108763200100227319414962675",
-            "1469727002050376143004735317308620121"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "163689960486968830624238755496353069266",
-            "120222413117901199440645458344006405188",
-            "48580226284038590005071569547583521787",
-            "8088270627535987928187148843962238997",
-            "81865070062931483309512859489282733063",
-            "-10237210340155912860809619233603401462",
-            "83075135112485276897941678118419444602"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-165871274022360766986351083915813500328",
-            "-8686579665026772053190367047771284024",
-            "-159204341085506490972656979604179139282",
-            "109873262356509061148465005250720029433",
-            "-106075570921623241101438726440228153847",
-            "94260033293871207317716609052204748035",
-            "-20194157317096074536517680199183372407"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-30954",
-            "20758",
-            "27427",
-            "20450",
-            "3843",
-            "-28014",
-            "-9284",
-            "-6624",
-            "17505",
-            "-15123"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "685",
-            "-5310",
-            "-781",
-            "-19286",
-            "-2510",
-            "-7200",
-            "3827",
-            "-1198",
-            "-27211",
-            "20037"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "805128",
-            "-8334205",
-            "-8322011",
-            "7348287",
-            "-2733195",
-            "426429",
-            "3846540",
-            "-6903563",
-            "6889801",
-            "-7512693"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2488446",
-            "3102298",
-            "-476499",
-            "-2639540",
-            "3282590",
-            "6092430",
-            "-1675823",
-            "5601386",
-            "1196495",
-            "5499393"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-30691203",
-            "661960132",
-            "-1935743351",
-            "1575466801",
-            "256013883",
-            "1160657488",
-            "-777972530",
-            "-1493606470",
-            "486831696",
-            "-523869499"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1802142466",
-            "1751466925",
-            "1524761681",
-            "1127842279",
-            "1711088497",
-            "993428343",
-            "1169779239",
-            "1513015569",
-            "-1133724977",
-            "2014476536"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1960388178",
-            "1348475329",
-            "862499131",
-            "1640384591",
-            "-1548686121",
-            "-109978873",
-            "574685145",
-            "-1936942220",
-            "-828064162",
-            "-2111967247"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-10546471442",
-            "410574147711",
-            "-159310325390",
-            "-342068240706",
-            "268451689904",
-            "-188950021888",
-            "174863595081",
-            "75886283067",
-            "204533910683",
-            "-236375793932"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "395399290333",
-            "398808017348",
-            "470458425747",
-            "544514539160",
-            "106030474107",
-            "-220167092355",
-            "403504352884",
-            "-215936236845",
-            "157621638402",
-            "-84528308243"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-11872483439739",
-            "27198663837500",
-            "24092599125599",
-            "94647109181593",
-            "-25234549831778",
-            "18418685805939",
-            "-48015201340553",
-            "94192389246447",
-            "114313155048141",
-            "-8129249986173"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "77060681503342",
-            "-17103335031331",
-            "62085210064375",
-            "-4113774722062",
-            "-39621802698178",
-            "82862411524800",
-            "-80722206760975",
-            "-71853038428164",
-            "74451847897808",
-            "138561565698569"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "11425892925558",
-            "-1067102949941",
-            "-67195834692311",
-            "132254465032616",
-            "81094671882564",
-            "-16512810337582",
-            "31369523023438",
-            "-25612899826767",
-            "-92714617670958",
-            "11132766799365"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "31425051479846585",
-            "23658872883751119",
-            "-22841020643211561",
-            "-5901149141492493",
-            "-9081601009126169",
-            "2009456704881039",
-            "-5853653315964572",
-            "-17548466661612427",
-            "31243548103064502",
-            "-2990459100082881"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-12114077651218054",
-            "34893217784362181",
-            "20057977432890552",
-            "33560592225527770",
-            "-6087365862911550",
-            "35528436105980777",
-            "-18908989690611601",
-            "-23450050973056772",
-            "-24497468547358805",
-            "35295281517022055"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "7512947852738829754",
-            "1506648420706893967",
-            "5351706185125823777",
-            "-8979604389662071296",
-            "2474510455479584357",
-            "-979503341239819500",
-            "2879236724021058276",
-            "901640783116791589",
-            "-1968701555733090102",
-            "9048825040146306689"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "3527698479739214995",
-            "-9168040692056637587",
-            "4303558786305470137",
-            "-6434168737271011073",
-            "-5987724165431090257",
-            "-6342874047925994892",
-            "-5023544862753808662",
-            "8349405051483082410",
-            "-5427848340450674266",
-            "4416839962565899579"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "122719954361389244782",
-            "-1715029242671728269265",
-            "1046814468132539634758",
-            "1829993007839921437821",
-            "1961163586998902612001",
-            "-1718264963912709868519",
-            "-142775659012283376739",
-            "-227979474167608252692",
-            "-1284136730697963933939",
-            "-1188947702777815289337"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1540168519262718909498",
-            "1444272924270897021948",
-            "305426275834034841423",
-            "-2023121412074327344395",
-            "356123154623624533101",
-            "1851993497777674677711",
-            "-1548911725567051530406",
-            "-1688091710111258813903",
-            "547593933625451476915",
-            "-1136296230783566148328"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "93977861990199039012",
-            "-725203385003516503766",
-            "-2136208269275109184730",
-            "-1443758672222546024674",
-            "1770464701250178930017",
-            "-1503951609214983767704",
-            "580922121807638712625",
-            "-1715487409849159976347",
-            "-1581681782950208904546",
-            "-345107986036541695760"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-112509459909310806801713",
-            "-318071601726453617114288",
-            "-377093818504933877006627",
-            "-412251199154230320946975",
-            "14121963032451866972322",
-            "127959674785194294868765",
-            "274741358639653860200873",
-            "-10201412639728798865544",
-            "-484633295332684921844249",
-            "325728689994021020089522"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "102768059460000020082850",
-            "-582172705216901696514361",
-            "385654623152916059129826",
-            "-375444952943658610617412",
-            "-559762648769206534338228",
-            "-455225699143700230588676",
-            "414928288856671138989242",
-            "-239573759040735488345533",
-            "-151621506107277003038408",
-            "238527569805762630418752"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "105793826786409638098848324",
-            "-105930031172236153458218556",
-            "54215836825825339383685314",
-            "153999900608311376451254881",
-            "-60781620142763268768239184",
-            "129045242635307916195795557",
-            "142609636641396599505824777",
-            "25997822165486291786720766",
-            "-24843271142157773732898696",
-            "27667985603420108003309363"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "151727563990526262987631020",
-            "-153515663086836104138582144",
-            "34269843807095303273290014",
-            "116745487266501279093435997",
-            "19697558732934548814393639",
-            "116467090539752813149322652",
-            "-49597590215015448554625243",
-            "904912798075267997581911",
-            "-39665579024769081440226797",
-            "-148107902864927713797008511"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-83573886433003161782682974",
-            "-61690975717719632051567161",
-            "87221161283509159769937332",
-            "1424308408986182936520347",
-            "-97659156978716488999314621",
-            "-17069082270469318857712868",
-            "-81196418361561342109282996",
-            "89508773441843844208807904",
-            "144076371744089019894053325",
-            "46698503394106850398118272"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-4870804024939332050762868706",
-            "-7019153028274263100384076399",
-            "-38347116871041435121142912404",
-            "6752651380046831311117204924",
-            "32477977767491441764479499613",
-            "-17206384783392201002575380629",
-            "-27155762594673709466833763677",
-            "-7707471006910257215683844696",
-            "-12836204732773392557927387161",
-            "760807996077187416324370561"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-17307596853554170302945978542",
-            "-29291868274857325327495085418",
-            "39520334649804167187543012083",
-            "-29850376686502020869058128768",
-            "-7769023746550159417970381944",
-            "13728883947958157003762954783",
-            "-32237971097073321264822351426",
-            "5786340858732715593319648571",
-            "16603037987628417795944460761",
-            "23450906837191853879925326964"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-9980201576657945144842882236365",
-            "-7407461373350157855602680465891",
-            "-8849151930540839739287729740462",
-            "-2082450369562757904475450406520",
-            "5688213649545258906102340952545",
-            "8532260187438278666751588130781",
-            "-102084121821929763174388250038",
-            "7229993189261659865189536694418",
-            "6276298854863176977991964120714",
-            "1342743900941457696012670661953"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2978344615310830117461734259477",
-            "-2947273335992494396678516995826",
-            "-5244820858348685929338162101277",
-            "-2640927544212422127465200234510",
-            "1768434382958061290101667511624",
-            "-3963482937808073490523756242168",
-            "3374307591928127235727040204209",
-            "-3382678138467009217749439169317",
-            "8801701051040866573946377274029",
-            "-9104355797002943521132479841900"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "8221768927807895270484160091896",
-            "-8900000026189067281738645101281",
-            "-8281746127211712061601232308528",
-            "3023240804949676140399638485768",
-            "-4102245491799843728882823944331",
-            "7251501339276578447235263420202",
-            "8751503650699867906907117450087",
-            "-3729506782195610335248190443752",
-            "-10033160781867769412699287534647",
-            "-1250783004758791761527983017975"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2562167817474569120675956515425419",
-            "-2458571516901048848163704156892937",
-            "-36875395321508089748922725678113",
-            "1960304726616291730330575204501959",
-            "2055550886455178489271580894649114",
-            "-2358720546112845253144262770181075",
-            "1595191993485611135276028859826726",
-            "1566529993850113106475509726619617",
-            "-22596759305941524381058617032547",
-            "-498743035152497361574808016716787"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-47643018102478418616183822213670",
-            "-278640293644733515826236620350821",
-            "-1488199042811674371836519886289180",
-            "-818674521344108691664748392501099",
-            "2556172025333762565075594479138752",
-            "-1334377085385061017822352624180696",
-            "-2000158271833880683895816854711292",
-            "-368140045799924875460317772104607",
-            "-1585782388250425609895544646403971",
-            "1824564753054254497659039848918675"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "479525603135366804733516578850615870",
-            "-495446691382547674716309382436075953",
-            "502812585466542988435075354889645892",
-            "476416535889813426699310670064638917",
-            "-379315281173603247308987567117630647",
-            "607404279943635423469568736054452550",
-            "-629067677540132407295995323971248814",
-            "-62158935415489079301126585948586031",
-            "461986658609980837096262131134918226",
-            "-589275703863823715586136613904443930"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "435625147644630830418626494902722848",
-            "-478332198115914941416962365458575509",
-            "558636662901555390631163102871642769",
-            "355599683788663730974008140088569567",
-            "415606584067363911029530290237838841",
-            "398064603694355571202936926109341982",
-            "-633945976114528848016756385029022841",
-            "457577785385893587465074783208649049",
-            "-616523624972085533886453431515327099",
-            "-248511133054735912122810606062669023"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-57306327392984906276930890383185368223",
-            "72793461807811385650658673069344386369",
-            "-109687531415068367399736525485032846349",
-            "60356410425087146413082196521754844149",
-            "26662652717210939669243284822836719981",
-            "112603258741679461947852680773641769673",
-            "4457422288602224460620455185955042948",
-            "103794515803470385910175949232361042030",
-            "-119185317915451074176129503358012831945",
-            "65467100518198811141064173626789800823"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-68618397724637272526572961589871509577",
-            "7721187761487257785999877840186156513",
-            "5605947584439501391665551914895560442",
-            "68369687165773392157960709162408033710",
-            "-96656920099210957452259257889912964672",
-            "-94072454264796947158929675025216943665",
-            "144069747100296579445022554416200691423",
-            "-87560734517757835226646920956502241626",
-            "-136164322966740604273148909571047647101",
-            "19429304069228502711385669535598831748"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "68390208110339728548757304121957739423",
-            "51149440950819465758183122582606174618",
-            "12265984607323358363395800066794656038",
-            "-150000242236153252396886212934934551728",
-            "122779026475879408492238567997677881221",
-            "131874778752322502170775011108192661329",
-            "165901435173219254996114701417463409790",
-            "-152003734738506573690620489933044183326",
-            "156016528459691385523457640405842540870",
-            "-74618395994120066096952180078019949350"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "23815",
-            "-30659",
-            "-17127",
-            "-19868",
-            "13628",
-            "31416",
-            "18133"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-22400",
-            "-14679",
-            "619",
-            "32351",
-            "-31747",
-            "-7719",
-            "-29774"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "3520430",
-            "-8276056",
-            "-827609",
-            "2153003",
-            "178182",
-            "-4215376",
-            "3779312"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "3689483",
-            "-735347",
-            "-5360898",
-            "-5764362",
-            "4660427",
-            "-7905626",
-            "8154092"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-706829888",
-            "1167156309",
-            "1518125729",
-            "975860423",
-            "995194446",
-            "-1865080408",
-            "-665865487"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1701907448",
-            "1352934836",
-            "286059016",
-            "-1400717695",
-            "-452649966",
-            "-1922657966",
-            "2070417333"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1935351572",
-            "765282566",
-            "1987622027",
-            "1741583735",
-            "932400011",
-            "167151325",
-            "-355472668"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-396859212345",
-            "-358864231013",
-            "411692595169",
-            "-32032800170",
-            "79797592838",
-            "494642730187",
-            "482700694650"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-94529105733",
-            "-481091693177",
-            "317977953065",
-            "427273590013",
-            "-227681357693",
-            "99285197947",
-            "-49749811753"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-117118949406128",
-            "-16338400756989",
-            "121098098144191",
-            "17786074861365",
-            "139116588792903",
-            "-104900603769656",
-            "77460829002909"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-64152968257972",
-            "81807906354014",
-            "-9962726454967",
-            "86559569733926",
-            "-10083720575770",
-            "-14825156695938",
-            "-122499888153949"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-133378720489228",
-            "-59578984792077",
-            "48240930882493",
-            "-81399868956224",
-            "132623478058564",
-            "-17946185246720",
-            "108220579003501"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "27603984537822762",
-            "24285467590617142",
-            "-24610833591141255",
-            "-13707671138044065",
-            "-24079809168036321",
-            "-3426285774015157",
-            "-16661207174485960"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "25341970114930753",
-            "-12578463204570261",
-            "-27319367490414208",
-            "-27862145691252063",
-            "-9374098211284058",
-            "-224593245961164",
-            "34774375621000453"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1508260868549245163",
-            "6273375209195432213",
-            "-9078384653770555315",
-            "5236211367446183278",
-            "4843815885489957283",
-            "-2504671565165730378",
-            "-8947215402970277018"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7409921464496531061",
-            "1356029422123982187",
-            "-1364654770344853581",
-            "8837499222236300067",
-            "5132751121490100122",
-            "-502781462678344483",
-            "4467369067622920214"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "2154925127820502346293",
-            "-1306492928287846607375",
-            "-278826605081884366316",
-            "882916332012524932211",
-            "1867667626776166611792",
-            "-1257524031015343087488",
-            "994948667658237479955"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "539210603887413500119",
-            "-1351832695016986241156",
-            "-1062904294743508083575",
-            "1450483825798880009652",
-            "-881626741922698995815",
-            "304292780803779267384",
-            "-371319374125766711584"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "243226565466619142907",
-            "-121955990464408141742",
-            "-636816055580076932255",
-            "-513308924855956320428",
-            "-1586486017550068684983",
-            "-197644649227952900350",
-            "1748345750409685925848"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "202061337421568637115802",
-            "185405094041080393854566",
-            "-147903622544387135396853",
-            "207229453925763208622831",
-            "-343183304767942752569844",
-            "-263692037517810930229757",
-            "111266436442025136177952"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "36355222093341524385642",
-            "218768782508355752146729",
-            "-200541398482024855947446",
-            "28474517856269610750246",
-            "-475859723844988539708245",
-            "-300510275404419103333742",
-            "546674288910101331332936"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "3601936927556237989024608",
-            "-3692430919094941422100028",
-            "97748690453108599708927434",
-            "-116661353115321540714375347",
-            "-71879985746676902756048669",
-            "-121080329577202994807755612",
-            "124157596086231452131087011"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-121811982953161783629612240",
-            "1607554249264877581531325",
-            "123072061986545439633145",
-            "-73550837036916705784352874",
-            "-117419921478539398829685153",
-            "-74399538740549801431316551",
-            "-53072519800681711726312500"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "128436901337483555656980766",
-            "113598952940587548025391029",
-            "88411366081005561182297775",
-            "14815457804520490927167142",
-            "75638196408599796922678025",
-            "-108087849560548352593752169",
-            "-11833635007482033712808763"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-6781678961533213012517697687",
-            "33224612367898641792526203105",
-            "19741448595364719290571423993",
-            "34895232778404370472470020141",
-            "12658156696934366509236475832",
-            "-1339988824059695372854332699",
-            "-15240202918093452204022855813"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-23304905447440712184522177464",
-            "38854699585363157300282622119",
-            "25197020277731879349242146247",
-            "37654843997064076575431679106",
-            "-37694332242432992461842973886",
-            "38735096335824029183056699705",
-            "1113712061187242088526216287"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "4872842181239913302717185661993",
-            "8110981189886162420036583272468",
-            "1846154365393107878136252015134",
-            "-7355182167045667821268714569976",
-            "-456342272099675035018815637968",
-            "-4741310371570496786057876108775",
-            "8692654330279187212246590575934"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "789321336877871879752144980182",
-            "-3592030043211469330492425640956",
-            "5543560868004228342173534568596",
-            "-8310481621300119615028360910615",
-            "7240613238493658400891584464926",
-            "6698325613041346941747416888641",
-            "-8117880941116130680718189365519"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-3557820883496744079071315236925",
-            "7037071399112810484115914176160",
-            "-1767092291265591600640701935680",
-            "-6045295616444022343488779010934",
-            "9259710329844166183361141015059",
-            "-1492876309663740055714983855690",
-            "-8427791476065938140828199154822"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1158759477908482981738237800163588",
-            "-1173316691740305096863218708950191",
-            "723215252639660437402175676963743",
-            "-1879559334466643497978379903607782",
-            "1983927892969038400024936381013185",
-            "1149553546691385176645909195969356",
-            "1166342561375174956477479521466108"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "626529133445278098702551621416112",
-            "-1408837087511730448581596972023260",
-            "1906905437026049050822161959468707",
-            "-1929693317190147781992957517985541",
-            "-378172107382327021537808059758513",
-            "-2104995076904948347049313544321337",
-            "1294253937974735117873956527399622"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-523256123496869429061522979056899046",
-            "-18365757383114987172474795440552034",
-            "-204316577987191697375229787073710633",
-            "330181965802203666233116582657210837",
-            "-329328597335009708600913451090602124",
-            "203539490982126102130410391161030455",
-            "417738506604065828522825064729683710"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-321000364277288528283109856107655940",
-            "580137014281216496641049610076428712",
-            "-624714144804715993809991357206356781",
-            "-407262969746696369705355949281205801",
-            "481317944191441079472434015349123595",
-            "217536632380375131817558978089536953",
-            "481697272008029766433028053959999813"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-144116647597826623855199496157914248857",
-            "52208802527320772539382939270524160714",
-            "-150911491870745668133846108351239739078",
-            "85442639480033500108059636873587453266",
-            "73892340483729688596932981784301693030",
-            "-21983833769824359378093314118115605654",
-            "155791999129521894360881202697471787485"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-161222642718655133616350033662785590309",
-            "-144401176588064295883792554624730874458",
-            "-152972600928373921945993474844975784915",
-            "-138536917768299990575075582087577539387",
-            "-162776200467637379804062098437779005139",
-            "49042684400063856845441060397203950029",
-            "95767276168967643036870259756918109375"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-39863797120385387096682208969556052403",
-            "82559022270581885556475272207184980799",
-            "117510934395578824951787214497627148540",
-            "-83476646270141960487173091399240016205",
-            "-1758233846624033403425881485773452965",
-            "-135007718267876949864445576181493416395",
-            "-141767357710928769494049512437739952119"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "31322",
-            "-12998",
-            "-6668",
-            "-18050",
-            "20870",
-            "7407",
-            "31517",
-            "30964",
-            "-19025",
-            "-26502"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1882",
-            "-19708",
-            "26796",
-            "32398",
-            "-3699",
-            "4487",
-            "11540",
-            "13472",
-            "32388",
-            "-24551"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-4766986",
-            "6654828",
-            "-7036686",
-            "-5243986",
-            "6660194",
-            "4688952",
-            "-6565312",
-            "7846449",
-            "-5876806",
-            "-491641"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-3816976",
-            "-5268710",
-            "-1742516",
-            "3856652",
-            "4463747",
-            "4089790",
-            "3013827",
-            "-2806363",
-            "-5993564",
-            "-4334975"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1939111885",
-            "1089839138",
-            "-423110561",
-            "-238112023",
-            "-1060805567",
-            "1288567695",
-            "820382341",
-            "-1689688269",
-            "966765872",
-            "-1935608267"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-806572859",
-            "2123921205",
-            "-1951507311",
-            "-1152859862",
-            "1529442938",
-            "1573780525",
-            "374401763",
-            "835164738",
-            "41728321",
-            "761957516"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1756123501",
-            "1520929506",
-            "-284683124",
-            "1144653924",
-            "-552942804",
-            "-2120298060",
-            "30126814",
-            "643208321",
-            "1693512950",
-            "1968260177"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-543650305893",
-            "-278464771584",
-            "-373909651582",
-            "549153445885",
-            "-242295101951",
-            "491322040017",
-            "-328958769652",
-            "-24343088729",
-            "379399746035",
-            "-103071495012"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "445831171065",
-            "223984208224",
-            "183764160166",
-            "489898253722",
-            "-352256812260",
-            "132712896758",
-            "-213452847196",
-            "-458421076936",
-            "-337947454298",
-            "-466450812833"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-124879858110290",
-            "135519222186375",
-            "85699747562265",
-            "-85042659127554",
-            "75573515688713",
-            "-58488578730867",
-            "-41028103971674",
-            "50130623698029",
-            "-47534808179200",
-            "-74283087483722"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-108796237752434",
-            "-77267431737175",
-            "51570892952731",
-            "95335199636762",
-            "-120149530213851",
-            "65347251353625",
-            "-20627278920101",
-            "-88198554155288",
-            "-7858756951448",
-            "36719638530326"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "37989750263669",
-            "-7110474133358",
-            "-8142079359472",
-            "-109838866716358",
-            "-109570651345817",
-            "-54071131597599",
-            "-5091765250455",
-            "-88967218959552",
-            "-26610598798817",
-            "135506189432092"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "4927887103256557",
-            "-18754894942080393",
-            "-4912007726659186",
-            "21247575662236694",
-            "2797426944150268",
-            "-6616351412144510",
-            "-11858257489510497",
-            "-23188104958701432",
-            "-8877819571973802",
-            "1148489375738940"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-7825477566817051",
-            "22013917265275897",
-            "7697670787874498",
-            "-9332621858164545",
-            "-2912282090647944",
-            "22112963575670946",
-            "16681702598755920",
-            "-27753683646566454",
-            "6945904955659446",
-            "2442936651087792"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7675767189136958218",
-            "4376177190988076013",
-            "135914493625679976",
-            "135689732946467188",
-            "-4157597916871123429",
-            "-3202587243297732574",
-            "8570927145651867846",
-            "966150880672931514",
-            "3340433868757095215",
-            "5044440160311120876"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "5133284943736156946",
-            "4845520967720236486",
-            "3808412010600114265",
-            "2390070001401807490",
-            "-2075341331489173819",
-            "7269598711719193440",
-            "6639116030361989708",
-            "3990965590531735058",
-            "6049354888289615042",
-            "4801937515511789680"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1064355765009099408700",
-            "-321943498165958622892",
-            "1201671142156144011576",
-            "1520237466996047474259",
-            "-58924034610474786199",
-            "1188600272040920538189",
-            "1973243532799526539431",
-            "-1589754043423107159161",
-            "1069084636593819465866",
-            "-2225914539586890120093"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "612790270140756043932",
-            "632096876907248352897",
-            "-614445606437892415535",
-            "-1538574921109377688884",
-            "686539122267683104890",
-            "-176896054618733272731",
-            "2112326625855675905778",
-            "1807700217188087573935",
-            "2250554304073443683530",
-            "2138601425060065078780"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-2178158937595239087007",
-            "2148658261965542925597",
-            "-1786860273154704658204",
-            "-2284942685968830599534",
-            "1135179943332399887722",
-            "-1850089368721794824531",
-            "-2107516150972307207136",
-            "-898833291339509074760",
-            "-1560291136165671096302",
-            "635830273331647493827"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "545257608208761234784401",
-            "-478027394265681567220331",
-            "23160102878411060468572",
-            "169851178877058380224552",
-            "-125063444295476267854414",
-            "-511661104901652851551160",
-            "-211091539176940271013432",
-            "-260892604441446245832984",
-            "334071806187190766343296",
-            "225652640236774742401805"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-125435440033823628710650",
-            "134873701855643950966740",
-            "-327244905598551933045573",
-            "392112435242139096124146",
-            "-392770190944746034104800",
-            "-444456098660755532238056",
-            "1948570436020667687581",
-            "334511617766662717840293",
-            "459630175785578568834194",
-            "295768689726958240598895"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "110764581191900446903790037",
-            "-142251040052070922679906758",
-            "4521074766144521546724589",
-            "-77954834062755231010987947",
-            "132206695009844374949071160",
-            "-115611166334940287023117326",
-            "65706530528500814014886945",
-            "132926781394523064114813219",
-            "56946888735676586779415707",
-            "44978068193037238045912896"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "79398695417455848981455196",
-            "41296350950824030267042588",
-            "-44890473232271813368854431",
-            "-93845863653461695811544157",
-            "-87673990780796119057141077",
-            "-79728712608821225741329213",
-            "133650017782788394397592147",
-            "-113944397482899885204627134",
-            "8147591003946322262360118",
-            "-88347016701263595509923031"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-97315706287462853410250215",
-            "-19297884994476314092921079",
-            "-138156245563462225217055556",
-            "140082648536915847982187381",
-            "-116717372906786739105728127",
-            "74725068650981797124372774",
-            "115115819529181418953999340",
-            "-104692994218324284120901952",
-            "-9339214268717197582310194",
-            "34586415164615511096229871"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "30452540938400888864313250312",
-            "-2802879378440933700326909109",
-            "-26896580846052300048510748778",
-            "13956100052440828740572023117",
-            "35092158772914033116097802591",
-            "33847590995690391053397721124",
-            "-6872021573016953238017942938",
-            "9337504336202853974096101152",
-            "-8139564364961519011852381841",
-            "33614459434990180894524889482"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "37905470020515740655644953427",
-            "15095043730643435565566661915",
-            "-16054339514326668180752045709",
-            "20206326378427568201157613061",
-            "36409538996611392332800791135",
-            "3986926868645572538910763024",
-            "3619435534252705282359941231",
-            "-28939638180493501947435665546",
-            "27752306518932422634994807389",
-            "5299661533164103665947907747"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "6105089286518535143859193272997",
-            "-1558013028566094088457684756095",
-            "267447018904579079104631493606",
-            "8716274064389440981111441588450",
-            "-8523502283934172783824252808972",
-            "7211587162269446695523784988664",
-            "7349202932851786545780603930347",
-            "6835046636946129018720692573076",
-            "-8333744634109651799888167347108",
-            "-2544747380910102910856810717389"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-6352412655736206068742730200924",
-            "-2123175620394690676305322433458",
-            "-8836382719876284105833993896413",
-            "5250128511200984854060353093256",
-            "10117785086990984372555197700371",
-            "-7553019007793539065221400188849",
-            "487332886938332402116864111164",
-            "-5531527231691294946689230570557",
-            "2033195130458534180764526511590",
-            "8418380572809691654984623098184"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-50075375212232172188420411196",
-            "4809924043195256813690822020596",
-            "1275374378747394211129459178045",
-            "-5194775733165378826646329523658",
-            "-8899088366764662523040904888258",
-            "-7065161673811581445863416064724",
-            "3448352081115495266715396247033",
-            "-772423708139560818203910008799",
-            "-3716422423592581053204772584415",
-            "-7073723704623872354556609478292"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "1662201874412358678818367544757313",
-            "767632843116354510741172561523193",
-            "-2574598778497120728925932302019195",
-            "822408943008991309024189274780663",
-            "1442207677524639837617120203090781",
-            "-2329938247319978136011213385811089",
-            "-844653930290095052875421889147387",
-            "597209484634644162562668851350801",
-            "-1653776464297020640113550379942905",
-            "1712355361051968314047230183856759"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-934154790921317246804917189844883",
-            "2011996172621693547547251717415199",
-            "-524198925581653076023930890792205",
-            "1460963164679956289335063949063860",
-            "916547324738412638652836279760881",
-            "-2181480489373236251201848006843613",
-            "2227194053359186942441098677400067",
-            "-2070283524814069666316978457528190",
-            "-2557886824011973362420531382315055",
-            "2359841497596077952056722100997103"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-244737191158099062140625546830357355",
-            "-558098781397099000894773898031616911",
-            "289872866815248801825838878888401974",
-            "92794478567836555966241203902901710",
-            "244269753519144613414831030049656050",
-            "488344310874378240044622887144568360",
-            "251880555776188717959293063210533656",
-            "650424241144052628672668970511093431",
-            "-490149649831311456535113419187895360",
-            "587815026061852779759502140522870365"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "372180445289567816296974210709998262",
-            "649322101444650143089117190099040098",
-            "-261315503489678515225280175375928660",
-            "-522083930998546622308238829319416419",
-            "142235256333754647127831983081551205",
-            "-166535174840652571060843789537974209",
-            "-466105320259826015444363036165976483",
-            "385149522321114928821540160206410292",
-            "-41443525693038526295999228480843805",
-            "-313051347741978666120077422667886094"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-167439439468877308797697749268322963993",
-            "-28242537581789671178678277260561674281",
-            "130587384617519710400745151774880402494",
-            "31589263496961519660807111701435015251",
-            "13326683789176912862324807380879018213",
-            "69851378199071338355039736806394653047",
-            "59447861241933516870558227322235615556",
-            "125427854769440091466924747763902774485",
-            "113841414377172020356030816155031973980",
-            "162459891215489371457804173662865844603"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-9113228729168889224553302821519848527",
-            "147906368719665671855384750115565399639",
-            "142408267705249397493244319994103808727",
-            "-158173827712728250139318830913214547586",
-            "90457292148533516388688156622880399300",
-            "-28762317200208469682474790209657754600",
-            "-147267994027501072294873134903092981782",
-            "73349578944467970931133887330177437829",
-            "-109559717261425791283100898451546302168",
-            "118124046303323736396291668012601665112"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-92141949280218575485253751932496543626",
-            "138068266350197970395619500727113936796",
-            "-57057880351028370035446451706682228912",
-            "140046511005251583337314294112597416965",
-            "5313615659947632571000091701353480420",
-            "163618210678848808873963839458536967363",
-            "-83020522347645062930841470958792915560",
-            "103388812228278752501831367543501892798",
-            "105919923091739023980005477488419598090",
-            "-15642676827816127683186187091061039771"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1173",
-            "-25049",
-            "26985",
-            "-3279",
-            "-32375",
-            "11902",
-            "31640"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "23711",
-            "10618",
-            "1182",
-            "26210",
-            "-29042",
-            "-26592",
-            "-32390"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-3383836",
-            "-330331",
-            "7170648",
-            "5645424",
-            "5519488",
-            "5932048",
-            "-2721797"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5680425",
-            "5530032",
-            "8360972",
-            "-1579435",
-            "1281443",
-            "4742079",
-            "-5190818"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "791809523",
-            "-1726831311",
-            "-306766525",
-            "1510344688",
-            "1557526531",
-            "-711666607",
-            "1285681573"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1588122426",
-            "-1825651554",
-            "-854908281",
-            "-1682899390",
-            "-386907059",
-            "1124699281",
-            "76032732"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "21696611",
-            "1114662058",
-            "-398379994",
-            "-37751028",
-            "-1858929126",
-            "-1571912144",
-            "1357766028"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-207926907151",
-            "-108845084422",
-            "483890046680",
-            "32829509085",
-            "276444998455",
-            "254643057519",
-            "162285997419"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "51727593810",
-            "-334061936348",
-            "30150675407",
-            "-331201335155",
-            "-501714900752",
-            "122994273993",
-            "-313427617689"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-38665729792403",
-            "113150504075646",
-            "-13283184519777",
-            "-122268737353293",
-            "7114949849358",
-            "-76982898428076",
-            "63703755155967"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-631968410916",
-            "-129868532669274",
-            "-138633149135123",
-            "90053223046351",
-            "130107621630474",
-            "-126528386107052",
-            "39830786351675"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-36266273353597",
-            "107910261195518",
-            "57616988744255",
-            "44429564088387",
-            "-52991708070673",
-            "18856755200112",
-            "-88910410722229"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-10733019451407946",
-            "-4637031550251259",
-            "29038597614687455",
-            "-2255766756551662",
-            "-6357871065260787",
-            "31141018628250396",
-            "20316885381831172"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "32276626527716918",
-            "1143035765853136",
-            "-35727015302634840",
-            "-26484971152317146",
-            "-32859967854440443",
-            "-32563301944872556",
-            "1238987785486865"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-8755802922599672235",
-            "-7396181851925542211",
-            "6711186749545114591",
-            "5590049579316174533",
-            "-3165569916335790183",
-            "-316326350454384555",
-            "4929314904948241377"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-397606177624923608",
-            "-8426436663324202280",
-            "4326137699230271144",
-            "6586316848218801011",
-            "-8091380893667926501",
-            "-893221278247799034",
-            "3462259882527377933"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-123690421269484703760",
-            "-1267016901460774922921",
-            "299161792651827136146",
-            "-1604897520961911844593",
-            "2037882344461012186736",
-            "1195943811863661819614",
-            "1207132107388937164804"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "2101648800869166208330",
-            "2274724666892686998217",
-            "-391260607449403060721",
-            "-539342914187070082276",
-            "-1440115909019570656078",
-            "1971609407978951853616",
-            "-1123962484080572650793"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1226504478266363310149",
-            "-1336799843493576778914",
-            "-1930283161332942670068",
-            "-1331434065508788145751",
-            "-2246411720300345670491",
-            "407117263123141212856",
-            "1931974044378992306595"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-361522891823295867238478",
-            "523641781996221269629669",
-            "493463729381734013522117",
-            "132573578585472506680774",
-            "94595327070388358792040",
-            "-475960519364994802696270",
-            "-400496792855539234277056"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-83327604823851708214213",
-            "-21750678079158391741287",
-            "303079990127928613453200",
-            "221033538070216052397251",
-            "349922191060743894146041",
-            "373614674984738281954995",
-            "35960928414177633291510"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-35263044120328302148125905",
-            "119902294752181475961380716",
-            "-143462823401917067325450150",
-            "76224465900409165961186326",
-            "129425531295697896902175651",
-            "71961437570078598659959749",
-            "-50542941964441222281681861"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "21273851514521946688339521",
-            "-114682664467937571727316318",
-            "-87665586498201782141883102",
-            "-37148627339581480801973740",
-            "148715674812065621394995997",
-            "-11949810986329503823448971",
-            "19902828440769121844807521"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-82305650498237902006296677",
-            "13405144161056810438291528",
-            "-55538748559515558770298655",
-            "47675008502605479352214681",
-            "144416507011350857414309005",
-            "29779427576479727347932773",
-            "76124247118585246765896254"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "5201245639226497436237918218",
-            "32394407131966840913830741879",
-            "17275077614546392015968733648",
-            "19680639349359359322458447337",
-            "27317116065055333169824937849",
-            "-12746107751769296292286176888",
-            "24689167759685843386070714338"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "10674526914216998427441154557",
-            "-34360582954885045536029895204",
-            "-30414741650041537218707792172",
-            "-36100155712815379900420808706",
-            "-9135627534401552379066184552",
-            "24739179676383158523222359862",
-            "36247531023134689615999840678"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "7728506401956815228532038088763",
-            "-2837122511678749937658222392985",
-            "-5052751030412737719634091683608",
-            "6267848105390862826653603709957",
-            "-7256424895588253047138206019502",
-            "-1465562444156137793663621199168",
-            "4747031647779859427140201067878"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-4615761627649385445936725928202",
-            "-10039625391960422316333169130120",
-            "-5864157091799713513469653318184",
-            "2127816811402154227868729483435",
-            "3887900797372126787242346200516",
-            "-1886685381966172685286274273546",
-            "2174897160271324780574975683648"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8147543028570098325830702033212",
-            "-8166347530503241567728663732295",
-            "-2400152589461801277732655340968",
-            "5816370023067145183233116808816",
-            "4507165196511235167888642848780",
-            "2286027903888132217006101817455",
-            "-2479439547905569438663575023840"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1828555317791876329482620856869918",
-            "-1789881062592639492432854851944912",
-            "1997518813798357124855744528406909",
-            "1983001417735981157064295426331782",
-            "-469859785106586780643284066769335",
-            "-299069863301987956957383980507514",
-            "1236379623573944194394212606448257"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "888629009780912538325980386511617",
-            "27717296778921441430770399511331",
-            "-1037544761462996724025231718395229",
-            "-2569726393180105871878430433407165",
-            "1050434002808238746161893184408066",
-            "1631428512670349250299644326318484",
-            "-2300221672111018999696902542660406"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "117708577531638404447859755168996138",
-            "499980650229427236421511725860459336",
-            "-11095778332866038210737561230496935",
-            "-545351732363151371037809309111972618",
-            "-247593431450103821518249361274651770",
-            "-237793299013077356563098927682674357",
-            "390680910028520326666704921002649497"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "451974522107762371225049594944291931",
-            "-105576308356387969354658158113358895",
-            "131444584597404940972776636357533837",
-            "511081773875049253533205440188898072",
-            "-152320758908721137229679446546078860",
-            "440168332116421922278190781376074082",
-            "422466258163678281216225964929359699"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-157339119467114553152239726866392495",
-            "116897764313121017716807765578012098753",
-            "74820773589003012395258853673597787962",
-            "38832900549006200655588104913719049413",
-            "31809184412064166455927543375666243747",
-            "-26330135739473810705643960803773520617",
-            "-118932439894932248602393041154357721181"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-25109297380056962038867001208740287232",
-            "-41675596142284332174303529214392893663",
-            "5630763719989167974840000823279633369",
-            "160052832392163305375298352935547628724",
-            "4354500338288930103695848603658025851",
-            "-79240341020657408457197673660870174461",
-            "-105142963009963436353607279364134642269"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "98982080008354791864222553245931141612",
-            "-14255476744570986458215294770192518639",
-            "75075249011469661237617297182263259411",
-            "9960334250615541536807663596098652831",
-            "77610568733923384998121313535231559129",
-            "-124628932104686355631960480356638386284",
-            "-54909581662559425139035632209125077908"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "3832",
-            "1722",
-            "16659",
-            "30179",
-            "-24098",
-            "-17484",
-            "-18903",
-            "26194",
-            "-29015",
-            "-22705"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-28693",
-            "-22191",
-            "-31428",
-            "3880",
-            "2222",
-            "29307",
-            "-1198",
-            "-17255",
-            "-8873",
-            "-16187"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-3944372",
-            "-7965251",
-            "776136",
-            "7478406",
-            "479063",
-            "-5101226",
-            "5809084",
-            "581754",
-            "3714208",
-            "-78676"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2197720",
-            "-5978443",
-            "6040915",
-            "1115058",
-            "4078042",
-            "256907",
-            "93983",
-            "5378385",
-            "-2933287",
-            "7437051"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "461104817",
-            "-336460791",
-            "-1866209508",
-            "981614060",
-            "-496512504",
-            "-1842967640",
-            "2028811575",
-            "-108083496",
-            "648817093",
-            "-911531546"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1855062455",
-            "-1848423958",
-            "-417919719",
-            "-1550324221",
-            "-226454251",
-            "1897143013",
-            "-1816207352",
-            "-1890930858",
-            "-1050656588",
-            "1380332427"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-125228080",
-            "147425902",
-            "-1803257123",
-            "1133430594",
-            "1104179937",
-            "-1155651362",
-            "930863958",
-            "-1372345558",
-            "204045790",
-            "325493759"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-43969925332",
-            "-423782533903",
-            "410599621485",
-            "-384348480285",
-            "410563996751",
-            "420331896854",
-            "-451260071343",
-            "-239682713334",
-            "258658798561",
-            "-490359578846"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-117878031314",
-            "160469154039",
-            "265139111256",
-            "479577383616",
-            "-359749140482",
-            "223868593231",
-            "-322904355205",
-            "350722353309",
-            "408233732665",
-            "297350052059"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-11402130119583",
-            "115585152210399",
-            "109875950346614",
-            "-26937162370986",
-            "81368062928951",
-            "-101279737882071",
-            "-79021567150608",
-            "33691525873326",
-            "94018510142332",
-            "110175572468354"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-10950828627484",
-            "-45009616517875",
-            "-33740390224925",
-            "14272990246117",
-            "-77929003338940",
-            "-102300441781475",
-            "-88070246222892",
-            "46505217555818",
-            "33852556004566",
-            "88581112696689"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "120432203274419",
-            "-15955787808560",
-            "34948631108647",
-            "-15994595995724",
-            "-27803388562197",
-            "-63066930361908",
-            "-3386645943750",
-            "41101017052909",
-            "46443568439036",
-            "-130299379020281"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-31001354878037938",
-            "-760641451157916",
-            "-4527935698981333",
-            "20422875389727418",
-            "-25561171622510273",
-            "6859613823629514",
-            "-31967296838595675",
-            "-26772749609822819",
-            "35113008647366866",
-            "-21247928407771622"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "16605450096694934",
-            "2713804935498894",
-            "3748040022825592",
-            "-35884925413042953",
-            "-28842895601915851",
-            "5002209115350832",
-            "3529334705060475",
-            "16112399859517651",
-            "26710552206102001",
-            "33271555054113480"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-6948678853416573641",
-            "8088096296940258606",
-            "1788919402499424939",
-            "-9045098789632663964",
-            "923217667787488454",
-            "2113233926511753642",
-            "7674437743867941425",
-            "-5483523786006335142",
-            "-4901566326841744867",
-            "-2159924707245153950"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "7483952831904713529",
-            "3981681156262502150",
-            "1574702197696520191",
-            "30404321841739229",
-            "-16526697791658885",
-            "-5887792884766481411",
-            "6480092953553123685",
-            "7930432301453660255",
-            "-950334699167714593",
-            "8999305224741512342"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2275373047011451096072",
-            "1663741816301024567004",
-            "-1866492858541257742972",
-            "-2109145933811908015055",
-            "205702837245156733125",
-            "1635077412214287742642",
-            "685205307788793936320",
-            "1889860958451267333814",
-            "-1166602441424869654187",
-            "745504509663417227326"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1798836380972328231764",
-            "-1406223119331403767737",
-            "1660047033970478613098",
-            "1778052602148636827065",
-            "2250316159389610073455",
-            "-1298324302681600099899",
-            "1334078532892003231310",
-            "729325161456818198272",
-            "191058750304629973982",
-            "51010503554643728898"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "1847340334856600128313",
-            "638235693099620437223",
-            "-478038004560773338092",
-            "-1391998540736358145230",
-            "-626383328490987256762",
-            "-2352574400149631230455",
-            "-1938941449061847831383",
-            "-526607055338931858789",
-            "1981655780781527447679",
-            "1545396686837274666506"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-312442107296555228736666",
-            "356012445393395243219201",
-            "505759552363745699184467",
-            "-468676292296122067383179",
-            "144650032031703545186687",
-            "-26329362228718986332534",
-            "23980362387843468011798",
-            "-365244050437485466278021",
-            "-243995662429130162331158",
-            "-204320605551784536257214"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-45575166340192063213221",
-            "-573081770149787292165894",
-            "-265165687156774270417407",
-            "142789058928229337895172",
-            "191301704388489595602183",
-            "-526986468133892967767446",
-            "477245941154730186128251",
-            "85837727744584298073480",
-            "124665454939314352568168",
-            "-538236817734442648171792"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-31883334627754186218955050",
-            "-132647558483145987490002060",
-            "152621615451762950923746193",
-            "-123974549416047643124802713",
-            "-16114612038666942583062670",
-            "-64534320970354404240221340",
-            "-52121728535745783604990414",
-            "-94488926190663283007722749",
-            "-142818466323905379126560097",
-            "-107911476720388673547687265"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "85894584079322001591239437",
-            "15214409976212802853836897",
-            "-38019531841082459805788664",
-            "37616670829337571764768074",
-            "97369332259197095859847091",
-            "73772357245924419843255015",
-            "-30815777011884938279345071",
-            "-48639604753962660078735675",
-            "115468028917195898397228106",
-            "127926946301889108741445954"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "133666088035672066583524552",
-            "-130261035231129416075204296",
-            "126288325871568137717986524",
-            "-86845343621023472085945052",
-            "107973761265249358331477587",
-            "-129772336942492423381739079",
-            "107590361807184920300114694",
-            "-15925934067100476069944577",
-            "40349773922798370876587602",
-            "10237290409613547079342522"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "23802936985404384833087799850",
-            "1891175066573372917579879025",
-            "-3414847211423679295209241879",
-            "26381566039446157654614814849",
-            "-27987571844346932586533728809",
-            "19734355232998847428072102124",
-            "18813566938676176789254455011",
-            "-36503995951399515178819792357",
-            "-14530867618962366745963282995",
-            "-8849346604262124212079590667"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "5181898859266891446958312760",
-            "35107669831244838496494366387",
-            "-14410695362339474219725640659",
-            "-11591179713532133832522279888",
-            "1322035740173050242109098628",
-            "-31330745687123561728243165717",
-            "26792385853476620307255105569",
-            "-239671734221072238217774753",
-            "19102158857542933762328806730",
-            "22327891859950141710268230741"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "7218784186398202012713467930238",
-            "-3350235717963492612747364671098",
-            "6231440398343118743080139900050",
-            "3480339439152451974013676380123",
-            "1802222928179100234342084269172",
-            "-6158375179378131392944011341388",
-            "-3504666018658185926339154570280",
-            "-8475441398809634118910111467555",
-            "-3093801338563751188575901637318",
-            "-5478326702705048089627298988765"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7070255220529922623499452044373",
-            "-6392207880846944173023026301966",
-            "8940482032109394222736828154202",
-            "-5046383856173347902770746632199",
-            "-8627626268162429998930354857590",
-            "2158989160600634779705496438004",
-            "-9013792196143998093187489447006",
-            "3476375415358910964701042924829",
-            "10085089756175313037187138824355",
-            "9740053811517652352505683816287"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-3787663618609735534843807278261",
-            "-10131105569536599796884449801691",
-            "503460830171569790542890271138",
-            "3434572231596005739225905817721",
-            "-8956835466725390809094014178560",
-            "9973500372789618871294599932426",
-            "-3436060305237781453095163214550",
-            "8450001797448541892298668439883",
-            "3361188979149779406972984767155",
-            "-4211051396445129112263473603788"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1400604743906584917351131252499625",
-            "-1478062509467749242110369849940624",
-            "-1939775116070969545684922458204716",
-            "-1226594030808115703890602534185886",
-            "41411606629976216575859515000588",
-            "-715726075155862393171728350610649",
-            "-1104837525141739703305043777788269",
-            "-33170364036380943653659197533160",
-            "1222412368140077471220168238614012",
-            "-1553672963167499514929514167750075"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "414812444544593930314879937191796",
-            "1065092968521305037826601157806551",
-            "-1284545736853571361465316035084177",
-            "1913928682493656194884471773672006",
-            "2437413883363914925409924254101191",
-            "-63504718310075110440759765897849",
-            "1142014044009551494450713989884540",
-            "-467473985179578855121650728580161",
-            "-1958496203046466422013468466142816",
-            "-228498365668817309414956102721486"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-165107146600836184242508744416846410",
-            "-173159599341289250114641790452112880",
-            "519587843813546128711723035455451318",
-            "556002998269748818044894693715246655",
-            "340836458025000843041754711402673966",
-            "107273561582467343086931264151931276",
-            "198750867607657619623292872099343193",
-            "177053814334723551673700131599196681",
-            "12660542230757668534285774032322329",
-            "-571464786368411573231284232367569493"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "162179090271636955997303945925436088",
-            "-313756832601974313228748371796894029",
-            "-479290633805655842621397357725946736",
-            "-511500927368428520551421482817201088",
-            "275242443136997885046391431699367254",
-            "-577640700565811102564722509570839516",
-            "-603313958861080101850976268791504285",
-            "-4642553372325527067527268751318523",
-            "585149029480379128228533930021017452",
-            "-447624843136876027041393586846771215"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "41501085361451418692451075430330699392",
-            "14066756191036297756834058689490291695",
-            "-164566469205370280337196747799862639279",
-            "97007518905806845925433851317020841140",
-            "157835227951254852214602652284268481160",
-            "25273736966363553104566178634088585028",
-            "-150537488010280684140991686519150494549",
-            "-3078910762200766609996313414922029941",
-            "120706844608861526819394623973916082740",
-            "77402899003013119828768311588427778798"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "17155049489457881084030524101061900599",
-            "55722466817055128162883412356150704414",
-            "160092374234431079498351920387290796423",
-            "-81606519127017628665631973004297421491",
-            "89375409744877313802670851685928047535",
-            "-65994081055910568627784130329323864802",
-            "-120630990114675994405665160336455407373",
-            "-137414651139106149921771512358288667134",
-            "121174892531857852483583596440818324131",
-            "-165550685491777099186772462955579166433"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-121678364556055223485335845024798563730",
-            "67906221171052313441526344645309169424",
-            "135318293234875105755625723591118174647",
-            "112856765176163913169894958961682862611",
-            "-119771416342600648005955621630454841004",
-            "-163903534238729373402472686918104270530",
-            "161195965019384544589699058515114347869",
-            "-116587313658056174021511449216936299530",
-            "64724954802600766569366551938003781249",
-            "-93125379513310589407008602216272655289"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-24289",
-            "10573",
-            "18399",
-            "8295",
-            "-20661",
-            "1262",
-            "5316"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-18813",
-            "1196",
-            "14506",
-            "27699",
-            "17260",
-            "12672",
-            "-26712"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1816906",
-            "1950630",
-            "869435",
-            "-4057560",
-            "4225264",
-            "1863554",
-            "514068"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "5766833",
-            "-4566718",
-            "6185712",
-            "-78858",
-            "-4404053",
-            "-1932082",
-            "677179"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "383051226",
-            "-485372892",
-            "-903491488",
-            "1167906715",
-            "882058907",
-            "-1145532790",
-            "1869671269"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1968019064",
-            "-1799227215",
-            "-485104210",
-            "1368798640",
-            "-1217008177",
-            "-1227552350",
-            "1050282791"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "1331776197",
-            "-1523716584",
-            "-280980420",
-            "-199394097",
-            "220377273",
-            "993543643",
-            "152558613"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "383358476044",
-            "-549418593050",
-            "-95127854833",
-            "233604693010",
-            "241360165929",
-            "-244114921916",
-            "500668910648"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-53958362657",
-            "294585258987",
-            "-297555344274",
-            "208136066113",
-            "306802849873",
-            "-56933397445",
-            "356355330533"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-5931341008015",
-            "-85194361749904",
-            "113496344354023",
-            "110910986479677",
-            "99037670275407",
-            "-29955950246308",
-            "85080062899793"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-135973903302549",
-            "106511990735629",
-            "-68491062797510",
-            "-67355500519171",
-            "-90256403179030",
-            "-67513824484015",
-            "-117243873668118"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-100006712547242",
-            "-834254212295",
-            "123327381870828",
-            "-47227724753173",
-            "133999742949746",
-            "-18734787485868",
-            "114072994453650"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "26713924791564839",
-            "8130537069775545",
-            "-12577784584283418",
-            "-14275066705387698",
-            "-13753875085512229",
-            "25629684304719161",
-            "14775029745555656"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-11254714743780398",
-            "10473563621744326",
-            "33848039724296273",
-            "18968181007120441",
-            "23801217524644040",
-            "-26532014979132953",
-            "-27043991311421046"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-4338512873691242591",
-            "-2471396968750798701",
-            "3382716270394008960",
-            "-5536237505914333541",
-            "-5670361551544238026",
-            "3775163668383883090",
-            "-6190677986420548067"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-6811298520974526893",
-            "5349469892177723131",
-            "-5310390011268146908",
-            "-6394607027886038057",
-            "-8840279685184811878",
-            "-866886887884920562",
-            "9106364263997684727"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2273577051086748127343",
-            "2421110092972784882",
-            "1009841336246568968530",
-            "-945047452043730572283",
-            "1410134830331293109638",
-            "-875429235306554264942",
-            "2114146046206025795606"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2175914150359547376158",
-            "-1748223628477889384538",
-            "2082301040631284414221",
-            "1223990770664639894611",
-            "-1827289874583926966422",
-            "2188372252873287105874",
-            "949660314176845084876"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "756120269623394822481",
-            "1401758245452765618339",
-            "893699234552132134074",
-            "-1016562455395417533129",
-            "982560837349843281349",
-            "1535949657790955542784",
-            "339935115964234018700"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "160187131709749816068707",
-            "-445406864840389796795963",
-            "-364502369523172897909179",
-            "-483741481440179619808869",
-            "-363648688131558141030019",
-            "-317255639295947426340261",
-            "76880251422851734014297"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "83513645025310150339154",
-            "-17033888719894118308423",
-            "139753445403319042050931",
-            "-311922677215511648704490",
-            "6614071525705894990176",
-            "-347208526123811355958702",
-            "-331153931143899968239074"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "66937915462785606409890218",
-            "18402929024834529807256440",
-            "-93539116539481832132130597",
-            "129533946990250575778822929",
-            "-35405911050564377669039868",
-            "-55753625842174688440739221",
-            "73274477544376298222515222"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "102320970151175129799043835",
-            "101371657730044294428907301",
-            "30763947066697758866083944",
-            "125632427074532822811696240",
-            "67850157625702978153575284",
-            "-122847530486522138663035099",
-            "-51630753075526948960226330"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5570796149032603732772443",
-            "112962510499227217269980469",
-            "153243861290764227222710433",
-            "53437571104225666803388890",
-            "61392106787538463166584259",
-            "117240447134205597906098644",
-            "60147122185044384664950672"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "25440681132059718117365230086",
-            "36918164020123084473254266745",
-            "21550823988603061803770774218",
-            "23314393410588498837026340595",
-            "6838667569178219678527118012",
-            "30164610006780796397257146070",
-            "3856966332228692365975619319"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "5081531030911632494676413206",
-            "-28718432056933259489318591062",
-            "-2050881926509555330776684358",
-            "-20284056359541046744053496159",
-            "27742784349335929086470876577",
-            "-23732359260540767132988499358",
-            "5634504669489702253559754357"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-3834438486720541018898060342396",
-            "757405556339035170443861964454",
-            "-8580423491565526971567650107331",
-            "-8945834070161348883399473301073",
-            "-5974403419273083538716640073054",
-            "-5722317395097101795951011911463",
-            "-5741054963623745695692184888504"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-8177592807298787544136200201401",
-            "-8737768036785410829204705458137",
-            "553812896188979268090905076767",
-            "-4021415115048931628518326506347",
-            "3924889803517574116437664136082",
-            "-8427629394384391196070489759500",
-            "4826578044967295536262713612905"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "7431086482852698405039291580358",
-            "-9383454246382299183181940802026",
-            "110780578216389910057065519226",
-            "2997597313220317309864866164017",
-            "-8403711664152768877667363976799",
-            "9484934137736292785001782174450",
-            "-1992550614924900659257438994754"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "2373418612554887808061895526341322",
-            "-875917552657361505492351804147083",
-            "-1898458663708254096173410834725291",
-            "290657266522040208254177101419000",
-            "1934693067868945395803972374030326",
-            "2035880975736537411226150165204569",
-            "-295118642138847608101651879233223"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1104518889416566749000188799690936",
-            "2455684185543033692597997273850286",
-            "82712851079703819661084329753293",
-            "-410022871087898657272365213961056",
-            "820614625160173093789799139004878",
-            "-1777050003863809764253453475090598",
-            "-679519739224009400590313815819330"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-304159418192963037178769623546586814",
-            "-128686367459246117841134563726117419",
-            "-168852189389901620284754066083296623",
-            "-368361507059344027859608313034640451",
-            "406153616128697783106760476034969080",
-            "108280339193448166575810552660499327",
-            "-272917413831425220737435317129240149"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-521853357960558893783030665586434328",
-            "-343385983135307684129023060457977073",
-            "-506847810949852766012501602241167446",
-            "-320653206306289485921441154060647458",
-            "-321419500062747985044408215510498559",
-            "360059077100522851702855678971772481",
-            "-18193071889338165594572934630198306"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "135198259031897173424041180828687717318",
-            "166925950940460213304747134486553784378",
-            "91770708378464964972025279535217192484",
-            "-74034082172265236168468281957827129715",
-            "-162271236574132326749987187978014522711",
-            "-149970538812246904199283660851953012127",
-            "-33876209446467800177023509622790899587"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-61149961594095579505494563784365845076",
-            "55447541107548109725109916957958410011",
-            "-52782699847581819420368482823281766808",
-            "-61428023230847673671328947277950650863",
-            "-77167370229187325704618575761108559915",
-            "120671975447784265485882220443592967003",
-            "-31941156027929177364936983495588921100"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-46517984021030779553174610760370691361",
-            "113342560476092078423544510209910511761",
-            "-48453285416719025136328005628829738351",
-            "-156382820183969337136212148728801068593",
-            "92013865013427171673489829654013623118",
-            "-149825413114872556503600279014768710017",
-            "-41842153899195246897218693785873371052"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "22560",
-            "893",
-            "13712",
-            "26425",
-            "-31443",
-            "13197",
-            "-2033",
-            "-5158",
-            "4272",
-            "-10000"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "7568",
-            "5297",
-            "30894",
-            "17857",
-            "-2276",
-            "-23490",
-            "-21021",
-            "-25476",
-            "22182",
-            "29801"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-6043434",
-            "-7233989",
-            "-4760386",
-            "1954881",
-            "6262402",
-            "-5432480",
-            "8247099",
-            "8104542",
-            "7559904",
-            "-1468008"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-6009851",
-            "-3463144",
-            "1902131",
-            "-6065871",
-            "5322522",
-            "-5281546",
-            "-3949430",
-            "3706705",
-            "-1404042",
-            "3601699"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "865502134",
-            "1417082065",
-            "-629664388",
-            "-807386741",
-            "-932260324",
-            "-2100594554",
-            "1317544706",
-            "-1659287662",
-            "1747762053",
-            "-396035137"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2009773453",
-            "1452039055",
-            "275687455",
-            "1229090980",
-            "1647739999",
-            "-2068020074",
-            "1116868483",
-            "-925674893",
-            "-276647664",
-            "-2124051141"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-652548523",
-            "-734515103",
-            "288855150",
-            "2003714209",
-            "-2050720739",
-            "-439439213",
-            "-597448192",
-            "1032305015",
-            "1396503618",
-            "1112795070"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "279530206260",
-            "-37787584606",
-            "-469700465159",
-            "505547261276",
-            "302063628730",
-            "232557570106",
-            "-400244326424",
-            "-500191912404",
-            "25916715111",
-            "434497276265"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-350338719945",
-            "82553936444",
-            "-303574370324",
-            "243609147006",
-            "-406918086752",
-            "-88984556473",
-            "414777054250",
-            "-65665371841",
-            "-214549984551",
-            "-160387504734"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "111115937773490",
-            "93917065955228",
-            "-96942832219834",
-            "-33245985521466",
-            "-14808380437022",
-            "-4337750370781",
-            "135538464766646",
-            "-89018159354352",
-            "107684460266199",
-            "54644567775645"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-4281375143734",
-            "-90555175252799",
-            "111437459291494",
-            "131211416029101",
-            "121367162942964",
-            "41802077584397",
-            "-15870395962588",
-            "88293896383396",
-            "5103371203595",
-            "872421043658"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-27344466164330",
-            "-64277006280629",
-            "-115200530257737",
-            "-96185525872446",
-            "-362102981191",
-            "41076176727009",
-            "97608038546518",
-            "-21909959043825",
-            "25684146129386",
-            "31887816743174"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "15805681068407129",
-            "-31632108725366096",
-            "-28430420565549892",
-            "-5685098119469251",
-            "-19359673914220516",
-            "34927075452235781",
-            "3646450258861011",
-            "23186600653867991",
-            "23870113232131846",
-            "24001450908961341"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-22903183193209387",
-            "-4042683237615665",
-            "-2730673747391472",
-            "26722058029955156",
-            "6157099985124238",
-            "20691656929186432",
-            "23541903929043982",
-            "30481714773589336",
-            "33354780396992065",
-            "5937390849575047"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "7111976505000124157",
-            "2513743790789558989",
-            "-5854964827243221874",
-            "1781418857572271171",
-            "117740201774951719",
-            "5464574628727265159",
-            "-5417016541752216420",
-            "9177082172732916663",
-            "160231964650370102",
-            "5198235504762424898"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-6959774822262382900",
-            "-5918004911967555855",
-            "-8785219904076781827",
-            "761518306349693777",
-            "-3727781912512154347",
-            "-7347378201324932678",
-            "-7407703676847128120",
-            "4192766707565496640",
-            "1019303794324002221",
-            "7284694249235670661"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-518706270599601321284",
-            "48296813336873849945",
-            "-757973019222940359901",
-            "475279089186345082149",
-            "-1857051161967159641567",
-            "-1773449378603505991898",
-            "-214240478131630835049",
-            "-286969346226347726119",
-            "-1377522753231516069488",
-            "1534327277443683237083"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1261639334685978762634",
-            "-863251376487397515329",
-            "744768807612401835863",
-            "431090683079445762349",
-            "-1430008898903453262513",
-            "114432723295067239367",
-            "-1659415137482284952255",
-            "1956229533554192977542",
-            "-1285276599317909495561",
-            "-681033070942915028623"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "701567718623448740657",
-            "-770039146384883281781",
-            "569393332403074078663",
-            "-1154152301490888490101",
-            "1384935762862036151746",
-            "1292652059491738064552",
-            "-1901055548660828668152",
-            "-511050274918474237607",
-            "1514545794119297935503",
-            "-1582702036644800787512"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "525113524901831930800014",
-            "595544469553401116745247",
-            "531694395790167129406901",
-            "239795230404718942193473",
-            "47476260565690957269128",
-            "546393256156863431003393",
-            "-61262268239682896208557",
-            "401221833939464710528829",
-            "-300134644671240853134013",
-            "161147446687616707600843"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "219138432946234236649127",
-            "-306826762775104215875477",
-            "-122309794531015699303879",
-            "-484390629051561859282314",
-            "-484657707904256453204167",
-            "-64172125540895226776153",
-            "-142182935337162713560713",
-            "-425794894066631241856692",
-            "519332704943479362574611",
-            "-39607393270604766751662"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "117923250549289739547762878",
-            "-12796961197805647943116125",
-            "116897654782120455942318786",
-            "13956190831994724793021311",
-            "130567329542252884379704341",
-            "-151472228305034689251068623",
-            "117154604904044151278566211",
-            "-124756046758763955771939571",
-            "27553563965416818601126828",
-            "-6385245309521757072601303"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "19686173839910969340904667",
-            "67019339050451913372960344",
-            "-911760385169067625107436",
-            "-122602505415495630018637800",
-            "31593555949045884898723169",
-            "77102155795733768673367210",
-            "-88704824409118698981385569",
-            "-42307172980137248443961447",
-            "-4446290230048200090988726",
-            "74356647474998795935207344"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-133795720031537585830253848",
-            "-78089793241413791675804237",
-            "-146996109993430013479432790",
-            "23768136773568272325587897",
-            "-106683272894876981717341824",
-            "-80841936515652353087463629",
-            "42569237872224343987105320",
-            "49071873620207544414478264",
-            "-4630034012596569492380443",
-            "-10118444529078594226753741"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-24951441861790452223123296595",
-            "11386091573469723230249468441",
-            "357584100357389438039201862",
-            "-33986416720044219140319583496",
-            "23627532621110890373222649794",
-            "10017504927354356464772980155",
-            "19362269204948111616152932551",
-            "22750490848378999604678136199",
-            "-9083598083282026421514694140",
-            "-38727975416599385546239458974"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "12488280666875253249236254683",
-            "33422133051718018037208075117",
-            "-33776414240503546307124956974",
-            "-21484107419134338520121082452",
-            "23100427643229869917783680858",
-            "-1650226751931233622609376911",
-            "16906427077642537130376239920",
-            "-10289660454830607858626682520",
-            "-19484893295053214460865724970",
-            "-35952156995798958657792954473"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-4735298964100410577985543000395",
-            "-530020970016182803114777861279",
-            "-1131349626390530283723194772589",
-            "4317710074952661856482753164067",
-            "4095402110127114773697774757004",
-            "-5294319980949349221369104353569",
-            "-3048927073292851696777488488702",
-            "7634763577542382376327040341451",
-            "3115557643024666160471563838459",
-            "2926203117946390190222302068793"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1864945236373483656597257239959",
-            "405034584047843548124421910439",
-            "-3218977334120915262993640819384",
-            "-7142961612298989061130444521419",
-            "9307783629655608942945035515333",
-            "9723234906857782536374491021270",
-            "7650370082443858700585254978477",
-            "-9310868784454660367988144252963",
-            "7465773199661339364694190806591",
-            "8097845381146606888985497903233"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2675669436671053895099186040413",
-            "6895644571078189440948660962592",
-            "4090458704020642720758701259110",
-            "3437150126960216898595459196390",
-            "-9705511727116548664311748297324",
-            "-9305522884159558955104155253458",
-            "-1180186469868495251804854919531",
-            "-9796644010646070627213151591605",
-            "7106015483167238861336648112959",
-            "3331018800384614291320519803020"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "1148597479167394014443766490953345",
-            "2591895812533789822937308818442541",
-            "-326160310667933246866417794387851",
-            "-790306080625502821695639512319184",
-            "1545324828980338934424171461753128",
-            "793479953457908571858622935305894",
-            "2257543789427477727739601853041034",
-            "2444208137442914637553318787476074",
-            "1042890315365379193825287662234332",
-            "-1210287719815272207093258458478606"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-582733012088132875430838862529115",
-            "-660250931409288922636705489970214",
-            "2138527182118079262740549727787747",
-            "-2553900648599237329560900255287994",
-            "-818610871820914906670478944208743",
-            "-236741329036188976369182885941428",
-            "2127636973795770254193330141423807",
-            "-431302383365507717941243837426762",
-            "1669665166902924237503748195025488",
-            "2520650475436221136120486524455387"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "437759108051476501968471376399124534",
-            "-243331297098327608976864926703591085",
-            "-312583708013495348602181422788137336",
-            "22789177262884761633952302550572526",
-            "-120348891169104228873609073292813076",
-            "-659626114206394610798043021957841914",
-            "70595700062132590775654277374702719",
-            "3451720916899085830004332720776845",
-            "-34955038635481392379717309447778322",
-            "611134933947728200993481817988506418"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "20428164720806545350579904191767053",
-            "-99366399181425663956407652863667479",
-            "-35862534912239206067332175346609413",
-            "163496968286287738613339640023311242",
-            "-591381118335160981639939232133613024",
-            "254858944488772779912509622495446951",
-            "-460577318473676675239602831217222871",
-            "-616355768017271613012286794164991144",
-            "569247714773488133953930390229542704",
-            "202465807813752300281405751766207660"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "50315610630704356585322877730374837077",
-            "-83098067869442334415610073682313947471",
-            "161365526209509778448649648555742998425",
-            "-34910129007785397951451736271574830290",
-            "-144028959288053184684355803368266298023",
-            "-83817363552302335547213001246996745217",
-            "66067533735734112278087882548638909770",
-            "120913070546179844966164010066001238079",
-            "11384422330934700411529312190354569876",
-            "24772640548850140487291953136913828116"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-33028393081806170731403400067321655079",
-            "-11463174497738743284114180047596875486",
-            "32254998885085389327900118303255482169",
-            "-143483787323458716777165205934466305713",
-            "-112857257202882526765530368259175091713",
-            "162300394541802787040467843446805562970",
-            "129149449533069183017216694533759537096",
-            "-64890619893840122581192195171585201603",
-            "92544985698450754032974399211134668880",
-            "-54842712948210953012984037318158437034"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "132478357453720312304052372488893354300",
-            "-32685327131103251164646706295319990901",
-            "137916669492333509181609802124805628257",
-            "87478174466828645335209662043146117532",
-            "-61373497372439972480430645755553315203",
-            "5894673095536466472878429843436835629",
-            "-11619138682611129587257806902056620796",
-            "154151469754446633748882542018886132033",
-            "133733328652939407559328194516170213391",
-            "-126168609308185025841853092223452728320"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "29705",
-            "-26987",
-            "583",
-            "14792",
-            "9066",
-            "1503",
-            "25039"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-11868",
-            "5868",
-            "1573",
-            "22308",
-            "27942",
-            "13220",
-            "25806"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "6498297",
-            "316060",
-            "-6879700",
-            "6560750",
-            "-578892",
-            "-4785342",
-            "7293532"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-355167",
-            "6077145",
-            "456351",
-            "-6459738",
-            "2475530",
-            "-2801348",
-            "2836470"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-763391790",
-            "-1421479470",
-            "1842219939",
-            "-1396384047",
-            "1279169338",
-            "-974221132",
-            "786409383"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-701822471",
-            "-624495191",
-            "1950360306",
-            "-937735710",
-            "891136351",
-            "1299679601",
-            "-1631128813"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "375062411",
-            "101064405",
-            "1860934989",
-            "852100817",
-            "1489729732",
-            "-1386032321",
-            "1372454919"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "211103860560",
-            "165685254110",
-            "475179443594",
-            "83982532429",
-            "-110181124820",
-            "260080395391",
-            "396030998948"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-345799561802",
-            "385403135660",
-            "394672914473",
-            "-41576529948",
-            "-89134685382",
-            "-3611010438",
-            "-230138775672"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-44213782783569",
-            "-20824315185336",
-            "119392219688726",
-            "-48280571708474",
-            "93590107082594",
-            "-73857195319550",
-            "-11092149545600"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-3391364501302",
-            "-76804068374074",
-            "-5330058597257",
-            "-19337292494715",
-            "138572773907931",
-            "21930262754355",
-            "19745392677247"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "85902098584199",
-            "111873133532349",
-            "-68545677680071",
-            "34394580702899",
-            "-129707208239806",
-            "124130433864871",
-            "34089590991835"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "11547754029851805",
-            "13929638569741680",
-            "-35234779220736599",
-            "1556424996390195",
-            "-9941069445592524",
-            "-10351643092326233",
-            "-25407298114074662"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-25715001828139556",
-            "219757435776379",
-            "-15386649204339974",
-            "14219377191186674",
-            "7764182966113153",
-            "-17037164141869666",
-            "-2475550776888956"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-9013210997202018091",
-            "-1797035859465177385",
-            "-5039026628271053798",
-            "-2279961464871578084",
-            "-3332468041413232867",
-            "5196784857810113987",
-            "-816043157177424446"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "6230937120482135875",
-            "4406903786753583285",
-            "-5727776665901788833",
-            "6110238893930148669",
-            "-145374459534268305",
-            "-5408134830337680351",
-            "4578682454615398942"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "2280996778076363880015",
-            "-1105914554647913546919",
-            "-2340456352988668320804",
-            "-2286379749373826695506",
-            "886840160760479118799",
-            "-41094253890685508209",
-            "548649222178985137197"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "2101991590910127128698",
-            "-831048801347409813644",
-            "283006935997353787913",
-            "1014149330696637995585",
-            "806441932790678928581",
-            "1292353558196559947530",
-            "1691441804823003410715"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "514147725545916528450",
-            "-193880206083679947659",
-            "937498535568154555134",
-            "-112013115494854394797",
-            "1838267628545853841229",
-            "1697251710819151266567",
-            "1334759843181386854916"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "140211044419225416059523",
-            "22798773775711118695439",
-            "185167441622179764743229",
-            "-341069468014651486949028",
-            "-311767107447079981815378",
-            "-365574085382023414765745",
-            "16721445196171820250327"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "486153544869280373342335",
-            "-242241326842640368113620",
-            "-562468626770589338549903",
-            "353095362900612835555266",
-            "497938272554417006820815",
-            "90302429955937293267553",
-            "526449366929722769596410"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "46664866598514825254083995",
-            "14396224856981525909820752",
-            "-107662311974370582851318011",
-            "-116315009943902083038882452",
-            "56805605268567131709840635",
-            "-285698053798149060391610",
-            "-33274177545126848030882515"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "33427646005521871613027485",
-            "2068649850038034587145992",
-            "100657143587737579826250182",
-            "-101842456842860935986029777",
-            "-24678241147837041282536443",
-            "-137081933839393292380849579",
-            "80701010466319784595704954"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-125204491775364926553434405",
-            "-68666196727647600858615388",
-            "112354660219741185829905397",
-            "-7303433862000761726317213",
-            "-11446693224295095219494490",
-            "-2156245347683069299464550",
-            "154672444469077398685327566"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "23329815819835763885234375029",
-            "17840398455337288079751030137",
-            "-25733526444924201365089723197",
-            "11519925701526868606303914066",
-            "-8122188835588210950596509581",
-            "20364966273892581445915895222",
-            "33135945479485532338472222967"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "34850681321476402094647761148",
-            "-8083975349781433603028632490",
-            "-26785483364705248388507635494",
-            "9143502111139064417571274857",
-            "14109565008946975910759730825",
-            "23146095454100851136277162012",
-            "1964738793442941286156606155"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-830794414147442758629680858917",
-            "3974824330694591996054219287782",
-            "5212798423257109428476944724672",
-            "4136148464931397492769112444980",
-            "8716912509663310300081342235480",
-            "6130432387446754799113484089575",
-            "6936235167270048720910192819573"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-3535004387728242781406510654821",
-            "-2981058632797045086695893841072",
-            "-7090056840341574165394710895073",
-            "2937436279617800594018353925694",
-            "-6164350919245055090956637473538",
-            "-6513208139095775762754457986006",
-            "9324466091637799474852790812941"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2028288650797899768325565085648",
-            "2900055817977855811722193499494",
-            "6905622275677150166335492710080",
-            "-3160034744597195167509247764978",
-            "-1770329430972443791351959666851",
-            "-6751176363700567085044496183977",
-            "391291090038019520158630200495"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1144504652616585466559731200361813",
-            "-1411714359592296247517000426578522",
-            "1466595389854363706316815721880003",
-            "742237093197555043514198686208810",
-            "632837196426513796812458196446553",
-            "1024964501312689171613773158523485",
-            "-847167208284549920541560580297353"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1379322307328006592168092307072132",
-            "387617426942146023411122884259110",
-            "343500850419230433556982280364993",
-            "2429014391360178084347952076151804",
-            "-1271102713054563598822742297111938",
-            "1935501224421101911088894464720498",
-            "891196511387998706976306482945567"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "327017567565957860896642013563192207",
-            "-197957402373048855115227470112922554",
-            "-274157035197732503264012623953912376",
-            "-403813151150633640598242397849702978",
-            "-607653760517680240576727061740741951",
-            "-484513780480873333770895576601263141",
-            "-364508171932424706077901220225164024"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-655778660285369872582403556455076537",
-            "-305967296614644034918759561910261868",
-            "408652192029803274954960477706952597",
-            "491158410408462445362863360612553421",
-            "190090738690396233311384708778934496",
-            "-650782116647010450130445692263218670",
-            "466999684855637663153637496446512539"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-120922442637350268547173038619758155686",
-            "-14798309877377243156606971473100481720",
-            "-158319052033044572444106251098798964128",
-            "-87790259877385234658887405184771282386",
-            "93922935281981262808730125220213226026",
-            "152362390413913740334911190667453959896",
-            "-144716399672639547866469402888393372244"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-44740461288862326679317055888851447788",
-            "-19261460967897542219529042766754216418",
-            "32572085694274520626483716255202096142",
-            "61807114741875177639257174914455169635",
-            "142136086887672692821719902247408741632",
-            "-53665021237760509021660371077876689014",
-            "135482047221090055561713975617737312735"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "151443922013736797164062148265526547401",
-            "35894129120522936623313378082863551111",
-            "165517845554666361071462006124502354697",
-            "-161960863802263743123033369079756629461",
-            "-13661079351804691514638526655907412444",
-            "-88694839241604621649741179075868872513",
-            "58239606879205464966310459406863836884"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "21865",
-            "-9513",
-            "-7941",
-            "-4293",
-            "-1219",
-            "-10549",
-            "-2196",
-            "21139",
-            "21478",
-            "-6001"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "8460",
-            "-5982",
-            "-23734",
-            "-11998",
-            "17806",
-            "-21183",
-            "13348",
-            "-23465",
-            "-7244",
-            "-15957"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1268458",
-            "-118370",
-            "-1893479",
-            "6108358",
-            "1102635",
-            "701748",
-            "-4079505",
-            "3897123",
-            "2836441",
-            "-5694828"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "3354881",
-            "3381813",
-            "6090423",
-            "7476959",
-            "-6152439",
-            "-3812109",
-            "-4999299",
-            "708401",
-            "1857502",
-            "1616326"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1829093763",
-            "-4407926",
-            "2068340761",
-            "234009195",
-            "98079137",
-            "759088995",
-            "1573936081",
-            "-1886084340",
-            "1660264264",
-            "-703900633"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1724311878",
-            "-1770100972",
-            "2005560287",
-            "1002317505",
-            "564934293",
-            "-1056620575",
-            "-1507809740",
-            "1202563854",
-            "-1605647773",
-            "965485898"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1993753383",
-            "-1867185966",
-            "-1797347612",
-            "1892035404",
-            "-1434558470",
-            "200775493",
-            "-1667955972",
-            "-1185419659",
-            "-1021155420",
-            "-1017852104"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-103795691472",
-            "50179936568",
-            "-305052039589",
-            "-310642809394",
-            "298713016856",
-            "430578254618",
-            "544157970272",
-            "161717434423",
-            "-82568595668",
-            "-69760173661"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-375428789801",
-            "229743413651",
-            "-385129101606",
-            "-341027447447",
-            "-292292749496",
-            "262095081246",
-            "399108175194",
-            "-436877011553",
-            "-184609205075",
-            "-525138717918"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "109490881395508",
-            "-2794346701792",
-            "-136768254893717",
-            "98238674344928",
-            "-71024502877527",
-            "36337204077446",
-            "25777777072393",
-            "-76891055436936",
-            "-20658339677220",
-            "107548266692467"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "65741531641303",
-            "-120604147256920",
-            "-71319706911283",
-            "12568908870250",
-            "20874672241429",
-            "-103855183735668",
-            "-53956000337623",
-            "67466545861242",
-            "-40824456528955",
-            "-50502795434656"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-30593444826663",
-            "-105265259920813",
-            "90066025218056",
-            "72114368716596",
-            "88265148520874",
-            "-26982520274013",
-            "-56277959562553",
-            "-46821369439330",
-            "-84272522150036",
-            "-67142476625898"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "22942929546037422",
-            "20172954267975860",
-            "9006547764775266",
-            "5211508666269417",
-            "30624269047382012",
-            "-12672445409868765",
-            "-32303326488011005",
-            "21742501359293496",
-            "18870493623228669",
-            "-15114725655588776"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "7991033936095510",
-            "-25436300164394417",
-            "-4116325708088739",
-            "-8818216017431285",
-            "-18277587083906160",
-            "14144228659002687",
-            "-4827602588444601",
-            "-6917969417697944",
-            "34390202143918890",
-            "26364020049473109"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5565127045385194966",
-            "-7684916584653270186",
-            "-6526101704890152726",
-            "5758616101220042812",
-            "4277401219812095069",
-            "-1156200668055380488",
-            "-3665026910524676836",
-            "7227753205619980282",
-            "-9117970762813305675",
-            "3814443356076271226"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-4056124162849183791",
-            "-3091054243487850690",
-            "-1005186283000031535",
-            "4264379098205926012",
-            "-5816101399981242529",
-            "657803495947876179",
-            "-7620099954905920196",
-            "1165400408553884079",
-            "-4242137285679032126",
-            "4883600219746027602"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-2075689333753747735685",
-            "2356020644862916379319",
-            "2167344894833235655242",
-            "-1233676921087779374936",
-            "-472138285531110689106",
-            "-1007733287828797731354",
-            "-1150820475775440441805",
-            "1849909446162084231324",
-            "40485887422211501292",
-            "-1531296877121202039185"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "2248262662434579442174",
-            "-24067525590648914392",
-            "-46650276984820791770",
-            "-2184543362428055235823",
-            "1974794946687090550573",
-            "2197581555630725738513",
-            "-1036621057391423397578",
-            "1122920389059697318393",
-            "-947702755738865994434",
-            "1634754840733349282174"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-859921720417617681444",
-            "-2190420634375059510979",
-            "-1434691179630443364753",
-            "-518741106894841329345",
-            "1093338259353051655764",
-            "2211352717790797000825",
-            "907793405354409516774",
-            "220145636554287824727",
-            "509691887514400022545",
-            "-1294594023424323107387"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-526990487436843194807840",
-            "596575213433002438735038",
-            "-71236910029025414107990",
-            "99178925759657972243233",
-            "-440284224066490812643561",
-            "-428326164367815704740490",
-            "-429553654939143998439803",
-            "-301485703325840334321221",
-            "-205335077080231282419987",
-            "-586491652024392408421712"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-543688845315372053238708",
-            "-163909849043312495770038",
-            "-389689726424929488513817",
-            "-114895253663121558845496",
-            "348640253272437667385550",
-            "16575128907035554845887",
-            "597210944202677679801832",
-            "220285812487408184784084",
-            "-42608008827610055995030",
-            "-96942244128145461390288"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "143527171537167288568334963",
-            "63922968735872942354971347",
-            "16148467038136997458380707",
-            "-153693517794242110028457288",
-            "19318376645712741297662190",
-            "-12794255459929906566054319",
-            "-37650752907879433922942673",
-            "-150166615652066337683957386",
-            "57329802738501405002838890",
-            "84897963838366989876933017"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "96124972909010047517011683",
-            "140953422210565403195650941",
-            "5311198421189536461110037",
-            "121439717040191911388251790",
-            "41648789220821764736893059",
-            "-34464297128753801791226983",
-            "-130145493103864535084592015",
-            "85478399528142555833134891",
-            "14109865387017479696802124",
-            "-35883514830521563515868006"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "7929873152858210171340528",
-            "146946594934440045255005503",
-            "-63984879531222004851746641",
-            "-98404545568865647913143114",
-            "147368438153309689359575404",
-            "-125299622361117017666281396",
-            "50888897645607457371420920",
-            "35436333051448932231106760",
-            "127474433365288821803863819",
-            "75480346343825103775154749"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-8746748457647904867496756699",
-            "13886890262009261987702677945",
-            "30610269704200657332639932690",
-            "1988011012396012136828019533",
-            "27809766702732680733200157750",
-            "-13397700579544534835060124865",
-            "25003563641560620051585929625",
-            "-36124205442930485039742412898",
-            "-26618151134121364917297218959",
-            "37250266093672499484998022951"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-14142713495768494830041644219",
-            "-28826123233012884759325086616",
-            "2139184291361898827778357325",
-            "-20691297473114691371314913993",
-            "34039896653596475818834199231",
-            "-1467759043071863209472101520",
-            "18433718648399999914637264302",
-            "-24512577345718204022326385307",
-            "-17460565004252223611174273742",
-            "30220497605213358105564998501"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "10121526385221565224067878565679",
-            "2761189092075112373016075500931",
-            "8854254270554901165807339966360",
-            "-4844293746135774082587580385559",
-            "3690381197256143789522141159908",
-            "1243411595693866754538784391256",
-            "9189681722403043058688029968097",
-            "-9423820843284925151006522300117",
-            "6829156521436853695351870360315",
-            "8184630808925606776348432717524"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1198084970702764472492358102739",
-            "3152710836296673619366574627547",
-            "-3203266598150150519017435963345",
-            "-3401665769768522116199310644875",
-            "6607270485165065820523048271021",
-            "-5180376940463540157931412688597",
-            "3550769633626957920535415329535",
-            "-3923968524034696093714727315085",
-            "-4025531993361587655896041896848",
-            "-188450492479152136768542630378"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-9632952156052895819744271379361",
-            "-4884426114142676161683078815655",
-            "1839921941370111674080951268455",
-            "-8242503028303467805329769377593",
-            "-8839943769048065292932997859326",
-            "-7067251768733441732414994112967",
-            "4523867687328920768404651884895",
-            "4871179227553544008972518619850",
-            "-6057694139116711199472594493097",
-            "4059555045350317377455403338609"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-473059709957241261159046271732783",
-            "1980262112011223122009659766419299",
-            "-12462833368369094491640116529143",
-            "-1189936951170501491703143185809120",
-            "1637235101820702334443602525486638",
-            "-2031029039226482674092805839096008",
-            "1673643328081327255616083846013952",
-            "1515455878435179342948918055102912",
-            "-249177468182679514366885827523443",
-            "-1462399863102676315035000336009503"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "404343261308094133306771010587258",
-            "-2509027130906219806348103780125817",
-            "-2235370619058054613214526829812775",
-            "-2180139572932375906797575417923006",
-            "1786990964606634697851218573276596",
-            "-222676010348749137040908415328994",
-            "2148962315756674060907600200655578",
-            "1131231890777254296826085678598694",
-            "-209000893739050027703488315683250",
-            "-2491331756189203304481882066855639"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-185542581219629399352774704587796685",
-            "-394902121829278205437359525805807857",
-            "590713072897259853019691937013503396",
-            "502758727281988975427078318543416657",
-            "-443747842243734666697335489578837039",
-            "5042221370262609425633645769887675",
-            "-591977482927777323690326997409238587",
-            "292422542569899682160719976080427761",
-            "605833396059257331402310165203375182",
-            "-9563525518418491930653260896379776"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "334166123380339702684858383425230913",
-            "-637729563446579910264265173398457924",
-            "472769213866685799294818860568678399",
-            "447146791822178801527521581709580511",
-            "96610773493845656033107109605172170",
-            "-142602384805506729332865726614124340",
-            "-310601730706741597007959967153005294",
-            "354280041691278605239105907920727029",
-            "320355952808759932183649996729527966",
-            "331701763416087509468808713667332601"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "49073461277677362785760660857736919947",
-            "-169416908345824675858705165355626189812",
-            "84167001824144890089789137366638401928",
-            "-23409106148842837235476212707694687403",
-            "-30271474341226497841818553413331361753",
-            "-106504152229661458377059178821397168599",
-            "47171294945627565796345213643071625567",
-            "22970191271966763243715811330493877198",
-            "14863926779301434690221505350909619916",
-            "110474698934476487574067856333615082472"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "125849800007107590516369492180395552578",
-            "143148433387379660832193328066338030792",
-            "-72853653543700073732079719513168773515",
-            "123778760286761947686806074556748610584",
-            "-105565654733279392109260625797964696434",
-            "83264246581235221617996610103577182490",
-            "-48415572079837050298521191611988793535",
-            "55401352808652663867123392021289274501",
-            "18767844067668706651480236415919760235",
-            "149963850691371825124263493422131099303"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "125053867195111854928850289325494913185",
-            "-141558821655686526589894984641859254355",
-            "-70235167406408960299018082636911869127",
-            "-93931785069493972666863586219173004358",
-            "-33652465762715830748074030542843712877",
-            "43131529119131579740991924094501938303",
-            "-56826490505262593726163351863722744454",
-            "26080328815831670206668453834325133999",
-            "-118301668341141860875674987759645097183",
-            "-137560743311784101467304719508764176954"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-13389",
-            "8685",
-            "-12385",
-            "8428",
-            "-23847",
-            "2877",
-            "27301"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-20601",
-            "22726",
-            "-19831",
-            "11763",
-            "-21024",
-            "-26976",
-            "-3495"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7613329",
-            "-6191296",
-            "-6562342",
-            "-2775043",
-            "-4626420",
-            "2253566",
-            "-1356456"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1881110",
-            "-3472963",
-            "-1986841",
-            "8110500",
-            "6613282",
-            "5706723",
-            "4659122"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-845165868",
-            "-123936040",
-            "-118407476",
-            "-872134111",
-            "250077717",
-            "48927889",
-            "-1242740962"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1257436866",
-            "1664895293",
-            "-1592574645",
-            "1054532878",
-            "1586386182",
-            "-1423067232",
-            "-433225350"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1448117074",
-            "991933747",
-            "-2007741814",
-            "1096958894",
-            "909454330",
-            "1945230524",
-            "-1135940304"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "454731687426",
-            "-410445542500",
-            "-275815453925",
-            "232188471199",
-            "74176210838",
-            "172694874896",
-            "-432229161881"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-237742907009",
-            "291725362921",
-            "-375456133851",
-            "-172555537749",
-            "-77222985727",
-            "75467983132",
-            "355603655065"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-103229358570432",
-            "-52384313969783",
-            "125123784330760",
-            "49147811785670",
-            "-76188420587913",
-            "62077347858917",
-            "113236111966942"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "16839675737350",
-            "117528188223946",
-            "-83215066360284",
-            "-106240126895133",
-            "-140610775675863",
-            "69161046340219",
-            "-5367620164209"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-28041939750005",
-            "-9849374173718",
-            "-104280463802980",
-            "68340765792259",
-            "50866601864200",
-            "-124901901785729",
-            "94320105961599"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "12964636865091758",
-            "-30900961707076249",
-            "-34235023432781587",
-            "31452849974220059",
-            "-32116433493349645",
-            "15056454641844697",
-            "3220380516817924"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "11565990132652309",
-            "-1979115219549902",
-            "-9506105015296441",
-            "-29947064953359026",
-            "-35723741290819777",
-            "1692216018015076",
-            "16174544022195084"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-7310963412698136424",
-            "-165597943071933948",
-            "-7957288198886101326",
-            "-1416681132847790179",
-            "2279955654231160293",
-            "-9208861139945806119",
-            "-2871834669649394603"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-4691141329322093701",
-            "8948849172004914148",
-            "4989049806853973423",
-            "-5955920418702428305",
-            "-5005462481578120888",
-            "-4824298625293485550",
-            "-992020992384580885"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-27391602612782822280",
-            "2319008273932661576621",
-            "1379487111365773121977",
-            "694284593718405260502",
-            "1761355855168617262841",
-            "-1515770924964548454668",
-            "-989979187498153392043"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "198638501199435366825",
-            "1125019815452792395133",
-            "-1049896359176778070473",
-            "-1601152615237961695468",
-            "1050439216436645606582",
-            "1663568252582913300370",
-            "-2061203660241370183042"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2113036292339854435848",
-            "-1939642742757517734568",
-            "-28192641056500022357",
-            "-739364128466490143441",
-            "-814580364884709918305",
-            "-1154955975185230844627",
-            "-1921376171526945915117"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "155234916517253223214669",
-            "54569816973154769361790",
-            "-396264903716832274146123",
-            "-233058506077293724737866",
-            "-259977111446647844862201",
-            "168457257727401353456526",
-            "-440383324891821228732709"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-317523940996880385737765",
-            "-93963745003535018073676",
-            "424089378343927508686049",
-            "-547783720395248736053345",
-            "-573590139412320114240415",
-            "-279824181416708109089356",
-            "151946399597755342049492"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "28344600382890942689933714",
-            "61364243140907583311935231",
-            "-154265345511422448987361885",
-            "119378359869607162352295161",
-            "94263708499987060050544722",
-            "-133072175861722803758097907",
-            "-11704454779169713276909351"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-98751232093166611752967870",
-            "-139312664474034269271128429",
-            "35063444117900395179797093",
-            "102516806810490076849188468",
-            "74192717816812033285854691",
-            "-146743149862829000033130770",
-            "-141832950190420181845392446"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "78201965083863028268161981",
-            "-9069855773037171038336750",
-            "132188050847166348693715478",
-            "45312541275344755216581315",
-            "-57072509286905908805327196",
-            "-17639505153037819959882217",
-            "78921165012102074114569802"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1613854197834032136730063430",
-            "-8470408631766558968143580401",
-            "-26796998771160976867597896819",
-            "-13968703974822115617423495877",
-            "16391297684868529484428246628",
-            "31996253723693099758880092348",
-            "-28515449027235056800026707822"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "29003901243034261051999340651",
-            "-9217872751721264488488548966",
-            "-36037333564320399226575507178",
-            "13184620706272928711369564930",
-            "-3484312485760312610634417682",
-            "26298119669598487256561916979",
-            "-10337073506268829385902024212"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8395953463471428775558712544937",
-            "3280829292043794132363911327400",
-            "-713339165879923703523124951611",
-            "6966592500081948880026911531684",
-            "9458860222968810665112995514695",
-            "-478657998044149303771109777456",
-            "-7822981040467488960380110589645"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7687380421442439073984466158397",
-            "1255125729759094668996545862678",
-            "4087370506300493221899403471926",
-            "2239990096185047591766535855780",
-            "324855577134097258958507078312",
-            "-3747605668465760865974870493838",
-            "-7517467382536093238063723586773"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2264136733622961048042169712287",
-            "-3680763311587562301144245715244",
-            "-6085544815496196698212373259054",
-            "-4725158409155890778538182765011",
-            "4471247291507677347209093541425",
-            "-7596184803597155735867437286639",
-            "-5336764833430717836720119834307"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2366929765190575517610613077354934",
-            "-933660721467627547628108668944304",
-            "275402050086771070341080860167297",
-            "-364049334222814377243385829475539",
-            "1802721796043278974720830665216534",
-            "1876897254307941830406818341784439",
-            "-407308419988080444605787064480067"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "1653560379001616793860692123874411",
-            "150784992794639309979528542957154",
-            "1110971968475734226805305846564008",
-            "2480908389064352508977069518804243",
-            "-271941929813911201105163823221822",
-            "2522624759865770340700105525537365",
-            "-1998298580902951627476767136760592"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-303303768433761525871131397626734735",
-            "580204425169654418247447034004051762",
-            "501559035276733743240608210997496006",
-            "434014792885862484071273298300463825",
-            "103329211286006486949233240613271101",
-            "-505666350544432180911151793361598853",
-            "64165233750039998288773750264121396"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "424864295799616426484212056964871888",
-            "-152810042904774611567602887301612969",
-            "477355529458883774205927095018255750",
-            "-613775486154323397471667167311948258",
-            "-30862514129841545507008489633366896",
-            "262491469819294261426016375408380504",
-            "128848914605896127620809659768891190"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1176728107084355805100360783355792854",
-            "-7236188428562180415879913333530957262",
-            "47292783010039120381519447577145042690",
-            "-81565099348678451031823780150331852600",
-            "78688059613057943024694270282505199422",
-            "147423850372516204461538795771199943752",
-            "-82721829556506668110250246860473354784"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "151022194687816907306712480755439984350",
-            "147565573622060292887781241703078453904",
-            "-166782516227114338666555252025171372201",
-            "6746685360027376523977385526199820516",
-            "58540530404008066096527055300466378045",
-            "25319977592399722647228094404431005983",
-            "75030966136806031996061647057535591049"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "121830200727005461151499890045616240332",
-            "131014485689583600627833063453380752758",
-            "-30720940443795603452473820184705126436",
-            "-15668097962838507353292677213849146239",
-            "104461885360038312673700885512336746198",
-            "-119938884501349847589471389439448814622",
-            "55172679667339024457950426429614765191"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "23120",
-            "-32572",
-            "-22215",
-            "16976",
-            "6717",
-            "17948",
-            "-11665",
-            "-24766",
-            "3353",
-            "23320"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1104",
-            "-30742",
-            "17502",
-            "24977",
-            "31980",
-            "-21331",
-            "11269",
-            "19058",
-            "11761",
-            "-29057"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "8257019",
-            "-1751304",
-            "-7837619",
-            "3010154",
-            "-2333966",
-            "-204198",
-            "-7074295",
-            "-6464090",
-            "7365046",
-            "4895822"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1458664",
-            "5699996",
-            "3620616",
-            "-6624045",
-            "2550814",
-            "-3036255",
-            "1587012",
-            "-3365811",
-            "790235",
-            "3027254"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "442486938",
-            "441457258",
-            "-74436116",
-            "-923568700",
-            "1944924352",
-            "-1941482279",
-            "-1125035682",
-            "-102135544",
-            "-1196111163",
-            "1765877471"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1765031209",
-            "-1507660239",
-            "-1844477793",
-            "-672110186",
-            "1975877216",
-            "-1203240404",
-            "274438170",
-            "-1671550411",
-            "-554361568",
-            "-163722651"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1263789103",
-            "489447307",
-            "-566090243",
-            "284044302",
-            "-1836581764",
-            "1548735264",
-            "-191701487",
-            "-173609011",
-            "-166293908",
-            "-1503453842"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-7765917028",
-            "-67711994811",
-            "457867171231",
-            "335464190692",
-            "-319749552548",
-            "-252965983097",
-            "537149590956",
-            "-106161385680",
-            "-489362544078",
-            "-324766745567"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-229499927632",
-            "65253348718",
-            "104144370442",
-            "-291236114406",
-            "397153316552",
-            "-2446986870",
-            "-123088300656",
-            "-203970057575",
-            "-542590736363",
-            "-190268824826"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "53278510251890",
-            "27395352245810",
-            "43165128890490",
-            "-125549371097904",
-            "45913496601859",
-            "-88777298033268",
-            "-44578278857847",
-            "-63182483121634",
-            "-615189926077",
-            "-76357287782650"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "125574339986876",
-            "14897658308787",
-            "72773174883515",
-            "42123525241235",
-            "-92023130876220",
-            "-137779513626577",
-            "128721948417075",
-            "-131284549575073",
-            "-72682195461575",
-            "-92062818915183"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-56667925886322",
-            "48625292283487",
-            "118021699876201",
-            "-129645086891796",
-            "105886580754602",
-            "-81412745473268",
-            "22079958372753",
-            "130176891204108",
-            "96533194170193",
-            "11884025784665"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-506532673811626",
-            "-35650957401620111",
-            "3797359512863061",
-            "12274676970376749",
-            "-7643350403625116",
-            "-22952047899787933",
-            "-31801747497539952",
-            "34825544608002068",
-            "-2163219849477806",
-            "-26717933056837916"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-18117789352537263",
-            "-9588508057343771",
-            "14147544466407231",
-            "5358112868530619",
-            "15194998186633362",
-            "-26368440181218293",
-            "-12926433949412576",
-            "-23715017719955956",
-            "2124625137004533",
-            "-28761382221979366"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-611587277931329314",
-            "4788391799910085501",
-            "2015606813848422210",
-            "-8162441603711661172",
-            "-3434406396031032576",
-            "4201771398235074913",
-            "-7185844575809467367",
-            "-6124286884318139459",
-            "9104770916622956359",
-            "776894361998019584"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2442968139182218751",
-            "-6191133470861120460",
-            "39377695956604263",
-            "-1911371627459726404",
-            "-2032902584307265533",
-            "-3918625665352066431",
-            "-3011351064796167752",
-            "-4761219044304366605",
-            "-5873710765610430386",
-            "-4865925097841000964"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "254629702353421818300",
-            "-2201401895035914287579",
-            "162176927797961571359",
-            "-887977538520723081192",
-            "1559680077891008200419",
-            "-1522754607817991562870",
-            "-1961188309718634913132",
-            "1306926884755953118990",
-            "-2195000881232701833676",
-            "269742032865994089514"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "506826741901505999759",
-            "-2184273395087508003256",
-            "924141038875577992170",
-            "-206907928631225444602",
-            "1962143049953611087716",
-            "743436553398815951437",
-            "931022352993641629959",
-            "-1854695194903132671547",
-            "-1981929463828562067483",
-            "-276972122424764490843"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1493690505338340259685",
-            "1586809240658822057888",
-            "494350090577058363533",
-            "-441261947278991503330",
-            "227960094120329115559",
-            "1848792322278602742922",
-            "1557617272354574911225",
-            "1731256272922066434300",
-            "2146230871407347076666",
-            "-918839131781624132904"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "22548387681410857803984",
-            "-486740942160285075283728",
-            "-18757726112678919772843",
-            "290325417808337495708055",
-            "-493613286382529175399469",
-            "-543640826835836745923553",
-            "305872812141626487961328",
-            "182680085006567454977369",
-            "-381084632278529532946167",
-            "-438390880171661736974263"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "456312474649470033816393",
-            "-115833852286009708732615",
-            "68058901001059387892663",
-            "449536434823641408121541",
-            "550535224734224663866259",
-            "600242006088744661574795",
-            "-474373221742191222036625",
-            "-240661321200669878886195",
-            "510976975891324563556258",
-            "56581084876567011909938"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-55030941453838611172063173",
-            "154562453921435135381589722",
-            "43654862091121183246335073",
-            "-37043561098272538846899535",
-            "-84012525778134679892504063",
-            "90521181578289106753547859",
-            "-121101532794400375638986820",
-            "-48962126032349923649363889",
-            "-49416297762321316497159289",
-            "91097613555149997187554026"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "740754556792408749652437",
-            "-48364577771068363588552848",
-            "22689046979811309216159063",
-            "-49805825990806434744728742",
-            "-129575325280951011614339770",
-            "33686330327503040241226442",
-            "132098550234954179034221650",
-            "-19568317425318962814852019",
-            "-85488236163679977350384849",
-            "-32900134218496126753349349"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "129277452246091321049329712",
-            "70220503267517710030799158",
-            "27372362666191002140346309",
-            "150017068938796641247123814",
-            "-83181229560758393426889380",
-            "78268145282577350329747809",
-            "-92583446733322174938991138",
-            "83334736171733181604682678",
-            "5792916388018467792831905",
-            "-79110296716121790367484224"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-6762857221159250494826450291",
-            "-10332119938961796101160722490",
-            "-6827819665107707846347452358",
-            "6329384513346831358274334163",
-            "-35228914666708609766335933234",
-            "-18048951629266414989346849863",
-            "-27226935845799367007517234093",
-            "-33993966153233641238453751768",
-            "-5449254845364088654662599852",
-            "7541505715737170338078113293"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-27624667007791025693852828942",
-            "29791087942990315789537070065",
-            "-31210197914933328681784492817",
-            "-20492515931057444475484015790",
-            "-34897600909921210666914133162",
-            "21001866866717994908958026000",
-            "34533628665541062590101591605",
-            "9988772685214552755442833227",
-            "22086548704119049555142576363",
-            "-16156072487413105847081955974"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "2364616944071636050694451730445",
-            "-4605392974112860339491707249622",
-            "7762016214564113231716204977147",
-            "-5804616094053219373113235353220",
-            "-7149030242509106300895187420705",
-            "-8733720516856953446393989573010",
-            "3766997683445225481997098610374",
-            "-4681729003393749052094837537164",
-            "-3858591495312700256431295473053",
-            "-4277910894337725265278367498545"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-8345846769042618988327927260668",
-            "3034158729600895891904384787679",
-            "-121178995572767479680968825369",
-            "2753730356624797067210787714567",
-            "8954963579041823082665982027392",
-            "1270742333952628369439000703669",
-            "-3722978202569846960374550742749",
-            "8821702309083726610115002889572",
-            "-4646910584068123191099120325769",
-            "-8235420195270182384004027445084"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-4599292704126802281290827035912",
-            "-314623101152193205334021409871",
-            "-629541047462259285195633937282",
-            "3573126210904165261265049508014",
-            "-1688995622757664479276042953337",
-            "-954432643427450256096079589970",
-            "4799594864439399541828732234249",
-            "7068551937371368971824412562795",
-            "2938601954614403464560201414377",
-            "2583981951692907177619688538873"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "1801390123686604711395138083864347",
-            "2408175799973869350806431040308722",
-            "-1778542198055167111435408713744051",
-            "2503317898880974086644685985961064",
-            "-1868573144190196894242583180400118",
-            "2413853351573616737379149363424791",
-            "1791133303754307763813804844006693",
-            "1880584363502969839626017340127067",
-            "2319612620308107999768959466515839",
-            "-1312849382673356132056970324156720"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-2310170941545151210165819902499827",
-            "-737480739959391674903038969492449",
-            "-2309694820066177770799513479215373",
-            "1423472051904245134846442992358971",
-            "260457318140005904743337186826997",
-            "-1594690225193818094407079633825817",
-            "-2186698024851903659624127278863647",
-            "1502160181086743651783854079119431",
-            "-249207087322062171035117292968436",
-            "131669942196137162081550281921265"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-221840655914556742984533980869327276",
-            "541288680814766363243902199787661875",
-            "259521991726914299693855180749498836",
-            "-642098028427571595255754897557274431",
-            "102852117125804159452269997724256795",
-            "-619484029498534054293488403236201260",
-            "-345175355591714711803667121166327599",
-            "-301314861888172625598139699349559259",
-            "-609730883416842409062992565799074655",
-            "230365679128699815563056808949145224"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "148237310969220211917376683153947791",
-            "-210879956694236410559514093773799189",
-            "68825095267034031802766092342803122",
-            "21069100059826162651376609239596285",
-            "595526602428177494983219729529252005",
-            "95671763294916433447636192505612543",
-            "-121882858245568611085988770451861605",
-            "206325916742129711002135164503598699",
-            "57651974744686292971156031485809986",
-            "-320734725725255645082933245576075729"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-138584416420268103904526275311550821586",
-            "5083386037235063597175109391737322324",
-            "26128220661314654796494761140594032479",
-            "12192498025672996200511955739264829627",
-            "85947824515275949989859778737001518967",
-            "132920098023348124785802079171904221898",
-            "111246451182495893420608179633240106537",
-            "-4547602311363102763260302847649859534",
-            "-43987674707274853293509031074465543646",
-            "-7024578484047164009719166261798276072"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-98438730789672041852593692005666781163",
-            "-50079767906520589446732692469907844466",
-            "-161434501044028603998001795580533038376",
-            "137619979466523372085843169543259266571",
-            "30806070627846697101821976362585151873",
-            "-20974889368336688743196860981435677443",
-            "-118421326318547135923082579581184125588",
-            "-36658255136000073539449905192106631248",
-            "41010547609721177330707111502953515617",
-            "116618718482647675602042707539708842430"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "56783177633153952864226073173557138209",
-            "-106939684114816004877527397111208670733",
-            "-53010195457974371105397833315577691496",
-            "-71944649577959370180890395897943740754",
-            "97436272237031860506529444641492486685",
-            "75452790723745404169344305366343804695",
-            "112051243374889808475698084777418001497",
-            "28127293814479165375232961041795735138",
-            "-79340368891394516117475712925796793216",
-            "161366149054331422136847320127220486305"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "30263",
-            "-23222",
-            "-24262",
-            "30483",
-            "-5838",
-            "-11101",
-            "-7596"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-28613",
-            "17283",
-            "12286",
-            "-15277",
-            "-25348",
-            "5314",
-            "14687"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1641157",
-            "7771466",
-            "-5863310",
-            "-7519258",
-            "892965",
-            "-936146",
-            "-8184473"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1892203",
-            "-6603897",
-            "8118473",
-            "4954349",
-            "5950071",
-            "-4001964",
-            "-563295"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "2105362262",
-            "-569111656",
-            "1919017986",
-            "1876055546",
-            "-1146939193",
-            "620406159",
-            "716539407"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2083506192",
-            "-1628538025",
-            "-479438046",
-            "-1422963534",
-            "736679219",
-            "-1232279592",
-            "-724157284"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1286129607",
-            "745445705",
-            "1008263313",
-            "50113482",
-            "-1025981626",
-            "-96567663",
-            "-1070688111"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "418265202101",
-            "-131132103981",
-            "476092459444",
-            "-88185972192",
-            "208316876344",
-            "287012809896",
-            "-90799129473"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-364027495907",
-            "-518301781733",
-            "-87293329789",
-            "131975972315",
-            "532952706734",
-            "65088425600",
-            "-389552284897"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "31618280405118",
-            "-136363944920194",
-            "-24219400967405",
-            "41351280642367",
-            "-133525694845951",
-            "33222176685107",
-            "-48907606129826"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-74180834940463",
-            "-120438687871068",
-            "95491516668458",
-            "111229832917865",
-            "33731924194747",
-            "-126511275125177",
-            "-139437230946699"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-81052755845134",
-            "-75947916229442",
-            "105789356551279",
-            "-77360764385979",
-            "125756275622911",
-            "92621084693706",
-            "-8993873340097"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-218063399041728",
-            "15987427800048505",
-            "5452953879269108",
-            "-2907032193248868",
-            "762605768430446",
-            "-1095257289404828",
-            "12083366342031533"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "10657562176134064",
-            "13537179043764834",
-            "4147191201684311",
-            "-15913012985064112",
-            "18305247661337724",
-            "25826108878037669",
-            "27185142855300649"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "7185681950550884166",
-            "1151981239380928488",
-            "8244169834678820702",
-            "-304666117465982921",
-            "981971288330668381",
-            "5795574764637974961",
-            "-5602631342767621026"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "8858282230609918710",
-            "-5845597164953171622",
-            "3853395376773770978",
-            "-5420964350807318652",
-            "-556878098560662410",
-            "5157835722577117011",
-            "-3095549053985906766"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-980234476785800984103",
-            "1785410146071585960280",
-            "1741125755543744357745",
-            "-2307966711214941804481",
-            "-373078769867949398924",
-            "-1086641478410581865639",
-            "690547933962974045594"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-885097049671576555174",
-            "-1893945141563298628450",
-            "-1652678503714833255734",
-            "-1522111312512895545246",
-            "-1668888046878977777801",
-            "1230021831666666579759",
-            "1588026688627154194388"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-917162439303146482401",
-            "1294154478309086604917",
-            "-1353063508538165826259",
-            "1022085074719266892796",
-            "-1562172028448696446044",
-            "1827858998664290349067",
-            "-1884237502299830467832"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-484334248622047005148813",
-            "148191614369576787178350",
-            "-41916037311516330068416",
-            "564042302843825437811083",
-            "-223411708998089161582419",
-            "-493169217694889240887888",
-            "168822761929986834961244"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-76559387748666164545163",
-            "-9254395158022788547985",
-            "-533412485676057805450960",
-            "149982043973998367780013",
-            "331053556044991173393445",
-            "514169254104754203169529",
-            "-24148845097144387020494"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-110794762039637748701547811",
-            "-112781226990835664252750191",
-            "-126691789751592065497849314",
-            "144891347683530500307750752",
-            "-95002620477467921055244746",
-            "40308052656613620648154342",
-            "134142133925977560550824382"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "46547963198244968911697774",
-            "97558079483281440143910654",
-            "42302799957358224994647507",
-            "-23653725784983135812047124",
-            "-73629112624555133955638884",
-            "147336720269797653946599523",
-            "49289602849638790286981280"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-70628982960116517292670785",
-            "89897841125429743744022708",
-            "40246726976710463297014640",
-            "-18507266936458323746034023",
-            "-127317537089789264088083641",
-            "147526034684993650522315979",
-            "104950772823463920929967725"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-7959063299212980364945888769",
-            "-12214855654426558559365015380",
-            "25951542396314432482289253877",
-            "-1020221313976375715276389621",
-            "-23858719187545844530085394517",
-            "26756899139375533317181309141",
-            "4149356920572734945386012056"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "30516050835182806794120674336",
-            "-24853046938355580136642360705",
-            "17673256930214912186178705872",
-            "3794080846648515873847989399",
-            "-27519999940588367143793580557",
-            "-24055845379132928502612582185",
-            "1667643406878176303891605843"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7481053395824836436290423884846",
-            "-593931320626780956465988943779",
-            "-6000659640663712751730791207087",
-            "-90100969836256549622480172858",
-            "8857339616569823715364996577725",
-            "-4550234737408799149611645636613",
-            "-5298498692956294201665781009355"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "2183123309024430871493750993081",
-            "-7601532421099550450707534366673",
-            "-7300980343536532697821828736934",
-            "1354900935970415000060545678696",
-            "8198340038238087506252124691672",
-            "-865479512261563494978410780512",
-            "-5046161384947842589369454777111"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "7048037667368946471394838100018",
-            "-6071852502042552382040623004150",
-            "-29904067906303750173605027886",
-            "671351089519547849465678121449",
-            "3143301561492705185485961790751",
-            "-6145271153767518350310952751439",
-            "2739965492773135139400075441125"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2567371035309291572933015418896592",
-            "-1613418673846353226340454921565057",
-            "-2365064503966708848862797241011316",
-            "-1542776028214362902586142929151475",
-            "-2077125689533596049348241259664237",
-            "-2395709824654377963034101663677500",
-            "2440524930359057180265130201332264"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "126271990461855730642053909769616",
-            "-2141603070621807963066899994069276",
-            "-2176132802609488796741574791492255",
-            "2332352886535253698579202178516320",
-            "-1988660127485179422598316866522748",
-            "617466151275332301720527118576755",
-            "2496619525601425389231233102949834"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "231635227467662539191613532700092322",
-            "357886376162746208586158220391320643",
-            "372166497885582630320382738692891137",
-            "-387074150560768584146102878863840104",
-            "-397494095284070251215509382375703502",
-            "540335898477711720687165346731799594",
-            "154690828219053775405144687447110697"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "656778981191586847022137324312215960",
-            "378543348336505847394761525402250912",
-            "-170070094972872823236801280112198457",
-            "-10242741317397583042355113808738618",
-            "89873395803487425288992885513379780",
-            "304757291680949813380778307009872780",
-            "-139647342743838007971248857009724115"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-131203220135616441025612961636698464749",
-            "-136533237651213770170219781290216699170",
-            "-115015389154631152533856730671459648641",
-            "-94487920510079112453883494033826826524",
-            "56128697101429071079534166874945886309",
-            "62210939351804546691896889001498845763",
-            "116499323952286447489475520935718675981"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "111388442425565536328400022570545560941",
-            "-128274800782884675622442061938835593669",
-            "-21259026684892744639073607446054060342",
-            "-112426553286465994874443695017393042924",
-            "-6478832771211729175837331925924806054",
-            "88007792352876262937416934703934442548",
-            "-124891073986219943979478446893457381063"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-53247472166305185804034744604113912186",
-            "63873846134112392155257205697721451801",
-            "-44185307140014507458077369663628065550",
-            "82459261534617980418389187926742556129",
-            "-91555320299720623336768030419645817723",
-            "-11478808234125256915529445366937625010",
-            "-284101804019488359263241192605820668"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-21109",
-            "-3732",
-            "-7946",
-            "-2257",
-            "-3925",
-            "-30469",
-            "19503",
-            "8362",
-            "12991",
-            "7380"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "7887",
-            "17931",
-            "-27968",
-            "-3196",
-            "-31776",
-            "31067",
-            "32277",
-            "-8764",
-            "-31456",
-            "-29467"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8341014",
-            "-1946977",
-            "6040551",
-            "-2571346",
-            "-6392818",
-            "2115232",
-            "-2447337",
-            "4046082",
-            "-2062834",
-            "2887198"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-184184",
-            "1975807",
-            "-2304689",
-            "-5917706",
-            "-7687940",
-            "1428040",
-            "1997257",
-            "-4160391",
-            "942644",
-            "-5375074"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "461428707",
-            "-1396927537",
-            "-778825702",
-            "-1909514860",
-            "-890594087",
-            "-360960780",
-            "1809000906",
-            "635847266",
-            "310435728",
-            "-904068800"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1160190062",
-            "-145728656",
-            "1783609630",
-            "-146939811",
-            "-842989885",
-            "-1768700091",
-            "988218247",
-            "148328980",
-            "-2071975098",
-            "670872405"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-824363066",
-            "-368967389",
-            "1685375538",
-            "1129837916",
-            "22659316",
-            "-1334068320",
-            "442107323",
-            "-1555351812",
-            "1240907608",
-            "32207466"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-467348909083",
-            "161337736582",
-            "534040697288",
-            "147508961254",
-            "-55643966274",
-            "338027786439",
-            "-116692579226",
-            "-269893444320",
-            "196082834886",
-            "251179928243"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-470003994676",
-            "322677755949",
-            "240704268230",
-            "503601093424",
-            "-298384610687",
-            "400606205208",
-            "-418170073845",
-            "-133930730273",
-            "134075361471",
-            "481801156891"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "3339778666379",
-            "-52347274197695",
-            "69720482084171",
-            "98924128655576",
-            "12928263807684",
-            "-6851555304470",
-            "51780495955443",
-            "83679464532035",
-            "-127505675951073",
-            "138274778683006"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "125929064682987",
-            "113730203099244",
-            "-100066179950776",
-            "-85878295227479",
-            "19299300138707",
-            "-108539192136351",
-            "99138900176365",
-            "69954325267229",
-            "-74544791461254",
-            "18922888907199"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "45485569650205",
-            "-128562887157102",
-            "-97873632139797",
-            "30278398120164",
-            "50653763282967",
-            "51088353337222",
-            "70065775683504",
-            "-138552521631772",
-            "-77979604107570",
-            "48798953674588"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "9248286127591027",
-            "6920015266380308",
-            "-31298699416650301",
-            "-32620123808864302",
-            "-8198521317945035",
-            "-31784959087849283",
-            "-13290835987057648",
-            "31560002024245360",
-            "15568532723510774",
-            "-1887653675336702"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "6474236439552209",
-            "-15895902060435063",
-            "-28567392174760254",
-            "28377048461337220",
-            "-4788924744301655",
-            "-35902541227577686",
-            "28213667178040981",
-            "27374686655345350",
-            "-9347347706094784",
-            "-22558945363830613"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "4315782565441521668",
-            "8173082059740912464",
-            "-4674157300377953730",
-            "439018152229220757",
-            "7259585234958472340",
-            "3209551603044381642",
-            "-2593722905832184497",
-            "2027467253721370766",
-            "4711777015859247337",
-            "-1809157338227183996"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-694544658659246762",
-            "-4156045606313107281",
-            "2281142887622773123",
-            "-624104445088573071",
-            "-3987668248832946150",
-            "-1357628067592529656",
-            "-7104181881423591417",
-            "2383273081562892502",
-            "4853234144609282656",
-            "6571580420114899404"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1101678549357629021477",
-            "2009977653178126846280",
-            "2037345716315195820691",
-            "-2096610127883926523376",
-            "2194680562745348805943",
-            "-2143848724610431766410",
-            "700093503999313554640",
-            "6460670107803288774",
-            "1291134572995199955560",
-            "-717095483870334127208"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1449785013926244904068",
-            "1586111973600917779568",
-            "1975689855672951561335",
-            "1946100167589360666679",
-            "265628521821771152170",
-            "-948749623912750799141",
-            "-1084337593623251031397",
-            "776286080436824555132",
-            "-494554638041660841031",
-            "-401685002986893137940"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-178940137819013596278",
-            "-370142275253865396698",
-            "-156303150104810810130",
-            "-822078323048785455176",
-            "535756974328325498532",
-            "-890371668586461515474",
-            "279474091115067270095",
-            "2075769840894911144578",
-            "2271112074461256742768",
-            "1263298342536869880178"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "107390994480706624333240",
-            "-272629086063015754481125",
-            "-125381849980531312111076",
-            "323365287095819927005598",
-            "166918591791270045548611",
-            "541466210731753290375920",
-            "412426989884687859377573",
-            "-373858895152711407562897",
-            "349597921666518744534201",
-            "-477064957800482399571210"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-350456949692319622870317",
-            "105130553074956289619769",
-            "-454855427531984650401861",
-            "389828363885037529338500",
-            "-45149503960310017108207",
-            "-364809035488363237149074",
-            "-212095481090572510124715",
-            "208001365502923021156304",
-            "-132773639805291311517839",
-            "524948545150003066797425"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "35259018232949564354576762",
-            "36343724900171873095814458",
-            "-47507355485359376375717880",
-            "-57533411745939815466380662",
-            "-60092847738452003317331023",
-            "3800735336914918445567351",
-            "137812953107886858371793906",
-            "34225766901520865002566632",
-            "-132405725520797481081665087",
-            "-153398838732410672130385737"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "128319155253991829531389637",
-            "43165460069726070921482804",
-            "85467445526390304512322840",
-            "-146762181884606435611421185",
-            "-126844884930818972344264748",
-            "34361835173349993323133217",
-            "-68547202891841302450583744",
-            "-40167006696488837265069472",
-            "-74901074229595686899584654",
-            "-68749948940724462847250795"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-38290033550964318063135667",
-            "-20967313541687634038075040",
-            "-107264911137060066098734846",
-            "89584407711339849997950109",
-            "109335186095373309975629513",
-            "-14494027827192960963596349",
-            "-67509403216005821639193263",
-            "109578027592798760144924982",
-            "116834891439714631179635997",
-            "109674768496669329805900472"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-13706828639541826056708910505",
-            "-23779415475695806226285335701",
-            "-20403054366535638844892685460",
-            "17926682575342545857820109930",
-            "-29969666635246903811911577159",
-            "4322913582730437845509857109",
-            "-5090037359725837740805001421",
-            "18248885943719255743411625340",
-            "-12657516075527000586763065411",
-            "33671850711466671188705676643"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "21441226402320291786796151469",
-            "-489973429642209279383578568",
-            "-36568669593686005393185481762",
-            "13796971801458472172520434088",
-            "-7994017766016214184641016553",
-            "1561490110301188737024730447",
-            "38074453848227878221879512526",
-            "-6611262569813139733823741726",
-            "23022812151767616798249226140",
-            "26695316798647697932393341179"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-6126422073163258556989145139770",
-            "7257045667636323814171654348911",
-            "-5274091940900155174972411849180",
-            "-6812696260414552303993540333266",
-            "-8500309156232696643300971495939",
-            "5321769864659588392049817499314",
-            "-5039830093949469211483714156812",
-            "-6633027512060316645790696983007",
-            "4340429228631480058324378799636",
-            "-1630878746182595626723753451608"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-7314945488320426565820671586637",
-            "-7406514689693791623767541892888",
-            "-4830710931884289793431794199249",
-            "-3758167604048365457370249362898",
-            "5317862646659352563988454094829",
-            "-748850916109857148485910907057",
-            "-2993387002194928323024015231901",
-            "4211954164724882453586630364110",
-            "-7408921561114481661493286530975",
-            "10033288108411665452743017188443"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "8053572570098281818356964596376",
-            "1908605622493118035491961007084",
-            "-5937699460286270647647349131356",
-            "-1407164418808891695839274066972",
-            "1026031202093754747593428440664",
-            "9128075080231853627740826681361",
-            "1150734293920781967788066491325",
-            "3575593240656154263696537723347",
-            "-9578952592909740118052990539663",
-            "9788570458322925906731674034571"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "2546167711754510531653417471247239",
-            "1864915514804198253374517101253374",
-            "1572251731593167469136110804788032",
-            "-1816600003045057303909283771795164",
-            "1520652080462583011477916567108957",
-            "-1734147169849373491334306258765538",
-            "-2447614261820877423091669867951531",
-            "-1826396544811346698392237371607395",
-            "1502568816413254345265156473409654",
-            "-2014610313148128366910629261789779"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1855163614050249786123016316161336",
-            "893899277550555639055767796543205",
-            "686227439600851989589634986801690",
-            "-1484196902391738874780681638450259",
-            "1181153298481188649464625411550110",
-            "-257877919422309608044093539127999",
-            "2468479739575998772676829454099709",
-            "-1539963498806165921795637993389302",
-            "-2243382068201233838876165984414063",
-            "491038991263905025700206542020861"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-597285041655777508836370117424546286",
-            "-212915674112372713563243155334464735",
-            "-169733400631355230665246923231564106",
-            "-257695180843856835976546761814974502",
-            "-159199708769938756688005712105595720",
-            "155463228870223105562821637784150991",
-            "-421604544463741431747680657332448481",
-            "192822447775661213463129358744172317",
-            "-286626526760237236497088410330567742",
-            "-601517958441081087199398706025786382"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-82547444875501132761785352487359116",
-            "-246593569791118450786584777558750625",
-            "-91844724030484160072926648255143672",
-            "-69252035825753540780599407037419460",
-            "644781206633544756310104714559447256",
-            "-262845596528177736487020213988699925",
-            "-375729034479299520248775176155207770",
-            "-479941467647966077592734215031877163",
-            "286117330727391846690235616502481186",
-            "-7294278388158531393325689448264285"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-169130959752592548102532341751116281504",
-            "82587899769437528472252758495774486404",
-            "-77723031252037678358942277533026624307",
-            "-39787175488615223575962629928173399959",
-            "-103079418527774040874191095440451368115",
-            "143404785392510227499220384378768451023",
-            "98751717881147885089187606548239643742",
-            "-80471675701993721480829704293444582397",
-            "-13432971458738065305485925445592722750",
-            "-68143198119846648770859620166719802"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "82277432281188444270047990740605736453",
-            "-140504957823814927502089640850816061182",
-            "48534660051854785030554289649407895158",
-            "6422771152783983559395644304289119920",
-            "162012152615078454305645544989583091731",
-            "37269704291699978324341128764605257057",
-            "-58248048235361087656770889990621980447",
-            "134745944265183112641665968501631304489",
-            "-9136434632101510662083878921980605716",
-            "-11817844733230924939043201144789838478"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-17709917998817602362457338930665430374",
-            "100705413630779255802749096858430372336",
-            "-65652752408617833644830081929182653005",
-            "78721980566008540939950320927524467430",
-            "-157085052161045001481271504295196155720",
-            "21700226768392088200691166712143650173",
-            "89253038833049482190072700821475812886",
-            "-42386752776532873392991410023518397456",
-            "34328803512588938135564393642000374714",
-            "126797458053317029746311576365125139325"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-3880",
-            "28077",
-            "4580",
-            "16362",
-            "-18975",
-            "-13634",
-            "29579"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "22466",
-            "-19394",
-            "4211",
-            "-30616",
-            "-20114",
-            "24229",
-            "-5149"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-896877",
-            "-3561706",
-            "459204",
-            "-7986999",
-            "-3891501",
-            "591660",
-            "-123828"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7455787",
-            "-2954938",
-            "8061044",
-            "-7704103",
-            "-4283355",
-            "-2688704",
-            "-3286813"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1733165912",
-            "1441221142",
-            "-711447900",
-            "-1370755477",
-            "-566470981",
-            "-1689066002",
-            "-1518943706"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1167592421",
-            "-791885241",
-            "-1679872731",
-            "-41746999",
-            "1369029801",
-            "-2099305061",
-            "-380693461"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1876525998",
-            "99057337",
-            "-1107715390",
-            "-1940677144",
-            "-240324753",
-            "55473962",
-            "1797328299"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "295503234342",
-            "231420286475",
-            "-7245442623",
-            "-506030630708",
-            "112634015563",
-            "18061760994",
-            "-112548836018"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-365159103775",
-            "12635282946",
-            "-514650575463",
-            "-389272826188",
-            "-475262038569",
-            "8128202421",
-            "349784367667"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "105099742726339",
-            "89319467966898",
-            "-45683396076389",
-            "-21990516959323",
-            "58719877204527",
-            "24673773662587",
-            "109803579959540"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "117460253140304",
-            "53310537831787",
-            "-50260601769156",
-            "-86329701674689",
-            "4117449846060",
-            "-101524170218096",
-            "-39178939801212"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "116693494366735",
-            "-98720295094103",
-            "-3387455956043",
-            "33422455841875",
-            "72646014377284",
-            "-54216173525379",
-            "-107085335515558"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "33982846762129193",
-            "18070113177751228",
-            "-15344533360160850",
-            "22967009312426432",
-            "-27693105018949244",
-            "-19447372654909311",
-            "5526992817880686"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "22051072322444431",
-            "25739994011608686",
-            "17590147555692963",
-            "-22084188037496810",
-            "-10818514363912056",
-            "3629814651214680",
-            "-13864921149293605"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1477505808877528725",
-            "-7970299900821284128",
-            "797529455893208185",
-            "-4380462832684600",
-            "-7512565283888184630",
-            "5963752963276377801",
-            "5383033152533304312"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-4687001791650362047",
-            "6189713819111473364",
-            "6157195100346646067",
-            "-7354274856118962216",
-            "-2096503882079843374",
-            "-2989958959527548003",
-            "-6990431314703212402"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1543053224502515824700",
-            "572944953559834661337",
-            "-463017450276577476402",
-            "-814539245715762117156",
-            "2125610462348570304645",
-            "-1998974164978877476896",
-            "218777334538713492026"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1737306797700142536355",
-            "1531804891962626834702",
-            "-1195046210647179987202",
-            "2315927533477943693088",
-            "1955617169829065459239",
-            "-622025738336427455680",
-            "1268127968239165761772"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1605308004306756881486",
-            "2011474158613556880412",
-            "-399796168662135031326",
-            "202881347434850907252",
-            "2019703887423617334184",
-            "716418631018448992152",
-            "1206220294128077626983"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-439233385375980423579188",
-            "-282388747616905814633943",
-            "89357877650443882966242",
-            "-141495542322748990965271",
-            "394310253761853869007932",
-            "408555292651658924207417",
-            "31352288232225179050347"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "336925051011166695076987",
-            "-104340070149410931907855",
-            "-577270465951816735176538",
-            "-257830029049203338174931",
-            "-208291608961639617152387",
-            "581220927173979115429157",
-            "-486086206006317637743805"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-29078699886191649638085668",
-            "-58403200017753206157268711",
-            "-30728609198387149996274670",
-            "-64955510531916364593021196",
-            "34821390565272973390205800",
-            "-93422825258783366802978133",
-            "-32247179645343680253023813"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-77365678100681876623290641",
-            "-86628826177603420327288998",
-            "9220094682835113941854095",
-            "93882093552015539929945204",
-            "-150721224176965634213377599",
-            "43753026435426938659269571",
-            "66570450267194288255165042"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "26300179792340119797864079",
-            "142433122880117613936146124",
-            "-15440885853316070864672346",
-            "-77502061475155985937091480",
-            "-112852326686297479782561254",
-            "72434505811059791598110246",
-            "-7668392160648564895359533"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "29239766717040730171831641774",
-            "-21707593058421917306282917041",
-            "34516607235563142943063617602",
-            "1193640916706101190985687069",
-            "35195812678373567674988713830",
-            "-4604316293532843686268059747",
-            "11180352632046834701829653097"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1512268160667408885922336144",
-            "10844547914295271624025530713",
-            "-36215819512055547591428396750",
-            "-2810331321951135608956464976",
-            "-4386752948121646037249312193",
-            "-17767553783444186492160681129",
-            "-3024939524547086439531257635"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-20864326575772010142787316454",
-            "7488713151399696482410740417311",
-            "6381276422733482520358034285380",
-            "8884761350831459122090428512810",
-            "9969195609900524295444588216806",
-            "5543397900882544648824130766348",
-            "2837938767703679300265023672696"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1882854523229835368724322985294",
-            "2966116522928193897186452665796",
-            "6823275008349281974665560465394",
-            "-8062354025481937215315488548524",
-            "6765883098885847750323695485797",
-            "2224258611402637372812075498606",
-            "1096213966837685819229458326999"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1594645032934746910233970766445",
-            "-7888607865300585433234547082596",
-            "4568621404199252787882732641526",
-            "-8445702981648004651693271114722",
-            "-7061451521435267187519509650848",
-            "6696570366244357679289327894924",
-            "8441199880199722664043107998393"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-968352259610893197064576275508718",
-            "718654181183934094051419872500011",
-            "2514405299754440481837754186402421",
-            "1800516623297456299756852785790978",
-            "1735762811642360734642777500928026",
-            "-818427028473555572485098076829014",
-            "-1159041509361012508054712578014787"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-53546281846072725871658001435887",
-            "-784630734436542795241759169811923",
-            "-718526749795888797678293952454287",
-            "1156515964581299989003720410728362",
-            "-838405070125273270332512952593048",
-            "1940449904167314426051872957919891",
-            "-68651512522935345206569837233327"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "572850491437435230154655178596404256",
-            "255907180028216856698708583682335802",
-            "467380937533420611084983609639927678",
-            "-578776848219875222429940192462905503",
-            "-305437010432528222408867961277657933",
-            "444241914984458649589370317558151484",
-            "-437642956538688234838513076311369227"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "358312056397600081928352831952683806",
-            "230966521966579976309413468582413234",
-            "-454572317314346054050950281223398637",
-            "-514645527798405383965741984798628527",
-            "178604228774099539826674396572478175",
-            "-617509561026367858818205129274682551",
-            "516749383280600313391592174692222877"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-123120621344099237933440205349374488066",
-            "-32225408253558378935144372215319566228",
-            "11301001788743914587399424830593135310",
-            "-52673174720412201741335076711264329300",
-            "-118712794710184498260756820285222988657",
-            "28574446760716238823537127611396566250",
-            "46215799970023783748448065488919483477"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "58353390412480195555770446835562760276",
-            "4833546377833498062150899905495355127",
-            "58373007706619991431855338114454320484",
-            "-70703504770529836816766481390613100369",
-            "143910284033581946098683712226489458302",
-            "117235434241994039601754355029907027922",
-            "100290083016626428361996754831114825823"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "77825035066067814510953781223725256637",
-            "100986125463015864365041226255651190014",
-            "119992813429982672016306816732813811809",
-            "138695082079580523445519172685734788839",
-            "-93300896559078568544280378088130535661",
-            "-21512916011354134398283958037251369915",
-            "-59254623236285041945205874576696705580"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "18754",
-            "-17855",
-            "-30143",
-            "11781",
-            "1051",
-            "-18103",
-            "3181",
-            "30569",
-            "-22565",
-            "-27059"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-10966",
-            "-15974",
-            "20424",
-            "21589",
-            "-20157",
-            "30323",
-            "18376",
-            "8005",
-            "30511",
-            "-8141"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1843361",
-            "-3517196",
-            "4625468",
-            "2321631",
-            "-7687911",
-            "2778344",
-            "125068",
-            "-4052771",
-            "7945865",
-            "6630921"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2367184",
-            "-4826645",
-            "384943",
-            "-2111816",
-            "-1600561",
-            "-570653",
-            "-4103404",
-            "743335",
-            "-1107912",
-            "-6354480"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "1229589203",
-            "-140746934",
-            "-1838286677",
-            "-1878305406",
-            "1961215412",
-            "1250128901",
-            "-1166900225",
-            "275507073",
-            "1193731503",
-            "117609926"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2112929173",
-            "2144863319",
-            "1992254245",
-            "-1937627007",
-            "1514668427",
-            "-1839905388",
-            "-1528455662",
-            "684780309",
-            "285489556",
-            "1981384197"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1886553183",
-            "-442912398",
-            "32808274",
-            "-183696654",
-            "-36971109",
-            "1971012659",
-            "-1278373247",
-            "-1688683464",
-            "1543369024",
-            "-1978222221"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "516696037327",
-            "-133356328060",
-            "366887410082",
-            "229447810393",
-            "-446554774147",
-            "-403087474672",
-            "-332879324979",
-            "-201414959734",
-            "69326493096",
-            "425678448609"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-439293553812",
-            "81933805742",
-            "-183895960348",
-            "-496786511195",
-            "313438779807",
-            "490045940301",
-            "475167170007",
-            "-102296474200",
-            "-69324984155",
-            "-419967280054"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-96551143452313",
-            "122054609553289",
-            "77940246274132",
-            "58988438553627",
-            "-37681781403480",
-            "-19891162801465",
-            "135285406649690",
-            "-79327539900948",
-            "132470331657036",
-            "-6480637466609"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "139797814993535",
-            "30274745342542",
-            "112817172422674",
-            "-52131523918633",
-            "-137459606352282",
-            "84222662933576",
-            "-98419098319107",
-            "6437228832991",
-            "81243750066175",
-            "-6421108664511"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "77769134597368",
-            "72127816622848",
-            "16103132204416",
-            "-7118137065494",
-            "49038964068498",
-            "86622864654107",
-            "32928568991190",
-            "-93632446337391",
-            "72127053286297",
-            "-103694778424640"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "22116565043461009",
-            "-31711615551037511",
-            "2821246731201391",
-            "-13351247986191283",
-            "-15623501709378161",
-            "25262423813103532",
-            "-22343569817384923",
-            "25928473716871331",
-            "32038496333487076",
-            "-6890071520503891"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-16647068290977681",
-            "-732120677335230",
-            "-33532489576560866",
-            "17792605822942940",
-            "24198243709120098",
-            "-23282344775422150",
-            "-28675151281288448",
-            "-14495501421676227",
-            "-1863883724884560",
-            "10312379020348421"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "5502360856538125985",
-            "-32644019016852151",
-            "1564692446235537384",
-            "-117754471439160800",
-            "-9013223642801616724",
-            "-5023267401335837159",
-            "699232645927291479",
-            "-3584329191084872093",
-            "-1311864165271950824",
-            "-1215291485581331201"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2526466500631342193",
-            "-5409822186679340641",
-            "971670265469264458",
-            "-7179072119717361795",
-            "7670806788162789754",
-            "-8318882969144120324",
-            "-9117830171517155584",
-            "6877332662750891661",
-            "1068609140965782417",
-            "-4925546114463183284"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "57583945723378415772",
-            "-342232111928136964405",
-            "-1195237978858213658562",
-            "-2068806789801380063600",
-            "-345026535447781896266",
-            "133610950746109877229",
-            "-450656040906061504998",
-            "-1893962609238091988400",
-            "2350599054313986251061",
-            "1880733516481080050212"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2249590711027756564860",
-            "452844566121110339696",
-            "-1922925439694884164421",
-            "-1550876878150832998572",
-            "-1185260961134674742569",
-            "-2039283323590053548044",
-            "-1687563918950261572963",
-            "-1944597896900829991591",
-            "-2359460784165763037898",
-            "-849961236635718175763"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "39964951314827779563",
-            "-372589960613063031098",
-            "-438035602871932031986",
-            "-664149217874104492300",
-            "-775029718832463979623",
-            "-1435477218213206627730",
-            "-777662353097751064825",
-            "-262402700201170887022",
-            "-1133936324748952947710",
-            "1327754548066739872375"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-190787733056613599495219",
-            "-515734754496362833319535",
-            "-574734864992365444843708",
-            "156606116703304701360073",
-            "-548629563358608342499088",
-            "314352279479464825255103",
-            "244688836299970664478495",
-            "223517627384801717925625",
-            "317460265141706669756597",
-            "-143088760391778698353724"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-121682002183738855835622",
-            "33829240294738771467442",
-            "561539377338103121964304",
-            "272589000480746001955982",
-            "476056122948827385095616",
-            "-483571374749297317898197",
-            "281143130465809637777850",
-            "-252495987618098543389302",
-            "394527250215970829835810",
-            "-371881433858127168330471"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-57554220355698316288465256",
-            "-76017540520824653711945808",
-            "-119283376705753351997748235",
-            "135285600664968889113349822",
-            "-56831347642867226553961594",
-            "-16457633406117235070315269",
-            "94381218510174633599528949",
-            "139553957700687764923892613",
-            "-53986781389720021194280790",
-            "-19994198089108196976112296"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-82576387180835452318210228",
-            "-49951144242867126451613703",
-            "62645934474937602509471162",
-            "-22809010733349138696349721",
-            "92648271949016552757106864",
-            "88129191312931452389255255",
-            "48011438537493230295219061",
-            "-78095235259711088591460034",
-            "132652997750328176815451796",
-            "-127305214162620317777045127"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-130726889859542614597966076",
-            "-56150188916918748446918856",
-            "131676166120048204530142114",
-            "-94402515536541962124681830",
-            "-141920082631622521770167745",
-            "138796510001418272242292175",
-            "-25121938667485895566695315",
-            "-121172442589103978423419243",
-            "-20614593640357879353182241",
-            "-82772743389453364089604477"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-29032726342801534955983348833",
-            "26158471499703236988192974887",
-            "-20114116207465444344361601128",
-            "-8681577131743649610696414703",
-            "32981177147751632167653843307",
-            "10715468167954459453141416666",
-            "2302451135115289498612037956",
-            "23070910964316738454734382371",
-            "-33075125932954753049741121323",
-            "10179913539917748846617161898"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-18085869738221726864797815861",
-            "-22337076672294140460410142760",
-            "-36126257950244891489093166216",
-            "32551071786984003673681244792",
-            "-2850364559142517973517854327",
-            "30988135871042625915127743204",
-            "6816014999562698392234131960",
-            "11494536675490631889014354130",
-            "19518893252904531723609256491",
-            "30427336543604275087551984403"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "2206367769081757187272650503139",
-            "9091361631393367270835435652597",
-            "-8424167241080231285345475239019",
-            "5834959797812027161305666236164",
-            "5192168644968070279507303594280",
-            "8341506527326618523722473942428",
-            "8594436209974939893446936907176",
-            "8681682547098842826265765019748",
-            "-5209020223570640459802520771750",
-            "6129943703376515947722773721600"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "9047109249979470996987065428892",
-            "-9799662424789913378125551587573",
-            "-10747887838497246955184907970",
-            "-7651592187822100343817178833722",
-            "6010095747552236822560336347090",
-            "-9204712857936864198407587203238",
-            "9268329208382510346394692142454",
-            "8372710454424791445966082256342",
-            "-9589445085108256491425243830947",
-            "-2939036102518584405497956526954"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-5392971967770555579833623091396",
-            "7010238060604152385637944463012",
-            "-952157695963924409916700180566",
-            "9774556009383087545392285658966",
-            "5770727225973437448322228561807",
-            "8118034587530249294761621086593",
-            "4629045275285811417199668511474",
-            "-3061439446531807421688403151892",
-            "-1370462548021359419092251720599",
-            "3949264862782238848089672597134"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2122708269622350729686602450849918",
-            "133816358693598033876477261324945",
-            "2416602162368187687173545193833207",
-            "1033421043633734739603132153227481",
-            "1940044255763482239251273519489903",
-            "122404165677034509854998880971649",
-            "2115709380653150711430911081473587",
-            "-954697183455914334514087563443341",
-            "-2123319112143807840315352640840117",
-            "2069575612420264676616069495687633"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1692523376605227556299724175506026",
-            "-560133778627251677678012123636755",
-            "1544300548641566325099709876685852",
-            "745074432149870035759595939596681",
-            "-1954945128503766900016994683433198",
-            "-2250046900317020802445312714834438",
-            "-2385830584607782067723440542099762",
-            "132290783232525067349828502622213",
-            "422538990938605269068919642797432",
-            "-1355056714352703736683115064904273"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "569637448050074280085390862207666873",
-            "-493782672094432637986628201979332547",
-            "559997888965253767870152932047889365",
-            "-192294596493342415461227479481558644",
-            "-467823747943914593693180397447717393",
-            "-180358592750289795012663508384651702",
-            "-277633416434123648393250047500800405",
-            "-161316286985680702736242426514896331",
-            "-107565346718017079645076760979976254",
-            "-343028720252730035978891475737130091"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "234202228460068979568708307032847949",
-            "-40201170775316769341182286764965389",
-            "-548980577113599607444799254971433151",
-            "541309219470209179356416121398240002",
-            "-434133022569940359270892323517092074",
-            "-273560039796167418597819102027246382",
-            "-476192949086818994497703488377408870",
-            "538618952671800675393447490544116473",
-            "93123165923308661421936492785506839",
-            "-637742333921319974000307483554747580"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-57037547117361632743720819923766599836",
-            "-98043608090325780586069692996244560497",
-            "-58505160656452186950211173738911382547",
-            "-101832799685426843314478830415915453714",
-            "88565658613827585716212234902487873212",
-            "37993662471162893207714631860591274024",
-            "142774451425889543215285746860042086262",
-            "16769512069264042461946104154625579535",
-            "-47552828674887709372081650891476109271",
-            "-42213620497501762639143979558467451605"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-147371756269307190381561519577768333146",
-            "50001054768402174217442186921551216212",
-            "-37909857998845694340361772993373171274",
-            "26488762795056480696073949053739280517",
-            "148945896988690949823595206483101743044",
-            "72542903931524796290465216241047509873",
-            "-167126191952176091620300581762459791416",
-            "7988430434861579711046106333746313228",
-            "-93130434033478424433799959885140345146",
-            "-3441472474979605847594343058062446207"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "46136426115595487614083206992753880226",
-            "-152038433918307384545322896116023034965",
-            "78938265199256609159965233504637641814",
-            "-92829030003981682199112271693126981849",
-            "10428026972710553277643628999246199628",
-            "-733720183320183133584540075760187261",
-            "-21944082237248471904000697107198113161",
-            "77626504391158473624750083478122906448",
-            "-159953023283206971997917750080649331297",
-            "67741969038939169538736690551212738571"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-14965",
-            "4396",
-            "-28370",
-            "13432",
-            "-19302",
-            "-25134",
-            "-2325"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "17774",
-            "12772",
-            "4697",
-            "6699",
-            "10195",
-            "7948",
-            "-1073"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "2170666",
-            "7768056",
-            "1730086",
-            "-575771",
-            "6874141",
-            "-2918802",
-            "-4009750"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1145774",
-            "7588162",
-            "2538941",
-            "2814807",
-            "6420688",
-            "5552162",
-            "61716"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "475579788",
-            "-2110736469",
-            "-1038349020",
-            "860173314",
-            "685087056",
-            "2099281387",
-            "274916519"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1655873120",
-            "-1731031947",
-            "561894379",
-            "867850098",
-            "-1594780953",
-            "467730702",
-            "296381326"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-270809066",
-            "-1724753578",
-            "1076930264",
-            "1046992208",
-            "-900063126",
-            "453135840",
-            "-1402444227"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "543756676973",
-            "13894519068",
-            "-471273054319",
-            "-361667009872",
-            "347117046185",
-            "352117261872",
-            "428679947623"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-414574595169",
-            "536827742264",
-            "73835628644",
-            "274376152363",
-            "294589390066",
-            "-11991628898",
-            "-253347644755"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-19215636889418",
-            "119919740703605",
-            "-53215288815658",
-            "-33327361054276",
-            "45198301326977",
-            "90776449725838",
-            "138054869379894"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-119367237365312",
-            "-140091389309758",
-            "15475687696688",
-            "-38031515520518",
-            "42841758149017",
-            "69022243350084",
-            "9179513583233"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "41132552781971",
-            "41253830277347",
-            "87359934843401",
-            "-95181726796502",
-            "27768710470810",
-            "65809922501001",
-            "-24863795602983"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "292236195126093",
-            "22719593938564618",
-            "-19218388071157930",
-            "33981265825341884",
-            "-18509717253371672",
-            "30580146808867540",
-            "-25999233818244727"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "28135088215434228",
-            "24773690318810918",
-            "-26724803220639117",
-            "-29814061818363701",
-            "-10766489482800560",
-            "30758073781326745",
-            "8776059520448382"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "409254481003117766",
-            "-378161134041351348",
-            "-226782297600641326",
-            "-2884040847263852027",
-            "-8247477639592596195",
-            "4107975741440930492",
-            "6909135551839426970"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2652868014887595347",
-            "-938854012354185866",
-            "-1598192800799770751",
-            "-8491269256089485178",
-            "-872167601828525845",
-            "8058502300329141671",
-            "3061608648711594103"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "146769264186631567632",
-            "731409928392690360238",
-            "201264820200577960524",
-            "-1212063678184800014575",
-            "1402459273537500628832",
-            "-1321984359334412491423",
-            "2211457652738431111859"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1847588624832707279911",
-            "-1813942494389916835789",
-            "-1958404120436196946126",
-            "1723793223754906327044",
-            "91104121605339071868",
-            "-37127427643123176929",
-            "-1759281127620720025265"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "621171459171060457840",
-            "207620657443600214064",
-            "-404297398702992699514",
-            "1641661352402425721053",
-            "-1968173283051339556925",
-            "-1975771117070391869479",
-            "-2326206316062007904468"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "157960797511886924834578",
-            "-341648681181914186464072",
-            "-496733650079984967364838",
-            "-444089180371365298276212",
-            "545885788394993954738089",
-            "335428473992315516320770",
-            "-8497165329921324825223"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-38994153758728840237480",
-            "300952907927512214570952",
-            "-312533402564800726680664",
-            "-384239115396249647073708",
-            "-93282765318781444842024",
-            "551248528363972986694971",
-            "287731359865140964525224"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "101025247865168925900922830",
-            "54857286231629651663501039",
-            "53544859669524419312467353",
-            "-124478605232939875253548620",
-            "17285305918706892564565360",
-            "-109106338103303620219905680",
-            "-39866206645357083787763508"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-85724769944287781078609302",
-            "-11704976431025150432522098",
-            "-140709446005420876354105607",
-            "118949605388441528679717522",
-            "147415669254850277731131009",
-            "-2518242221011392198813403",
-            "-110299103632345032256326636"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "132459645720204436026597326",
-            "-75684750458331130703402700",
-            "122558708866408634795154753",
-            "-110485976053300938316559281",
-            "49084715923367850211269998",
-            "96960123064705845023119238",
-            "123180430855167057989302957"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-18936205707758319951200347669",
-            "-37258565469174214424589588093",
-            "-24453048320489113118458406056",
-            "-10587746588216050364022206474",
-            "9748825791372076261497902071",
-            "36545682723514548638183652663",
-            "-25861598120327052219989832099"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "34252212325207935596745602246",
-            "-23818237350808788371236620972",
-            "36226019636259967938400145050",
-            "37192973754494387619137336106",
-            "-5057174993081801990711137100",
-            "19315470624682365399645492525",
-            "-32772028697629595902245624670"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-6792023322456998237800922079479",
-            "6549013706052367027552378139504",
-            "-9355871158471909412376307831412",
-            "-2030077667778674905770995357453",
-            "4297878705058522858422532653176",
-            "-2236484269757156229891142724479",
-            "-6040135630828160347217599800148"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-3599439677962085785168307719800",
-            "-4245900385327794216010405726579",
-            "9450764155817872025990436327715",
-            "8656233260540192979968625227977",
-            "1160854863482601034702346632871",
-            "3956026374789035457631650901065",
-            "1453599630928365440553293992121"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-8915771384062939324293344072095",
-            "777633297413063771199232835099",
-            "130337830279869604841710324103",
-            "-8373921460052275293875653314023",
-            "-5246842589420902120766262884279",
-            "3729544269328940809924381217876",
-            "6272763819900035423590366605426"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1617716673371462402162303323419703",
-            "26336765354063275118084261528831",
-            "1492712908830805398072707084234922",
-            "-219159852068967847470786902528212",
-            "126542964660097922190866932619843",
-            "889878290610547866308346440500254",
-            "2086140459688639708299971129281292"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "111351977899132479809610701899734",
-            "883054552995427224030821200597311",
-            "-2065448421761013752757262983625041",
-            "1742123659066570365356027485580166",
-            "-1214139633564246959114082011858323",
-            "-1329417508775576485092806838462803",
-            "1116415564152726849396179280195975"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "25792382598206920383056857113445849",
-            "-225206309711067108325919531991796201",
-            "404950774727900383585705746884848243",
-            "-470637440392131155991087245263637994",
-            "230147369983625933489964301980421634",
-            "-371436034781333002283883627046974041",
-            "560240201817281749776706447503520796"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-184751107296655537872267341147777926",
-            "329426487040671280863523825102062539",
-            "-418105543114253529014238351683881534",
-            "-617932739175887659472533031137397189",
-            "498336206481632051733278557649532891",
-            "580985420014217396923072878340987450",
-            "-205539611656251655979522315213206497"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-140752175559703681946897226667461340778",
-            "6561236723375434393948178304575297047",
-            "-51434996264522492401719681071804511089",
-            "-125946647710302371061500790543557458955",
-            "-133398205151504361614506341930758954997",
-            "-25733469644094471567565487452545498665",
-            "44048098477441865782455673692289495153"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-145448294825692173492641127474455264094",
-            "-121372206006141296987868818880832869230",
-            "-141786136125809700329851146916010465431",
-            "-64699237500646340071065763833604265646",
-            "-57587914054490682697769053906782102087",
-            "32192058203820777323675957815817034772",
-            "111541312639824620042046577015667034684"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-120964441901874362290104187440391939364",
-            "-96084745151601772727177422680207591805",
-            "-166536914660320577793788842820747499277",
-            "61156293370756011979833006538029339427",
-            "94985231961279433991237396849461866817",
-            "43959734247759347414496739857098340817",
-            "-72248466678766711563463040091419174562"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-6120",
-            "7057",
-            "-6295",
-            "14831",
-            "20732",
-            "-7444",
-            "29138",
-            "89",
-            "-31431",
-            "-8017"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "32489",
-            "16222",
-            "-21842",
-            "-24054",
-            "-29957",
-            "6345",
-            "-3733",
-            "-22295",
-            "-1301",
-            "10500"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-72740",
-            "-2017731",
-            "8013529",
-            "8012822",
-            "8352456",
-            "6421813",
-            "-2425529",
-            "-6607883",
-            "1881808",
-            "-2234254"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "5181661",
-            "-3577958",
-            "-4493738",
-            "-3295135",
-            "2544246",
-            "447427",
-            "-4432217",
-            "5249513",
-            "-4448902",
-            "-7992598"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1569315361",
-            "418335588",
-            "341076905",
-            "-730203548",
-            "1269521259",
-            "1784051884",
-            "510427112",
-            "-1268247751",
-            "2018024071",
-            "997087873"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-162075630",
-            "1319926606",
-            "169298867",
-            "-921839919",
-            "421705930",
-            "1771873235",
-            "437874475",
-            "-312980929",
-            "-392069627",
-            "-1446413247"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-699761346",
-            "-1098413742",
-            "800470076",
-            "-841985366",
-            "1782178243",
-            "-89008181",
-            "-1616551429",
-            "1946816503",
-            "484187966",
-            "-128499562"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-15033977299",
-            "-446057719500",
-            "481043288478",
-            "205263251758",
-            "-56863332253",
-            "159382478645",
-            "15497510247",
-            "-11166860082",
-            "459845389844",
-            "-315779255031"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "13619924768",
-            "-108585103579",
-            "-286333703121",
-            "-22225593305",
-            "-4214443693",
-            "404081003905",
-            "-266115340439",
-            "-522963986885",
-            "-81541686728",
-            "311449667067"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "3440291968557",
-            "39790668036317",
-            "121143735330951",
-            "60300700594106",
-            "-138565677223306",
-            "26990651262138",
-            "-69507089026735",
-            "28346271500562",
-            "-68434454958",
-            "45308688118409"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-30985211143486",
-            "14497903153172",
-            "108091472626361",
-            "-132443509279150",
-            "-124710978475843",
-            "-22621813043867",
-            "43348381090099",
-            "54224054718466",
-            "43935291459066",
-            "106409780408478"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-37426243585738",
-            "-136731105244763",
-            "132386170102737",
-            "18729575753580",
-            "-61381755765885",
-            "-67683935577429",
-            "-130715456782347",
-            "135506741441431",
-            "64115570795686",
-            "23904178460900"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-3109726999519689",
-            "1933126768037472",
-            "-324967063575891",
-            "-30747070522132113",
-            "-27829185300215897",
-            "-24226320094880357",
-            "8149118499338522",
-            "-14537608810060536",
-            "-22181098580998350",
-            "-1543766855453763"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-19154567959160505",
-            "-33714007900076962",
-            "29435912661346051",
-            "35448248561967655",
-            "27478015216841137",
-            "-9642727074664549",
-            "20762876950068092",
-            "12674801929871187",
-            "-29272042854662323",
-            "23087590778346538"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-6178990937608128005",
-            "-7489771860953428316",
-            "7138996857544191473",
-            "6891721369949758163",
-            "-2873210693718606357",
-            "-985023314566108394",
-            "-8482975523737005038",
-            "1933121339588994379",
-            "-6237609370968336133",
-            "-6006493915891200615"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "4784228838256112666",
-            "-5639521520326372798",
-            "-6372119935029533050",
-            "-13173761350189796",
-            "5256559774234064648",
-            "-7639941297675590428",
-            "8339054501857458814",
-            "-5851965443287017683",
-            "8471016463241511679",
-            "241927931394313236"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-483218027063613629703",
-            "2158782735740085418214",
-            "2086327309425994289085",
-            "-1775936067034501989571",
-            "87437755811834396167",
-            "-28401153096633450165",
-            "-1133004021229840529093",
-            "1871364394906942992468",
-            "-1367249310926305189706",
-            "2201573961610082633279"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-534665456095867317406",
-            "-2091145637438156527744",
-            "1002549198487665026269",
-            "-1829053960401122456656",
-            "-507210040486661453955",
-            "1045481287999809175028",
-            "1364780996043256384861",
-            "136073480977825489240",
-            "-1037248082018171019376",
-            "186526137004977787352"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1046613079302385912677",
-            "1021357072861918022642",
-            "-1212895629888241074297",
-            "54602995841860468967",
-            "-2328862578607448318042",
-            "480770704064136552652",
-            "-2205462302944763257608",
-            "154486372431065433621",
-            "-1627545550801203651319",
-            "1661236305135671491366"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-25780050424235659153148",
-            "529910266796805109246568",
-            "-524035727043667850771484",
-            "158037899710407903896118",
-            "17775205387059778764118",
-            "183414271106923495875624",
-            "564101025301896167399950",
-            "174082107953749604159417",
-            "-510247241020792959694652",
-            "-31790257572439119641150"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "97909310721294570420676",
-            "-370685916895270859148094",
-            "-207704549226119447779963",
-            "426685027916926492394771",
-            "-443922064163037127693132",
-            "-359165394706192831593487",
-            "232450412648501709276260",
-            "236476482318617346453058",
-            "-444855507997557301532066",
-            "-449511488318489004842616"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "38297941459228367137032480",
-            "37693160058585205753349341",
-            "-135230435965114188640670954",
-            "63954600949868348155966793",
-            "-18059488984707719081771228",
-            "12523259782961827464033972",
-            "-154035891838969004456038899",
-            "-143740984881393038015437656",
-            "-297107082262287737774124",
-            "-130063144978385075413421572"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-121901231315087756982129772",
-            "21641765111158040359351177",
-            "79510642319690549494318636",
-            "99992072265161738668933440",
-            "-127544045958283514926879895",
-            "-114814479146472538283905870",
-            "-6956674791158590081188973",
-            "-152063567955740133520378519",
-            "35283887938627339173013183",
-            "-77488852854891430841283266"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-35297860946578727078961377",
-            "60914664428732973645334926",
-            "-45881788007565335539581505",
-            "-16228932271534174997165412",
-            "-71589554478597723028529083",
-            "125241806056796930297219831",
-            "-5330340415825203344097529",
-            "51775257591241051145892674",
-            "-15094772395361486242521560",
-            "25938645275060872598806563"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-37399043524295253068535150516",
-            "30416211250451302199476070853",
-            "-33596129413262219560422312517",
-            "5313931682258453540118628812",
-            "21048003994659574916664477845",
-            "-37382894423738432073629190847",
-            "-15318095353333670892374528768",
-            "9624056340871881017715059148",
-            "-16108266238759019605768116174",
-            "13607318011608209290042469481"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-29339095371120961510655959746",
-            "34499077642097337163200996883",
-            "12438610605314642729365206169",
-            "30026217552330912860684967035",
-            "5868323165870187705662338709",
-            "-22530513597085742496802571404",
-            "20187377513734548340151159804",
-            "19309445557615337894124357368",
-            "-9834900335171895983684326501",
-            "10977735104041542369404969198"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1375924286262127484011633937832",
-            "-2147016509826786120906015229213",
-            "8312572357614785735606012528886",
-            "-4051638098169024644782191731949",
-            "-3093628440576237730249167513209",
-            "5666878520633789566902037223594",
-            "8891965700337502827869504398273",
-            "-3425704790604702995311162396482",
-            "-6523722055221807095862112250242",
-            "6355813979375858041213525598182"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-5058425412398335303061912485394",
-            "-7219572559975239271635947264369",
-            "726522491715344256514490058497",
-            "-7042445872695173559471595541793",
-            "2824402214773339173380186665274",
-            "-5015784004233448712622655297019",
-            "5486760745287225222007329633188",
-            "10065222761695430251439328556933",
-            "6166669897599573455003032087428",
-            "-2172662097799258720481847032564"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "8036993285327716214363526967047",
-            "4430074085127306659301038354391",
-            "3362256777260202908602746872178",
-            "-8231357790598764797150571723919",
-            "-10113083855460126423773664315153",
-            "4304195785667284780679333446327",
-            "7529022456114985130352846237161",
-            "-1617155253974148221187702205421",
-            "8306989535252982450393679766069",
-            "-9917879652040843830362880242798"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "2025150411878375809601981318007687",
-            "733154270680517806621380045304125",
-            "237851062444860227206988707561392",
-            "-2559173073631870285694845698600192",
-            "-1612871136126666613840893942772465",
-            "-907529648416027223413166136860388",
-            "-1839189396233732473729596583035690",
-            "88713624503691341082574108422443",
-            "338402803145217006589478543497297",
-            "-880122644115442177811028160833635"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1839742964889166195100300692473716",
-            "885434974408265966958762326684680",
-            "-1621828050026346614658514674603315",
-            "1905665376759464813614892131583581",
-            "-2388201929527636648329898098952877",
-            "2481877047862950402685641670256262",
-            "2023252640349615986505312617764433",
-            "-1573486913273646294139059870810833",
-            "1805414520297065811367995244619334",
-            "1843061646556820707723637177021074"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-191847997784246847874745009499399054",
-            "372786599802160285128273261461255881",
-            "376288273710337416992985070127844806",
-            "188093861376600388183605420152756308",
-            "571207793825131270518817095820136067",
-            "-29919619103217554294662107906751719",
-            "-452678708024430178885781299576494992",
-            "535406994206915746718046269323872661",
-            "640280552739110271190723844875415792",
-            "-600187294174532632129083155832394691"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "160335860551254932275470660660164261",
-            "-471326848390488335045668822156269822",
-            "-495691107470112053256769582261403309",
-            "-393200617684151831876978692678316885",
-            "297414113438652864360156678843959711",
-            "-268776834626793693334448405382040859",
-            "-117780897867754527460881147518546805",
-            "298322417140430849049049944396274055",
-            "234866336354615854416417135899865645",
-            "48595083212054770623391355746687188"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "46767536875344963516160138900400417992",
-            "140769783767864571592597846120527955449",
-            "-87767956607006201530442382053058191437",
-            "-147467086345147382218132338434959967344",
-            "-63040799227207808871886672405579600857",
-            "-163413759426610481573012906592956738336",
-            "-51038824199236863589719906709018954970",
-            "-144531515418551447921937889834182877513",
-            "-167321975433722954448458398645759050579",
-            "-123967516821302237595171386295592191011"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "79453031253319883075571062614534868736",
-            "123921984663798339646770377207635911524",
-            "-157303675968253574763215319217464671001",
-            "-156891299361397755454566840636980983938",
-            "-145862034846283521653632276945573288715",
-            "-28726972658144915880841740075557050787",
-            "-59175893681203716281306184534788761148",
-            "-116003172142553199810126172180490708929",
-            "76631143543919820921892254735365792596",
-            "97582911312902206555664841122180441248"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "7093132471014474767844887751733331003",
-            "-108686417660834376788570147811161987220",
-            "-163594850104237544086018972477724405791",
-            "-2302501739484662175406128065151266870",
-            "-97343550981288966396082969127785946405",
-            "-96030927988302472038807926974869041673",
-            "-154167090334610438942150064192357641402",
-            "-18793807036998611053269951477295987184",
-            "-70904740499999719165305256191226042599",
-            "70653097581681099304462157018443053691"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "26050",
-            "10037",
-            "-10374",
-            "-29490",
-            "14331",
-            "-16851",
-            "-12187"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "13120",
-            "30961",
-            "18595",
-            "11399",
-            "9159",
-            "-1887",
-            "-30813"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1464633",
-            "220199",
-            "2712771",
-            "-7495838",
-            "-7981890",
-            "-4964125",
-            "1595391"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-5853521",
-            "4344274",
-            "-7018099",
-            "2293236",
-            "-7612443",
-            "-2167093",
-            "-2845086"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "95875595",
-            "-609963850",
-            "896088118",
-            "-1715535486",
-            "-102098264",
-            "1291776262",
-            "-576308153"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1236728557",
-            "-1637854635",
-            "-984551882",
-            "795795740",
-            "8028990",
-            "901192316",
-            "-1111344946"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "378575634",
-            "-419525563",
-            "1883074043",
-            "-1173948468",
-            "-1824740989",
-            "-522033444",
-            "-144793007"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "370947827710",
-            "-353447519869",
-            "284585997441",
-            "274833182439",
-            "46832561565",
-            "371244974672",
-            "202518766395"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "218531362099",
-            "125513046194",
-            "203189347634",
-            "-304680830682",
-            "-463095454301",
-            "-6527992404",
-            "-65734664745"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "124491338796971",
-            "-71234357373577",
-            "-70640224281818",
-            "-115120848140363",
-            "46780581253253",
-            "-5239172476241",
-            "-84243714348014"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-43659843831402",
-            "97675487713738",
-            "-120205430205763",
-            "55637124317579",
-            "-2982496726764",
-            "-52205341209619",
-            "61907219984235"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "40565389677572",
-            "-115932875026862",
-            "-59257993113702",
-            "45346953112251",
-            "48999715544038",
-            "-93859032164586",
-            "-82647138297887"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-31698638660098966",
-            "-5631854766304352",
-            "17449252429242489",
-            "28180900120216510",
-            "5008123877732808",
-            "-34000957537070508",
-            "-9375521335589905"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "9961273701300998",
-            "-2079937397053597",
-            "26948861976924314",
-            "-33274483408865913",
-            "30025685782393962",
-            "23738162907963992",
-            "493130406875726"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1979493224765362120",
-            "2703732660426547803",
-            "-1393112844070577191",
-            "-4589313647595954574",
-            "-6650779199917767681",
-            "4898222384404144581",
-            "136147557489562317"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-3646410955003742974",
-            "8191219785186527321",
-            "1272327194703892541",
-            "7200053761957267992",
-            "-4756848297671371938",
-            "465404651157646586",
-            "5030791210523335471"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "471782014697430155157",
-            "-737522866566807476021",
-            "-1150886932732683487297",
-            "2216993989609573889751",
-            "1791930017506828908157",
-            "-844823775260624667509",
-            "544085813983975919632"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1674397379408819628225",
-            "-916247777654751098512",
-            "770173233696709315682",
-            "740475606804091311338",
-            "1832098966387094053802",
-            "-846509827577616730614",
-            "1310459528272118181618"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "74011478604212791529",
-            "-331788012397048455114",
-            "-1505535048061915354043",
-            "2196671714385448598750",
-            "-350496961296855157879",
-            "-1047520580803370592747",
-            "1407733904504194944452"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "334057475536999391388584",
-            "167091731454929333593163",
-            "44371453303518972747966",
-            "569151268328963633065480",
-            "502857981392722544973772",
-            "-295294362379075981585508",
-            "231490385988114470344787"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "67874870060011234362111",
-            "-134871563655837319141577",
-            "-165820628960372861946363",
-            "-391238480407275084709510",
-            "-514577690826104710765865",
-            "-67979890712897414695858",
-            "-408586208764886574226242"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-92558993866389986507056248",
-            "141516883852752944766615012",
-            "-91570642406924423409457354",
-            "142445780080422570580978556",
-            "6629554290181300402543099",
-            "-13376427830750013064535819",
-            "-128889999820989497872482505"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "109570534710933797396607895",
-            "44325882156245683484525132",
-            "-78370164483658463265616463",
-            "21269267048775656453724437",
-            "-30434466531056204756754318",
-            "-146721097875248361900368890",
-            "16341220289441428332578520"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "149460511934390160021660960",
-            "85813150145346742579054179",
-            "10395595941021601123326187",
-            "60742333060570890451324525",
-            "-69744724753060176636143795",
-            "85805585820369366977540699",
-            "-118751782594197400635380486"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "25165154960101426243162674534",
-            "-10828793959658115401846998769",
-            "-15232188130968548112534724088",
-            "37859448133639721078872362278",
-            "-7447685266469730873213326336",
-            "-6630414361379515759165805767",
-            "-7233008330319849805678054088"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "31352291163482491119505968125",
-            "30926463871793539317337614369",
-            "-26565368808580343750512847154",
-            "-24547829992985946652408320126",
-            "-18355556958734667364187798032",
-            "1438511591107866365310462118",
-            "-28634765763897394391222662353"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "5950176580747626568664247515800",
-            "-8881211795988992975636965132300",
-            "-2313319268134714731343698733583",
-            "-9280914263091091040890831012745",
-            "4639580868256294580236676918210",
-            "-9335839789223791032443503646374",
-            "-972698824035541842758234702650"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-9116871202867186426233180444277",
-            "1252769228624504890201406664824",
-            "-4441678277221598037171990272524",
-            "-3497493513724645633286134222906",
-            "1362086037022057987770970014654",
-            "2526310726561592465837221454378",
-            "197133844356911321653053339758"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-6708417134328302521535165500528",
-            "1259667415597434897205018980503",
-            "-8667405068669984535223184571634",
-            "-5739153439279994263124834718486",
-            "-4659094842072120505966726511778",
-            "8300992321238715729975176338668",
-            "8305762879837071470447907044080"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1855360572508690069751614139995240",
-            "913127495556918482781605103352223",
-            "-1634237774328458406341648362825579",
-            "2012213887653411326935188001113650",
-            "1854844808900330191204660335054080",
-            "1943836864945319401575398852606071",
-            "-2512140816283887752192691293590826"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2347346757752941921138702653567730",
-            "2471720490360303419055064438101411",
-            "-637525221921571876383204743520988",
-            "-313171852811679112466522221783714",
-            "1342661303952287975125536927727615",
-            "2299702375882500241106744128006573",
-            "-1943268622964000029081987879045476"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "654404760071118946096668775855737838",
-            "-134614183491363562333301742647543553",
-            "193373068724594777442105443158226074",
-            "82128803304304898958437601302688987",
-            "231616933503852269212186042174117433",
-            "314512202435083245896423396120681411",
-            "-560893487306878937612307892677922361"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "61682174231144284695206586082327571",
-            "-129722213375102804822534176471924759",
-            "-470843635185932669298551792606832749",
-            "217981712620797098953060036718615794",
-            "524439585175580833405205537825140874",
-            "-195520289865208736968677273971035370",
-            "74511399356182107059807662782310402"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "26120113210988095907759127757085647952",
-            "-62165437783621924594919739022258953866",
-            "104747421037847971642972590567045904195",
-            "53605601765747459417883834171905176717",
-            "-16460101511938648810934533084724073149",
-            "87326150749852540273294368718992775275",
-            "16683834934928424633510098174197548524"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "26497149875196872156784837245492823091",
-            "92947688966177192205895235501995800904",
-            "-128897447396708280338335738279922653247",
-            "94341806002152925510991334018527791058",
-            "-112437238136605911451884994064234664417",
-            "-149010327216271969260130899539508200431",
-            "-32345160422388704273102616927971726501"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-166189853516680988544038633926086071136",
-            "-51412708930825095905795826687352289630",
-            "-8345130886957441238365575658116421520",
-            "1835330936447412638754115271624712637",
-            "149041866461530306889089342295575456556",
-            "16212245285186773325597991037224844276",
-            "-44514833992738879886424708523206514266"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "19322",
-            "19888",
-            "-20267",
-            "-32519",
-            "-22546",
-            "19491",
-            "-12006",
-            "24475",
-            "7982",
-            "-4810"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-32156",
-            "-17491",
-            "30836",
-            "18967",
-            "26344",
-            "4302",
-            "21070",
-            "-3741",
-            "21984",
-            "20912"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7093261",
-            "-5853548",
-            "7803379",
-            "-2652515",
-            "4959963",
-            "8087528",
-            "1598575",
-            "7487372",
-            "-3584523",
-            "476277"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "5614990",
-            "1605944",
-            "2158854",
-            "-5461816",
-            "1168967",
-            "61828",
-            "5746557",
-            "1413562",
-            "-7871958",
-            "6056696"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "1038435346",
-            "-2012132702",
-            "-903699578",
-            "-1322624637",
-            "-895719624",
-            "1176645993",
-            "-1538792708",
-            "-499541589",
-            "-1303395798",
-            "1511778212"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "592833317",
-            "-1551950984",
-            "1787888535",
-            "-810984372",
-            "-1974703475",
-            "493667730",
-            "-1121250454",
-            "376054319",
-            "567834251",
-            "1569097131"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-57685736",
-            "123800228",
-            "519450088",
-            "1079630019",
-            "-1254308991",
-            "590805934",
-            "1765339826",
-            "-1234550696",
-            "-824160185",
-            "-2094981215"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "426101820801",
-            "16436911678",
-            "-359476250071",
-            "-443809896688",
-            "320952321382",
-            "23645867134",
-            "341575522947",
-            "-454866134852",
-            "140063572947",
-            "-548803465692"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-206275629357",
-            "-54167785313",
-            "468398637611",
-            "-162195244968",
-            "238463244086",
-            "-168579433699",
-            "32497103886",
-            "379346160025",
-            "541309413663",
-            "187332535600"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "49075412231132",
-            "27312750405736",
-            "-22512416476092",
-            "112383900203683",
-            "-102429519587353",
-            "49012285726128",
-            "49380517981528",
-            "100096915120043",
-            "-135774832908052",
-            "-26743412282490"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "92838931686727",
-            "1117744174578",
-            "95749441954752",
-            "83774056709063",
-            "-80485560556004",
-            "31410756920117",
-            "-36487657625110",
-            "-17337070785087",
-            "-79624495118450",
-            "125937356449490"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-110960987245002",
-            "-130196863138687",
-            "112521051717937",
-            "22370815190676",
-            "31270809959205",
-            "121855313393173",
-            "8699496453047",
-            "-91463041032135",
-            "120519868366012",
-            "-133257403196016"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-32069587070878257",
-            "-17919111411953962",
-            "-18001660931442915",
-            "-1767754592277008",
-            "20250526488187012",
-            "-15695508630258145",
-            "-29837740769794226",
-            "-4501074155399095",
-            "12225232288612758",
-            "22313124950526297"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-34480102097926967",
-            "6344112291297418",
-            "29002029974785001",
-            "-31888655934628218",
-            "9139086331212235",
-            "2897750950926006",
-            "-27160809101795530",
-            "21028873622945161",
-            "15244977183310528",
-            "-24528972829842178"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-4068321997152171044",
-            "-4123931468795332282",
-            "-1917336520397580474",
-            "7863490469535036896",
-            "-6249110314124783127",
-            "-8225844925803348664",
-            "915179017540453539",
-            "3123520133722242387",
-            "7605858146072323334",
-            "3943872340866871094"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "8702547793259894978",
-            "6483962839585495096",
-            "-6872654786944293818",
-            "6033338727343656838",
-            "2377337619842982990",
-            "-6489810207155348116",
-            "1074629160217093102",
-            "4824865193186455416",
-            "-8000377732360383694",
-            "-7092995275501204023"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "392214659868220760435",
-            "2001707758785583846477",
-            "1973056242078770230918",
-            "-1958109206556224024652",
-            "1085003398984190910582",
-            "122474924730748113507",
-            "851293406060406798668",
-            "1832853642649160529635",
-            "-2111330458370422801057",
-            "-2122277960278850970588"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2252221810790127710310",
-            "1477205316920429874421",
-            "-961506947433404737273",
-            "-245308458478085909173",
-            "357740715501747274650",
-            "-319267889025708102500",
-            "1094364280480774943760",
-            "-127746993279336115173",
-            "1782157345845552907164",
-            "238471321966246221649"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1691113452288155441823",
-            "-837928306525549514253",
-            "-1479432108576007046222",
-            "1105760639244233719583",
-            "-1237878533885748567381",
-            "-2185454825581323446807",
-            "163923040453210887447",
-            "-1194656668349891851539",
-            "-1697451474233505816259",
-            "-1346443165535100297337"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "234606311866196287199252",
-            "-280339717607805536038094",
-            "174162930698908947490765",
-            "161585530398926918641746",
-            "149110074266065657434558",
-            "39179047469267699561279",
-            "-562131507501967025468563",
-            "353803686657854340422174",
-            "491584079078747706104003",
-            "-361063318154572608483058"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "271411052426415377865185",
-            "-444592158660720424250257",
-            "-255709913155980939726276",
-            "365550349570545751906209",
-            "-391044572823762759576713",
-            "183367216650532855576691",
-            "-25390552937951110044900",
-            "184949987773880185014120",
-            "-267534620027159821434853",
-            "132847257761444427988262"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-50975717540435075836318695",
-            "1378903033683610665195435",
-            "-140258399598530936546358654",
-            "-87594983716718223901386738",
-            "-62237980291352487006786500",
-            "-91499845570297449212552189",
-            "-66208718275179977437401191",
-            "71189572681527467501510610",
-            "-1306164209002345386773606",
-            "-49463313801741626591705131"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-128773881103768533353175446",
-            "-92989705198857589828906933",
-            "135169579794423165966163763",
-            "-74770130369838071149350912",
-            "66417301185305992075241814",
-            "-141076205408915017047534288",
-            "139087458245468156248483059",
-            "-113662293865384133240833450",
-            "-33825577590872840313241969",
-            "-14077765969840480002036401"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "83003901123187485851103193",
-            "-2681382205142334385409300",
-            "-63331882652492224187298286",
-            "-110680165287453809004856775",
-            "147522995254483971982329487",
-            "75382769928196858065260409",
-            "68276261988199153282208869",
-            "-87269314773681476775194807",
-            "51406486149759545599895079",
-            "40564670281024197061922198"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-26644049411043351785728824141",
-            "-24105812251123083991288681115",
-            "-13313117369621013301443559549",
-            "-15343445014815373573159127244",
-            "5755441206841059236617659163",
-            "-19137609460361732913808417597",
-            "9820328360260799657364770926",
-            "33319966440642342193193092160",
-            "-2450510718121406857997296905",
-            "19633470714253525250579882639"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-36841392181436281670139286742",
-            "35355431815928332051589081557",
-            "12542032737254605451781545802",
-            "-10487948400679804251659176662",
-            "33809232792580693385020804592",
-            "-1286410851551344895362223329",
-            "7299687240575999746351638266",
-            "-17358024343798554471827987834",
-            "-29156466412538498088209136035",
-            "-17589710144892474177196649606"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1569098507666310750400243811856",
-            "-758234951593444817309034952464",
-            "-9334359694680896788581614109081",
-            "1374116640047423155668561508442",
-            "-173162738574107411965825187244",
-            "-7788646219993207807828069988222",
-            "4582300712366442004380627595004",
-            "4100619504434533691239280199560",
-            "-468263237010220777440412988226",
-            "-6978567372677615209814697240488"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2976231597733439456905633512789",
-            "5127694050127805803249796769468",
-            "2812957412066585231215442690760",
-            "-8402845131237017711805113621227",
-            "-3787750299715284207846037832827",
-            "-2942880408698349918786267176602",
-            "-3869882757561265792893437687111",
-            "-5705588172653590518606599812141",
-            "-7302962533971552771835642777347",
-            "-3268746639752527561077535734497"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "249971857312161074689173876267",
-            "-242404619148151547781226427874",
-            "9581515616266968745257306192718",
-            "-9310338506009408582538577250155",
-            "-6804608278893940697882201407664",
-            "3099137104427329585255879001438",
-            "-7567579129514718223375916274942",
-            "-1792499874699902261296010365098",
-            "1639591688226140840628852768785",
-            "-7608440910939533514456193631459"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1478066879273161886647445158949772",
-            "1837220622062178767494109366244231",
-            "-92877272254401719687763113724897",
-            "-294736309677963931197700276380980",
-            "-1131638498094855104492084200292876",
-            "-1707583373250833555270111202726089",
-            "2530465654746538337722203391829038",
-            "-2249523431616310451983315854427522",
-            "626377764251003872328656072958391",
-            "-2410247195955462616836551577048770"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-146608320296582083230297319921561",
-            "-2472542853509176412554981102318147",
-            "-771312358883127333171922117508275",
-            "-1484063485715773612247024703348500",
-            "679091726809387681196416537626957",
-            "-2001457836812405622324166631537924",
-            "-631900342171956815934243043067448",
-            "711088708081508591363639203425914",
-            "1216331827955829693179876936054302",
-            "-1299482886169500029305135186407016"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "200012218527021640529683894748995748",
-            "66764908937162351505130243349347892",
-            "524610465017564034853035195648393051",
-            "-558690033622104772858687622389660622",
-            "-544523595431390359103420871965400054",
-            "245517776515380942196684249862925365",
-            "212945120221746468714378114960847869",
-            "-170782019116161816032185050362150848",
-            "-496641648487716226900749343652261406",
-            "648453852192358064522416946780906606"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "255949560736548808004852239641213264",
-            "-324087200268712128351855136105640947",
-            "-6820351909324143280484118195131375",
-            "-319504958870141568923172587852075104",
-            "523488920375771830477498953239602567",
-            "194332300193562216166276513041179721",
-            "-544008549012482630748073246202260640",
-            "159071387785195543622408425447358845",
-            "76192843992111999275453592662491096",
-            "-473054289942710741781585231767065104"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-139359679896732931766919659337245494846",
-            "-35545345721518693494350745566292372621",
-            "-39327020288096966885458128121852385736",
-            "7493284389294749331633573014767224917",
-            "77381066407576226608915901862097770212",
-            "157711333385356156585898944278021995524",
-            "49883214513209304705821748055646582719",
-            "146274344215989941722162867924721361448",
-            "29434461275514518797058993245422008579",
-            "129948671740191770106010881205508710601"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "78106395943978345433881498304008994451",
-            "-160930953760985927349252065503891837878",
-            "-44960294156570777230598296792605054671",
-            "140984650860694548582383830944572104234",
-            "-139997530771990989911328151859950982105",
-            "-56309689550359535719606358796078640634",
-            "56779686305520783893926725471749235781",
-            "64518970089533247978457584756917625030",
-            "-119002062601850172159773604273618695770",
-            "99267635189640639519242595654851971448"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-72992812885182321071012171435152271739",
-            "-55130623505249212822546937141683067554",
-            "-72150173497072821802434510525219140741",
-            "-135826146169714584749451385037745056378",
-            "130698346424652975123966744269457918140",
-            "-9260092987630855868815559991510953109",
-            "687286835945665138009166453051890054",
-            "-152468467896817629814259003076281203489",
-            "-162737426598589027675694265384434548482",
-            "130527505687529038013531520307450723070"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-20673",
-            "4891",
-            "21555",
-            "-23205",
-            "24226",
-            "-28935",
-            "-9747"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7505",
-            "4860",
-            "-25545",
-            "20070",
-            "25803",
-            "-29488",
-            "25570"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "1487976",
-            "1762770",
-            "-4729573",
-            "1860064",
-            "4929956",
-            "5522284",
-            "6549685"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "4049960",
-            "-970587",
-            "-1321157",
-            "-3312445",
-            "2703511",
-            "6707801",
-            "-5572805"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1030375303",
-            "850853352",
-            "1617347935",
-            "-420547740",
-            "653990365",
-            "353737175",
-            "887141994"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "974530540",
-            "1286390864",
-            "-1834371078",
-            "-873048386",
-            "-1662709861",
-            "-1479216424",
-            "841702675"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "2111707600",
-            "-254659598",
-            "486623667",
-            "714212951",
-            "1069946182",
-            "1654147123",
-            "818253616"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "158613753089",
-            "458774753508",
-            "183875050170",
-            "-405459377062",
-            "-76041901937",
-            "422167883413",
-            "-534535030458"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-189858741056",
-            "-350281980076",
-            "75626581117",
-            "-124609040589",
-            "16597068948",
-            "210894043846",
-            "147277886747"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-138751689194121",
-            "-103042931779161",
-            "-112178692829012",
-            "29511789263726",
-            "46232439685971",
-            "48353150098534",
-            "117568446080604"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-61910798890980",
-            "-140506887267184",
-            "112641714944989",
-            "3355252674878",
-            "-15180008486174",
-            "-77620968921810",
-            "88635255157246"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "54206304886847",
-            "-101630474357009",
-            "96590747853874",
-            "-118603139384744",
-            "5675249069187",
-            "-45370506866973",
-            "-36853313570962"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "12547998279054852",
-            "32079636436024400",
-            "-8837895237364730",
-            "-35089444786916540",
-            "11941345258052284",
-            "11998082458470934",
-            "9244690049555110"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "10936921703728198",
-            "-21359025539153981",
-            "-17919755145627767",
-            "21949453057332109",
-            "31577422472892467",
-            "-2175882775298387",
-            "22366796586949547"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1991785497370767870",
-            "6209395018704963569",
-            "5802436034677451710",
-            "-7064032955625756220",
-            "-425594384187662050",
-            "-5892871677969375177",
-            "6618055914134267928"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-9127990150600728413",
-            "-5735750909960740797",
-            "3801973574837623883",
-            "-5415111795522083403",
-            "1905105625346053106",
-            "6231685532968733711",
-            "-467857863906217121"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "85863289349977744466",
-            "1143903301173917583596",
-            "343013108718986345006",
-            "143977393722524587619",
-            "-331683688552855746072",
-            "-1255008151495427109419",
-            "-367830894824428134772"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1380262755120611917815",
-            "-2015184270487688482207",
-            "421650876988531672681",
-            "1400851929839245970743",
-            "-247535080568189823163",
-            "-2113957207159701869965",
-            "661753800403331824022"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1409117742382861999337",
-            "1964560064468429764667",
-            "1142331396214943706208",
-            "2120139614999229044568",
-            "1947051906742118331879",
-            "-2255925732391731193539",
-            "-706486902189772690761"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "476431701466362805331100",
-            "-102676717243207894859018",
-            "594838701556832564313786",
-            "-362093575874816415536617",
-            "-298506140329613600409281",
-            "113749430332489269875681",
-            "197169454728417077892949"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-427853124038909455080219",
-            "66701743587659683001174",
-            "-2597511976969857899394",
-            "60778757968804042956061",
-            "-544547149575175129004139",
-            "-301565858845410225401166",
-            "-265399533535019605844097"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-68618783730059765480823635",
-            "-148575561591978834067415296",
-            "34414152208973548229001993",
-            "-13643309285265500492215602",
-            "102647265825215089997130781",
-            "137227738860777958998527556",
-            "89495140415736266671994902"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-136993255643844109804321368",
-            "95521822621879235917169875",
-            "15444326698047673705527386",
-            "66587355931325005334848104",
-            "-145548966688252050709592565",
-            "-114049305396707161765587204",
-            "-108330685803294296438944164"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-35055644549667511602728701",
-            "-151408885763406254266448065",
-            "148986972316531200205118208",
-            "-41264915535541021357739976",
-            "136259859352059633203136439",
-            "50887898641106552333186126",
-            "-125285378380785532529599731"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "12941490015157247768713837736",
-            "6835075928133812117006091940",
-            "-22465188887333363863609842193",
-            "-7126648403394390900967730280",
-            "-28393957274203526260439553432",
-            "-38741812277298816415321041919",
-            "13338414913605328772627511898"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-20110672505237420917225518191",
-            "-27596411499885490649297106626",
-            "-12603225725813579881802031040",
-            "7543351889165927098806258732",
-            "-36704747017636431900889798792",
-            "21396851540234206754769905295",
-            "-26912455145404876756203862275"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-3387707576912848734654159629359",
-            "7428755755160883095771560631147",
-            "4569162969402491573365786468348",
-            "-2490525292701388792253454545621",
-            "2994837362157224884748366006872",
-            "8916264544517216999577433705932",
-            "5151024374664908204375853841885"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5663811480390229830172653604467",
-            "7710539150230289621751006180128",
-            "7797728575196483778606701813486",
-            "9630462872777850496307059381475",
-            "-7728740627143181530379709906473",
-            "-7781087371673710496980289208707",
-            "-343446002946672747378655962906"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-7557416815553078625043545761338",
-            "-2302505358387623502188356176192",
-            "8409779146217467126417839702826",
-            "-9562089631495606093360342875300",
-            "-8213115909769479205332628941563",
-            "-3559170898222778482528552837035",
-            "515283880696723945344198400802"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1367641768492784058807182267663971",
-            "465298046667559350852539820375203",
-            "-574478792401028873492458572224839",
-            "671454055256727078424602503807202",
-            "-1606532935067250255205206946799560",
-            "2502175580278378863196680582577687",
-            "-158821802300435835463112943740860"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "215412964590856924411049997929445",
-            "2425019052313712110758162804934291",
-            "-2146281446953297190248965140031957",
-            "2313116073547801117262414478722805",
-            "2445004820402073310655244369464935",
-            "2131568767414300517904191007403641",
-            "-1647531519212921581334819756802357"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "85439167121228840311602468684207718",
-            "81462378211070190176464268885238633",
-            "-520261127199435865904944398789158800",
-            "-373378915703658263067219343884833015",
-            "303273353020035808553785984579294122",
-            "-14150871600103744151748032687048184",
-            "187409089415128244172342086722110778"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "426903599253969182311652501209225081",
-            "386418676761755887855863585696427033",
-            "-12458025011532389171806041982715946",
-            "209536513458228602712253512458307460",
-            "-606973411546439030075456065531198766",
-            "292324957531014750417545379298738712",
-            "-283787856374051062869985486340352964"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "63865640843944075030209963280445799369",
-            "-18593804610606078796694478405978654849",
-            "-714714379007990044568901737313354522",
-            "-143842961516453470477418544067319181336",
-            "153172084381164114541423265053189318206",
-            "12685456738195001579207153151789306138",
-            "-29575308771159264213086650783552893870"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "46883541681382683193881459486746081613",
-            "-125705053509498712301219791891009785852",
-            "62669131077706452018756304286321569553",
-            "22514282939897237627731060578196173718",
-            "-75575161713087697602988263826550011240",
-            "46505563659899129005157792634893169283",
-            "-119258175090032575441578768164878731653"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-55040330949772143040530849272221593209",
-            "135813211061156674505901218739644432898",
-            "169896929526665904477525636205199802874",
-            "-144923747172463589788289511293391386010",
-            "52887701532943518748533315738175210189",
-            "129347148437659340779376391685263512814",
-            "-119470842876568878095060418047486776106"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "20439",
-            "22663",
-            "-27261",
-            "23271",
-            "-18990",
-            "15944",
-            "-28565",
-            "24963",
-            "30418",
-            "-30608"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-22057",
-            "3217",
-            "10476",
-            "15694",
-            "-6027",
-            "-15715",
-            "-23007",
-            "-31432",
-            "-4516",
-            "3674"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7442230",
-            "2338346",
-            "-2738445",
-            "-5985510",
-            "2142214",
-            "52299",
-            "-8166525",
-            "4690970",
-            "-5712690",
-            "-5048341"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "4260441",
-            "4125202",
-            "2115968",
-            "-5649222",
-            "-3760260",
-            "-4042562",
-            "-2350779",
-            "96900",
-            "346378",
-            "4216085"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1097374735",
-            "-1284838828",
-            "1061029847",
-            "1269187264",
-            "2093057513",
-            "-552929762",
-            "-1669807006",
-            "48971987",
-            "-806857042",
-            "-1203491271"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "486603994",
-            "-1677973283",
-            "-925436252",
-            "1756729478",
-            "2007578960",
-            "841852782",
-            "291979431",
-            "1252234044",
-            "-1077400305",
-            "-2004190290"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2012058775",
-            "567356812",
-            "1905525934",
-            "-1504705027",
-            "-66129469",
-            "-562262896",
-            "732024217",
-            "-1858174448",
-            "-1128956516",
-            "1788342603"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "435657141702",
-            "-478490014750",
-            "360566647940",
-            "-451660074249",
-            "-473020751145",
-            "392377661939",
-            "-482632860063",
-            "-338086490878",
-            "309007405872",
-            "-353813708003"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-459773526894",
-            "-430668239377",
-            "98090610437",
-            "75247578430",
-            "-324388649864",
-            "416582345348",
-            "-62640371660",
-            "-284829666000",
-            "381139880955",
-            "-4984998478"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-20005911336447",
-            "72447015480327",
-            "45875595264956",
-            "-76521915606081",
-            "-34727867953542",
-            "-137384660844194",
-            "52697015634263",
-            "103452307321328",
-            "-122001791486213",
-            "-41151199613229"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "70939096990350",
-            "-88819773553707",
-            "-56139660451437",
-            "65674495025011",
-            "26628603487458",
-            "-135902172047580",
-            "-103682776666204",
-            "132777414234749",
-            "-95404715253975",
-            "132858731621408"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-132374262406977",
-            "-23628151618575",
-            "-119413346104562",
-            "-55036741341427",
-            "-35811108191614",
-            "-1926885375842",
-            "-45365158169918",
-            "-114661135140377",
-            "10473703483140",
-            "-74303850742113"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "25306738711824109",
-            "32509922510474623",
-            "707085602821514",
-            "9763707224974397",
-            "-11143100390263700",
-            "11596259349396834",
-            "24075139416501450",
-            "8655375690994432",
-            "-18063068128417348",
-            "-19863328717071201"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "5637539114033423",
-            "-5001319200678838",
-            "14212933040227288",
-            "-33982239913110551",
-            "9485454238704206",
-            "22215509542635843",
-            "-32953189204876032",
-            "-24998747694223021",
-            "-2633537128076828",
-            "20245361874996758"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "4985469615170125407",
-            "3351154357521105423",
-            "-1334855791139741442",
-            "-8797809572977779612",
-            "-8598556274215160807",
-            "-3639608199332585325",
-            "4875792833346596793",
-            "-180163167139705625",
-            "476427630399101153",
-            "-2608044133530342885"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-5157228090470659511",
-            "7212202656918885732",
-            "1392041261546235241",
-            "6666890125347683",
-            "-3802346357954570034",
-            "7105488401526240167",
-            "-4672914031095531393",
-            "-6827233405808698926",
-            "3167057671289501060",
-            "-3717235008913756239"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1189803804746023930692",
-            "-625825002864892544122",
-            "-1629596920467579686358",
-            "1736386230972209967360",
-            "700381856353328623786",
-            "-654232777049969789030",
-            "-74724090947393824084",
-            "1167695718621359342916",
-            "982240876673049294819",
-            "-2253964136358443531770"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "1734021379805203643295",
-            "2025823067259793494492",
-            "-1597926848173583043168",
-            "2016223048238280625792",
-            "542138962133905683759",
-            "879305494437540350029",
-            "24106321453602867849",
-            "-23115421710948790743",
-            "-1394212641438626790639",
-            "900304908524327153009"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-815922170546921752952",
-            "2345528514985286552061",
-            "-730780927736831533616",
-            "1069468118213157740893",
-            "-1997524152172607320568",
-            "-1013146875657159489822",
-            "-1973113169762410936751",
-            "1200927779840472350073",
-            "-1766824844262595417616",
-            "525685124341004293754"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-170913940873623401775282",
-            "179981267419149838084057",
-            "-370082002746130953305180",
-            "-131843472762558045740043",
-            "-552464426412919975259597",
-            "24312389763321025014440",
-            "-117006219956015698142037",
-            "-294656127901854426623108",
-            "211409385267588640410423",
-            "-401701449753764845530816"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "261336340980586457175758",
-            "-200294377526284545507585",
-            "-545096901807334905127689",
-            "374297611040715654546064",
-            "242023592078112962668392",
-            "519439377841947434686615",
-            "-474543347988347187804194",
-            "-394392300302764104998174",
-            "-373120785523247440518771",
-            "588720790387528574187381"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-139459348306311875888174515",
-            "31473852940256986171518891",
-            "-9887972468444270565467209",
-            "93418597022785737089002364",
-            "65646938038849350878907951",
-            "-13454108861792806928065988",
-            "-49131526937539933217982757",
-            "133308858070906575237327213",
-            "152947960978969273942320012",
-            "-99442640752857756581864595"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "2115383285040758640199104",
-            "73985143764269122713862311",
-            "61649530092631838157886499",
-            "8213049092689795695398840",
-            "-80077933562147893493089163",
-            "78551679595459404249914332",
-            "19850268736295064479696418",
-            "124684888502488128271726633",
-            "37465268414151592422174391",
-            "-81920045880589413421302411"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "146919906028535181219026866",
-            "-89543083067520077646503602",
-            "-57021118916205567449809506",
-            "123915826284653894642187831",
-            "45309385836027080396265975",
-            "108158825422372930192837799",
-            "66329707408865417911755413",
-            "-118958587438073608674047710",
-            "-91357950068726260281104280",
-            "-29334802080406579764325519"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "29971765432798246511193470890",
-            "-14358861096333026316517453356",
-            "-20738805649133754102834682386",
-            "7189350037292179268626580107",
-            "28348942101195751039833924545",
-            "23861168485253092769676627300",
-            "16588967227968379293949586116",
-            "-6873327380426872277945057200",
-            "10424009656429165482189206264",
-            "-25621000662753343435110968263"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-39356814765782174445810187495",
-            "-5109629353343354164045003706",
-            "-16869835388192806041216992477",
-            "-37493550780440739680416813425",
-            "14541598222000814429300992064",
-            "-38988737188675992487467355111",
-            "-5094561545550859820454915644",
-            "-12905499536852970749799435474",
-            "-21653278306908362352193117144",
-            "-993708667489234042402387802"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "92415685774358925610111866673",
-            "9229208403038084890901114521746",
-            "-1766812394389966971613945075397",
-            "-414903185248431735357057732437",
-            "128208901508290284695665875545",
-            "-2137916455945877871317699306510",
-            "533853066501738976626621316273",
-            "-8107875934613418676045246063445",
-            "-2240122730023917069540851608907",
-            "-581801766541597034700720337725"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1815876156537294905389859319649",
-            "-4726996253616925415079686314941",
-            "568839304816351244324261819932",
-            "-5163478890877212498625611240707",
-            "-662774202918173654109667847074",
-            "-475889796722743921788914957564",
-            "-2257429926736080379736282434990",
-            "1726653147329710337174488734580",
-            "-9363121838594629328777547224810",
-            "-7533717992682225954740846518262"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-943679878919633167252094145878",
-            "8714088656079526494903956041252",
-            "8411215846063249276308781788948",
-            "3664164290851654853119485847374",
-            "-6596298511313995187171485387486",
-            "-1888023965534996939643588527874",
-            "9495642065507897069829420814146",
-            "-944088385505063048706519524817",
-            "-1682255994436138829648213443423",
-            "-10107759010048745798990652968169"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1264118898522834382835880961293103",
-            "175335396147539366747199378984306",
-            "-1480903532901286343978092781681499",
-            "-1192391017717251896100729091650720",
-            "1838460835508247778407301651152350",
-            "-218273162958334959288494722385785",
-            "-266094035120591056222534225926678",
-            "2529452524986175024854639128506489",
-            "809296180497156248692989775063626",
-            "-2062841016560545591440823200686963"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "2170563804277303232741531700370893",
-            "-748753118748469760570998958561667",
-            "916018945705575050717700426827152",
-            "-2184472322228724823602690942023783",
-            "931638193487785096171421593175885",
-            "2048640881231787711057765873886397",
-            "-1717558044075129776250633892902155",
-            "-2313071463687411409263290533428648",
-            "-2151217590832164263816790880109487",
-            "233680104831469375662508975501380"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "386287962215958396998754574574732663",
-            "-631240026268303131318958821819142960",
-            "-525325746870165944407752164089651120",
-            "226083291950635135851013581626817238",
-            "-248862800389803494487190616128802768",
-            "-504010349662551275225205203827997278",
-            "105517119082759430552188298694313003",
-            "485997620144390375276743453768158813",
-            "-31031956533367407083197254732570524",
-            "105470167017873351672604929878914316"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-483310365266775246988333151327302729",
-            "632542156756981952900968647179691109",
-            "-199686287544647062245243545386295768",
-            "-346768888815915145525346260667844925",
-            "-208917751619615348174629828212087836",
-            "301058117385654246394042436715253681",
-            "72505593750960021178904279470923063",
-            "-533222490246855780568633480920745903",
-            "218758514092273334444751656476699625",
-            "508751967807589006206145598647069503"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-42741017306389443150668859837924739566",
-            "5211098457938490686418682329098486838",
-            "-129969844595428022866869746117998789324",
-            "-94012368654033828127179346577805729097",
-            "35086650888287131920843468969962483767",
-            "-64547523416114956219242396283441262524",
-            "-78626332557361945510915241951325611430",
-            "130701192029686880255650902394824091256",
-            "12989363125669154968811991286890110074",
-            "-19085080263288132794957946754147030146"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "126277014750196607230171475233679635500",
-            "-134087443068240928447419624897745395408",
-            "85434520441165433374732053355016779518",
-            "61561576435107610545214363658645070358",
-            "-35737267355118855527515802602250082633",
-            "11868126818381274069679858879103809834",
-            "87005374759848073229912677602906854442",
-            "90719075388093079581459445478934240458",
-            "-21323038801308634493038758759215276208",
-            "150665237002876200779610299709080110866"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-100088170739481113599978032714704061913",
-            "87230434305877189656761352602340853350",
-            "150644562584291617352733319990979317142",
-            "2355696344715547537955189102551329553",
-            "158450070722937152732551704806734037987",
-            "148116003453147564228147700395660475174",
-            "-115716266063960239779150802300625543144",
-            "-158188859732442401491344398356371993578",
-            "-99767424729140507618824095329194502037",
-            "62003921486566133988081889333737019283"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-535",
-            "-25514",
-            "12848",
-            "27508",
-            "-25029",
-            "-8130",
-            "-25697"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "21948",
-            "-6803",
-            "12985",
-            "-11290",
-            "21862",
-            "-7890",
-            "7067"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-7148303",
-            "-4971329",
-            "-7052595",
-            "4735130",
-            "5847325",
-            "-617961",
-            "4747637"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-5671537",
-            "4122273",
-            "5239819",
-            "5517428",
-            "7254910",
-            "75359",
-            "2582957"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "1425327362",
-            "-959771469",
-            "934816401",
-            "1185248203",
-            "-959453286",
-            "392425494",
-            "16338144"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1025370776",
-            "-572097770",
-            "1425619841",
-            "-380090147",
-            "-1914141867",
-            "-910187147",
-            "-1412977686"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-434340667",
-            "-1848805050",
-            "743213334",
-            "-324842742",
-            "292670937",
-            "-1900640639",
-            "-933474826"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "239743079568",
-            "-159475972033",
-            "-482663945868",
-            "482237623461",
-            "-423374537953",
-            "-467862671850",
-            "-529681543215"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-9094038950",
-            "163457626005",
-            "-104843767567",
-            "-374539130257",
-            "-470191859293",
-            "80376556424",
-            "384398483083"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1769074858487",
-            "83312732731055",
-            "-41445089577043",
-            "-93201479369899",
-            "-119343260700090",
-            "-68212756586620",
-            "-42877401031196"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "133242907747130",
-            "50022504118929",
-            "2658782627429",
-            "10941894796686",
-            "-80085216865476",
-            "71240008008818",
-            "42520497691986"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "82862936532274",
-            "-110751109078729",
-            "-88636454965649",
-            "89575893784635",
-            "-113792597216820",
-            "16670045303954",
-            "72512396633875"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-18708696209667035",
-            "-29729465986356868",
-            "7302038187080545",
-            "24647819387887401",
-            "-24274097067646472",
-            "8981835671516785",
-            "23227166627732592"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "15050466481240323",
-            "-24020755744281234",
-            "30234678633583819",
-            "-32972592121664681",
-            "-31358688408363897",
-            "14381538054568157",
-            "-21711802576304571"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-2980656018277684855",
-            "2130261546356574299",
-            "-408075321227727159",
-            "8286713698598987178",
-            "2810785916900593847",
-            "4658344625420734801",
-            "-85955245053273680"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5045733282821378120",
-            "-5160561427270835799",
-            "7274527635644960075",
-            "7450048726897605750",
-            "1192508141799813218",
-            "-6935690825612507890",
-            "4890840298456771251"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2095147600329911271060",
-            "1933472672626912165692",
-            "-1347315152343358826298",
-            "277387945491924944621",
-            "-769378651588853688675",
-            "1228702994603312892693",
-            "-573226298560349349125"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "949955811513626444069",
-            "2348831874784760844285",
-            "-1005596983583704859249",
-            "-160987643119919574079",
-            "-226311796781453099711",
-            "-777866278163013786942",
-            "-119808887292662530484"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1078706430442981789252",
-            "-830548988474988813900",
-            "252173722280322777802",
-            "686764913963945110534",
-            "-300321502707885602741",
-            "-2341175459570789936839",
-            "1104794651616574646405"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "81847995433813126101147",
-            "-122374233040857342961394",
-            "-86035995805787828514539",
-            "126804988483725019773355",
-            "173993212271803349346646",
-            "-479430025014835876660217",
-            "-107472624962357365868332"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-394077530826954690702589",
-            "-558490301095757507242556",
-            "-521490538576210425997803",
-            "457192467034944298375289",
-            "-514616069321096954519829",
-            "478488130853503189910654",
-            "-577821496311805716252063"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-25044801706278642778701324",
-            "12810834987050168365242160",
-            "31708912178391271824492022",
-            "29246422252469203846996284",
-            "29386096276019991509643500",
-            "49156718482999311956010351",
-            "-146178818417047615416629788"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-113609160992875298395963861",
-            "-24138001744338957650286105",
-            "-67004809197973811498505516",
-            "-102688488214775613024684556",
-            "139561555742232655615687767",
-            "-148612499920539242012129054",
-            "-60197558339677876239964540"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "20195825920279795940729324",
-            "-119334106986421277897505308",
-            "151659610074839765261403354",
-            "-118170878491501590658833395",
-            "50153305614953569413375206",
-            "101283064071515743153346905",
-            "-8052314554905129705402755"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "23932763385345968456601647803",
-            "15652781673781689996402901658",
-            "-25714911140136998783717424112",
-            "-24063108817371419630967954407",
-            "15277383588988737590192970511",
-            "-19221555964336177191153095738",
-            "8525778421472359673700475873"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-29702031637985515415546806692",
-            "-13859102307407213719104673225",
-            "-25067618688733109656139385633",
-            "-24682956579651842668991571498",
-            "13711565425088715334400148186",
-            "-19366222915962629805772891305",
-            "-33545282070076066792477610200"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1577579865090943191123249075079",
-            "-3525655228029257341271764365663",
-            "-1050223731403232946069011798659",
-            "9184101680926576354398417891029",
-            "1090277651050981596352138640337",
-            "3043069214224348874921088096672",
-            "9123125546671244166682999591141"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "5230742018439185774351510283447",
-            "-3712455999261483372027089691766",
-            "-2990152400744505134513538814664",
-            "7316572061546595364944616807071",
-            "5602827451767519820566081421704",
-            "-9545247122155861772969509882401",
-            "7032145480601368225417113061961"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2664567996265385909226813270251",
-            "5361353871754409746653525259200",
-            "2256932189357666584876220153595",
-            "-5654300048316572634355784474153",
-            "7631572574661069365537533985027",
-            "-2645945495156645486998250219170",
-            "2020870690070534491429622566455"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "2007985045286249696289152653639706",
-            "255131400056657258321022115794563",
-            "297050787060326049481336858216178",
-            "884106234438982336563352611661346",
-            "-2587734425716673025569123990231730",
-            "1957450916757365456976201890886857",
-            "-368089571172755563470896249505623"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1196387814490529999805386914015829",
-            "1038685272748955982421814739654364",
-            "-1193187060865049033560022310447241",
-            "-1172542451530951320883605317070612",
-            "2109806848803753145281118730755717",
-            "-1123127061355414245949691913443684",
-            "1576461862603874408384234984377650"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-622450033088710447603286926602835722",
-            "647404094951668977726470009898385198",
-            "-226340752111389342737654608992675255",
-            "288035057938916398743906657372237781",
-            "-398948521522675079718064199905049101",
-            "210834703229901379528655619684415338",
-            "-151997602879056519490824338774903819"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "599661339271767435241765491583593057",
-            "-405698515950459980602780956812973563",
-            "-651291563428939025100760124053290332",
-            "-657745631936196547863976296056517471",
-            "-600407163951273202005007415374308699",
-            "-238929313727252416233275164296771369",
-            "558497244260050726702362474833539378"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "47697045732499570659740940309604340801",
-            "49094216418383588916902774794940184651",
-            "107458416864580553906480322750546108468",
-            "-126667437332361921585431044198585948515",
-            "-53936578834290623326458038655308336078",
-            "104673595473921192102042280196362912884",
-            "87274371731568548795590851613278065574"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-57994691774977410461009466091670483898",
-            "-139290829877786761805444219267269803497",
-            "125557441407240749013229104923768296949",
-            "-149517211669454181272347743110271361442",
-            "-61144120978857663327902638374458613629",
-            "98284527118323795858458311216632999342",
-            "-121317326075664247739969129996213981006"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "31724754377471299103514825907465147200",
-            "-68683175193407119606110759218116809794",
-            "51929217413585477513343109403149838340",
-            "-145027261082478191639375237467632529703",
-            "-49770426552521492900748892821647544270",
-            "144672559328394602382003101451778075572",
-            "28345129948566882228213841519097444442"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "19013",
-            "16476",
-            "-20629",
-            "-13807",
-            "-4458",
-            "-14679",
-            "13895",
-            "-6591",
-            "28846",
-            "-910"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7624",
-            "20461",
-            "18204",
-            "566",
-            "-19039",
-            "17312",
-            "-16104",
-            "-30039",
-            "28542",
-            "-31955"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "630872",
-            "-3149478",
-            "7212148",
-            "-5625858",
-            "4187377",
-            "-7592605",
-            "6361212",
-            "1360513",
-            "5585631",
-            "-1637645"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1903211",
-            "81573",
-            "7930229",
-            "673455",
-            "-5195870",
-            "5653300",
-            "756828",
-            "2999469",
-            "-5710166",
-            "5301041"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1853757120",
-            "1047124920",
-            "560213792",
-            "-566455513",
-            "1050311723",
-            "1598909497",
-            "-1861461622",
-            "1007453606",
-            "186779504",
-            "-563460356"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1383656932",
-            "883468748",
-            "-1292278154",
-            "-903131312",
-            "-1071814745",
-            "-1300060646",
-            "-837242798",
-            "-200746325",
-            "714599424",
-            "-6503541"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-460640621",
-            "1452598777",
-            "-1043355004",
-            "601836614",
-            "-387360778",
-            "-1842549950",
-            "-1286045229",
-            "1011279045",
-            "897922597",
-            "-2075789221"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "268979329564",
-            "516400770279",
-            "-330547198646",
-            "-138555837050",
-            "326543329356",
-            "-135436080610",
-            "-179952442222",
-            "300111077580",
-            "-276023308365",
-            "-379534546872"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-11746421841",
-            "-355409685643",
-            "-176229485899",
-            "-335104431722",
-            "162586810440",
-            "-417505572341",
-            "-327503218560",
-            "-237592706942",
-            "284154570293",
-            "-247114028858"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "81497388294647",
-            "-105089606867026",
-            "-85485884825237",
-            "-84732918845306",
-            "8357901780398",
-            "-59052160981538",
-            "-118765758366224",
-            "76774046345709",
-            "-122272430514436",
-            "89632957325007"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-49023243323234",
-            "-19691482514190",
-            "81020005388878",
-            "-13049232621282",
-            "-64400521716964",
-            "-44556778372970",
-            "-126760338329887",
-            "-95545268831523",
-            "41700405063963",
-            "108419780726149"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-107526557921638",
-            "107593946350906",
-            "15717527533250",
-            "3802176381376",
-            "-95371837173682",
-            "31982300862443",
-            "11262311488441",
-            "-71783765256670",
-            "7543990555883",
-            "6433455104518"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "15370190057594307",
-            "25338659396844360",
-            "-12395415092069244",
-            "-14339801329528901",
-            "-4669889778034838",
-            "-25293753369826946",
-            "-3864029849168179",
-            "-2361320120283656",
-            "-1383816312214096",
-            "34795785958072458"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "3783311029197913",
-            "6715667064352355",
-            "20491322855651616",
-            "-18892806810730476",
-            "-29298088411781325",
-            "-18004762134322096",
-            "-6287459475318319",
-            "-28607277114462589",
-            "-21423194975668894",
-            "-34665915056050672"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-3801841962478573811",
-            "-7405589676368624854",
-            "8312654202555889027",
-            "-8469153922901405899",
-            "9033342105804955460",
-            "353262572711500661",
-            "-3106215324351420666",
-            "831047326133816380",
-            "8150006237115616315",
-            "-4283399264798386963"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-8901584431726569509",
-            "3464311601859524575",
-            "-5869426028134580414",
-            "-2688169706060456011",
-            "2295784898660947844",
-            "8661201927268530958",
-            "-1291556588632435723",
-            "7508890651106821342",
-            "-552620568374393213",
-            "-2414552209269209516"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1268774911788677821466",
-            "-1468173730086716488054",
-            "2333556357660662925914",
-            "1125086588336622451903",
-            "-1307938906371302432016",
-            "-1335315025974812297181",
-            "-1770591667023996442654",
-            "-1618151743678349641488",
-            "-1953870570892738899528",
-            "-1420698506208780653516"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "97145774678299519394",
-            "1227557973951035235823",
-            "98483114001898133318",
-            "-241607937190185623252",
-            "-1824624845562727979837",
-            "898642316179641750374",
-            "-917227455439067325819",
-            "1391756574048152055440",
-            "-2338483366275639941073",
-            "-236784562298273813783"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "1385658483208773656383",
-            "988352401637819464904",
-            "-834024798417789410134",
-            "253470261013770477298",
-            "1027824244823037033941",
-            "-295271284578270208942",
-            "2092749933699556157881",
-            "-212909696600914004341",
-            "430816063369429652642",
-            "-2118940369361998675417"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-72495282431672509310211",
-            "-260808002784871326009195",
-            "367911180219297507096976",
-            "475567389581679354296412",
-            "283347954325215180669562",
-            "-247672665222729098007990",
-            "212556445759539758862792",
-            "95137611300085883049338",
-            "-253373421791320529250788",
-            "222529485178868323798812"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-198192142423639484697068",
-            "177859535515358311773279",
-            "-558532822597349100035295",
-            "-340243398464679108564091",
-            "265469123993517923432529",
-            "345718000847558318478738",
-            "378018566902132428188504",
-            "105885046930552921000134",
-            "-160893570768315261756622",
-            "-387610702742418384935858"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-144968858380916871672160248",
-            "52324015489202530187648533",
-            "-60539725259061399057418114",
-            "5951149345478800610815784",
-            "57415730864791909115606042",
-            "-52801875272942350510376204",
-            "134592231723492901663336639",
-            "-140309028873563970501229424",
-            "-108507437605812788817593167",
-            "34131217432985750294482026"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "101925561886985522713167496",
-            "64068475454853961876718594",
-            "52868179913899871904937921",
-            "47228119380503897884367815",
-            "-46788993674462462832287570",
-            "-104610259825858116764781983",
-            "32354527810168930868473679",
-            "45056639449462594887058208",
-            "-135796831562998221931983419",
-            "-118863104811282298311979720"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-144935023148179749058126736",
-            "48227314826112309666538622",
-            "82605524173281841359546240",
-            "138426913971094444509629819",
-            "133303171716402294169615293",
-            "-142698067685030493395426562",
-            "-16118795484757783951829634",
-            "-127345535900813079037928402",
-            "31052925027573527366876496",
-            "6085416657630733491512226"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-35364635610587093818111370252",
-            "4086803468490861639250374276",
-            "-1753919885518013415897000208",
-            "26862553012392198245742349664",
-            "10669372287960510828219956384",
-            "-1007097557406650376921479141",
-            "-1580693773196331906210657222",
-            "25812917857711965549650468024",
-            "18724993038796357154863599325",
-            "-24508123889671650819840888793"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-18902279341581100470708119631",
-            "-36522283854701472155628358904",
-            "39532617789123607497080494567",
-            "27117584983573687565416505488",
-            "21636499255472286057566042509",
-            "18733621370093464247720680288",
-            "-39480534968471587456182921828",
-            "-37721391776569371748588571168",
-            "35468843832781032242301509843",
-            "-16165717202124486435967229402"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-4522816763549834982990574959364",
-            "1373820747630420236782319267397",
-            "-5973300398871900188157345915779",
-            "-3481250147289716375798626146235",
-            "-1694496501940066046436069391978",
-            "-7462383927751567171069774651591",
-            "8912249954123145763780574884843",
-            "9381633652197120079484670939176",
-            "-1098878014354252629151676845724",
-            "-2173222031454195847214087975766"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "8975610890580938533873895882166",
-            "6181193231273971804885197385850",
-            "441052995054523394237285556116",
-            "-8766763319719487961533692298280",
-            "-842714990971736191972834107071",
-            "6840968783732306639312843567376",
-            "3841095572745602224231284364820",
-            "9467751369945105582701807843797",
-            "-5351035191765711075838610630694",
-            "-5308772832124983511335493031630"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "9347392750318791423094898319330",
-            "4183549304829613232393877274325",
-            "-2300378611286319596549279057011",
-            "-6937551197751554358853541320617",
-            "4564202808321596383974663617261",
-            "-5190481232725371819825118580382",
-            "1822212646901438322631749853066",
-            "1485920178528983047791595729329",
-            "-1229068069521960212083202938332",
-            "237689578861440280652794100924"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "115106178081535021784505745982211",
-            "2419329305084042487339107025104645",
-            "-912291369331954853157175763841502",
-            "-900563205408184843681209632304310",
-            "-2409941993002043200510899606638580",
-            "207954557233582697210944508650947",
-            "2523362759243854886179529293350534",
-            "-1209388681794143621587165255741373",
-            "259026751367118542127035660878113",
-            "1003660757951177805123793137984087"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1364136601439660016967396025012011",
-            "-2319775878890049929548330062341070",
-            "-1449285195280197573540980195382578",
-            "107888626176858249017005749097741",
-            "-2047490557041291301727159113491968",
-            "-879558452744622993459196325149602",
-            "-1386527790084045558776796472278147",
-            "133271536923889936499750446388741",
-            "-2505010338752155970620613001087615",
-            "666690558706649829294657481518697"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "647827261339309139672072271604218401",
-            "-258811588602379592317988185007366025",
-            "19118764232643136124664526632131448",
-            "-342358790376296733951169651683991194",
-            "323251023333708738421455258993841741",
-            "379547465547461884608218077364934561",
-            "-377241696764273343171368191818828042",
-            "-474120316689176518053512200120507400",
-            "572902079758457973787032998836436243",
-            "-170695774138811733345401262184630875"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "305708404293242487627320811047392371",
-            "-531504659332015189310098462346024467",
-            "38731992465228164632556252163535297",
-            "663006990236245838431214438209595319",
-            "-118885733274822068648133582054828225",
-            "-144829449643189775388924778145388908",
-            "472872218845792265593284840437270542",
-            "-310671243825518439944530367781619370",
-            "100999780786464624037618413063970122",
-            "-140342096347493988777682079106141362"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "32980532793889149400753838532332705439",
-            "-164344442015956226607797018737685311450",
-            "-141620964137040177729886345057833620325",
-            "129406137990155072039956432976677981821",
-            "110860822470333733093650034824108278208",
-            "-55257524399499752297571098737083027353",
-            "21667380566056781477986443622263599784",
-            "-139527484497317282946286760556136131579",
-            "2993193228803848771670718010890478039",
-            "-17314058829458659076458760524200313761"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "136785414456456523483802852002988078554",
-            "158300488297788966764944523807878924712",
-            "-139182135932402606222753976139330995413",
-            "-65945426315720446378481044342262546327",
-            "150507222652197288662681358385272850559",
-            "103871248288732570387585721016195272008",
-            "71995969230355239685697947093141718491",
-            "123362031595790252645978327397128737346",
-            "-9750682546488018096795492364860912234",
-            "-154627508798373930419429872814370749557"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "119842907203642501605603704672016604700",
-            "-17268268161596497482469861499561728202",
-            "10844152782523585961703939469633384076",
-            "-62997709460500166787346095846904613371",
-            "88308111493725127276829193825175861897",
-            "51565439967137952485926321683961024024",
-            "47601722115696675135575316380394827453",
-            "-103072164908596700312680385416990765141",
-            "99066862329124132138915843909816085618",
-            "29881936603443354551348559988907820317"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "11695",
-            "-23366",
-            "12098",
-            "-5922",
-            "-24360",
-            "-26490",
-            "-8451"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "8356",
-            "15273",
-            "13350",
-            "13154",
-            "-24436",
-            "17249",
-            "18193"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-7959866",
-            "-4584859",
-            "-1849516",
-            "-5743547",
-            "-6549993",
-            "-2265282",
-            "-7704024"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7862991",
-            "1982106",
-            "3725606",
-            "791227",
-            "4292112",
-            "-7820825",
-            "-463905"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "393711805",
-            "722994374",
-            "-1096064610",
-            "529484077",
-            "1342578673",
-            "866470525",
-            "205716816"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-791379162",
-            "-1640580986",
-            "762691364",
-            "1995469295",
-            "-421319712",
-            "1271534201",
-            "1429378995"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "302750528",
-            "-120846658",
-            "796589794",
-            "959422940",
-            "1637146863",
-            "-2105168751",
-            "959083607"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "369772287616",
-            "151347559746",
-            "310899836472",
-            "-72176434390",
-            "-96924947011",
-            "-228897695327",
-            "-200002009593"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-457074057554",
-            "-375995209273",
-            "316810959776",
-            "232806094204",
-            "494582201448",
-            "527142467595",
-            "429029914811"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-2749358243231",
-            "-16732337474393",
-            "-41981779092256",
-            "-31047429629139",
-            "85922781452400",
-            "-110248875388850",
-            "14775617632206"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-89773154375777",
-            "108323854266884",
-            "-25662671385030",
-            "43022064801421",
-            "136623279644254",
-            "59073010679225",
-            "-68467564739828"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-72813466497130",
-            "71140769259291",
-            "-80317050256498",
-            "-54904445398065",
-            "58067517976047",
-            "140251327559406",
-            "-19836322904046"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "32549494969775706",
-            "-440355605481950",
-            "11791444108889307",
-            "12475855272248987",
-            "-2784519143284935",
-            "32466210616699342",
-            "27675300306271448"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2902857186001800",
-            "23303428815434999",
-            "22978749219565527",
-            "18265376949989171",
-            "31457574635371153",
-            "-7781184835189876",
-            "-14565659292923040"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-430513575868348426",
-            "-8790392468356940146",
-            "-4699312496566636040",
-            "-3993022130065929131",
-            "-4879440303771900917",
-            "-6552655591468880275",
-            "1746806308890936437"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-721862386033128083",
-            "-4475260144423557773",
-            "-2570981490582934517",
-            "-7711961915298512607",
-            "-4822749646811070045",
-            "5836898402712974203",
-            "1646816636258502903"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-196690994284317985909",
-            "-1104147372526288843337",
-            "-1412688911560211238060",
-            "2156517522260848540623",
-            "1969864666336817403192",
-            "-424864910108053276903",
-            "344362455866908271873"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1977829057280933277101",
-            "-1853366049465512956083",
-            "2335230945236060536049",
-            "-1075731044607594025734",
-            "1859892436977688408623",
-            "-315861879615022790690",
-            "-406105163821827431877"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "417852109818843056255",
-            "1752679773930708218188",
-            "-1943388216652054599366",
-            "-714786275398685414265",
-            "585659101400025508462",
-            "-2096928276954243783388",
-            "-5439936016422902751"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-371691511788058976981831",
-            "468331324108156702082525",
-            "-306216617268143895601700",
-            "585404166947186691975366",
-            "288996272789179095805972",
-            "404343176683141658586544",
-            "191866472956788824823964"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "315327112788086641525519",
-            "196752770980596165008391",
-            "-572486369362609381413082",
-            "157070379247532783973389",
-            "526043469975661293749107",
-            "-332418593565470406233968",
-            "-456053081488540795834833"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-32587082314199631587299920",
-            "133861603238939464220682787",
-            "-83661874551945050110053855",
-            "88800710199138738791487458",
-            "-148303404783980031631890281",
-            "-92723105772899258187193672",
-            "8503332868372431603113821"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-19332793743633931994349116",
-            "-96326365761369957850035834",
-            "-131011081713605299896434887",
-            "4272403363996546916496923",
-            "-136751423492618686805500248",
-            "151616186823003014418871731",
-            "-1671600429980516271659907"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-140178641895610194038703824",
-            "-101032891978279919640123306",
-            "81660784678037787563074285",
-            "39964525581604073164209878",
-            "-27374188725798306962666133",
-            "30132624370004367295733964",
-            "-24808854061327935626508114"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-18346621296739073329815384276",
-            "8129555162832277260205547644",
-            "36653480194016965780646040547",
-            "30413178297188904152302651584",
-            "-3894577824082035416332316895",
-            "-36007834468089853892594019849",
-            "-15800624696484429406311297074"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "22023236505727198042054799637",
-            "25162398511869781136612460948",
-            "-27627237437030757915583163269",
-            "2399929206249180782631036076",
-            "-28662435722237160171923737772",
-            "35814219127521949420744820118",
-            "-19892289081278817747121556433"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-5833740800009897266898626041467",
-            "-33244429845422337192185559070",
-            "8607576650630464089887525333430",
-            "-2116847884082967129690884147276",
-            "-1688186241717588214733687423048",
-            "8336863793337204216701546448411",
-            "-7776559106309167653701679757019"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "7677666198324057071013895406917",
-            "8312123351615753410594523358329",
-            "-9172950392603423861689575769225",
-            "3983044414175939736030503134666",
-            "8631672985863441241981992212823",
-            "-5092486822105432034536308372124",
-            "-9513508243773819164622502221862"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "5586571833059467170325581422044",
-            "580606001351331867421453366092",
-            "5459008382235569678361699614142",
-            "5167556446031629490226831649463",
-            "5538049048887584844681848848766",
-            "6285520963756397613259958855517",
-            "-6303661112625789803890168279755"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2026431296682674250857553865416840",
-            "2156728720055476065414283902556465",
-            "-2113626044266072567032924427618725",
-            "1577105749037891124349723340806308",
-            "2341510691513285685324249715992360",
-            "1152985290466370765853992549550372",
-            "2257606784668378735530248971238219"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1909890587318622197067905430014808",
-            "287541947253583018938971686094227",
-            "2133113520020164331925609988632397",
-            "877412966607662750851739644288192",
-            "-1354720000623937488986892371455979",
-            "26739837041119641398066396760126",
-            "-188838172981149861365490159579856"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-474782395129122353298074619574123333",
-            "475246432403218151819336842343219369",
-            "-173617778400150860563781368814715566",
-            "-185846112444193317541092054250459789",
-            "530657363533857853032769680847569540",
-            "-624548224136809783035837658411029096",
-            "16767939677460215918277184102392562"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8794439856560424693485039347212630",
-            "-74573922642298735959395658944476425",
-            "50121637564100226023942304740008235",
-            "100186315919309941191487123083722961",
-            "-656685831019371144979565967330203175",
-            "598127327210536287666688394187681062",
-            "469011031931868490962046889570742506"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "132571096983923187471923107191482189670",
-            "159416816456247505951844178439417096312",
-            "-46858620574250494092983344457915710534",
-            "-32188937023483923298551233297633219014",
-            "23399433488123673778344704553087116420",
-            "49411831195906345612909906764377215656",
-            "-120433578968253846639971258003920226422"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-79060725002651426090157731360159425117",
-            "23590752860694088349229816117245792147",
-            "122068332660626412558932914786262751393",
-            "58567440788739372959622438841791498887",
-            "-151757958624575453818610406998254514825",
-            "-46670330230498566773973502369131285704",
-            "-67623110355947762123153960505167699960"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "19323325648279215563974499442806584258",
-            "160743730096300729908285974982614804782",
-            "98979412153227101016992388437605176538",
-            "169051965254068352712380666347973917472",
-            "33410045474491953996554951161727411456",
-            "87639385406550804599722815989154690961",
-            "-127263625338574842387718381281492249303"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "30246",
-            "4750",
-            "-19198",
-            "21754",
-            "25255",
-            "-32398",
-            "-217",
-            "32432",
-            "7160",
-            "2502"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-22430",
-            "3984",
-            "2068",
-            "-17474",
-            "-3604",
-            "15015",
-            "-28407",
-            "13805",
-            "3348",
-            "31779"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "2080492",
-            "-5892388",
-            "-4427617",
-            "-1926570",
-            "7753036",
-            "8027624",
-            "-2138635",
-            "-7355969",
-            "-5207656",
-            "565924"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7581394",
-            "-1145315",
-            "-5530746",
-            "-1343136",
-            "-1965882",
-            "3388545",
-            "5063475",
-            "-4724789",
-            "-5369747",
-            "-4555562"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "12542417",
-            "1259749219",
-            "-475800794",
-            "2133922027",
-            "584606746",
-            "1701844663",
-            "1570293589",
-            "93985663",
-            "-1590446304",
-            "38383855"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1335818368",
-            "1814707665",
-            "-1447700920",
-            "-13690005",
-            "863389254",
-            "-1088930392",
-            "2068779612",
-            "-431001990",
-            "-133595395",
-            "-687033383"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1433448420",
-            "-2037717833",
-            "-681228088",
-            "566270991",
-            "1714830138",
-            "1383333290",
-            "-870073230",
-            "1018390804",
-            "-1658508550",
-            "-1107870810"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-183566186766",
-            "22430286822",
-            "-216962582571",
-            "-466722944551",
-            "-27556463961",
-            "546569939868",
-            "-276694721505",
-            "-48879453774",
-            "260500893747",
-            "-442983780322"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-537420559602",
-            "-20381317872",
-            "-238654812999",
-            "162311255965",
-            "-380528677930",
-            "460248798746",
-            "-470403136829",
-            "41925493634",
-            "118729323873",
-            "152145641309"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "19115429868946",
-            "13475764429133",
-            "-134296438665814",
-            "106743314332396",
-            "-53710936617611",
-            "55826528957975",
-            "-6112400391073",
-            "29771890922370",
-            "12948136568295",
-            "70280112187588"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "75635401406293",
-            "29801992058998",
-            "-104075542445723",
-            "96149637189488",
-            "-92247279012539",
-            "-15060636948068",
-            "-56990909320532",
-            "-42148465517830",
-            "4636483585350",
-            "36352680284144"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "109325942422503",
-            "89437875709036",
-            "-69763342392522",
-            "-109570939746784",
-            "-51557696910336",
-            "106618186702949",
-            "-52418370534901",
-            "-41131112323835",
-            "97009168063041",
-            "15052093903552"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-12596475918000306",
-            "-10440190089661389",
-            "15930071291826631",
-            "-14154914571137080",
-            "-20679980275492503",
-            "-5555224487780486",
-            "19901627911606993",
-            "2179801741655552",
-            "32519637793270999",
-            "-12190525011728478"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-21675467468906896",
-            "14317453815507613",
-            "-19766776814356123",
-            "-15076731200801441",
-            "-22431380700345243",
-            "-6473570686950262",
-            "-8373384674763888",
-            "-20901722770742947",
-            "5175325370040911",
-            "24214606141441984"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-6586995582558976488",
-            "7822902623338681773",
-            "6785324312631495786",
-            "533690903523561420",
-            "-6270244316286526849",
-            "171361209170531205",
-            "-8970550092894953161",
-            "5694205347266685846",
-            "5128833225945547275",
-            "-6526220735860764396"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "1525290815331568444",
-            "8786542072042599843",
-            "3211936611572870417",
-            "-1018796928748300854",
-            "-5419478240797376370",
-            "2820144392948109276",
-            "-8097542825869754965",
-            "-1815427842766140431",
-            "7519915858501526150",
-            "6718055695379996173"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1633852390483743207506",
-            "-1111545040340809206837",
-            "244724811785233487882",
-            "-693891632794029583107",
-            "2048439746612005438484",
-            "-2139374266382006896259",
-            "824431366346499761550",
-            "-2178751263030852933012",
-            "-1927196521844590849943",
-            "988141071239138916737"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "2257309169850384513902",
-            "-574793864866852081089",
-            "-1948188754190708684653",
-            "-1683360294804356257358",
-            "1047989496843790848714",
-            "-1920909202759912391700",
-            "-524370318736298792785",
-            "-2270280452792278665082",
-            "-1977443531683898225523",
-            "996281040520873028206"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1794161457257457767507",
-            "-579049890249855445335",
-            "-1877229817480332151412",
-            "1516286188346047750655",
-            "1679089559862183244805",
-            "1899758075679851870084",
-            "187132781949105016179",
-            "1867935632353572731320",
-            "-1296841752077650621812",
-            "1300114283317135818081"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "158042936756450218355580",
-            "490847485432966130350847",
-            "529866300289645094459968",
-            "-197353870044211794005526",
-            "87425841556036243951489",
-            "373006885981853652482697",
-            "-287764822688722336029390",
-            "-190352821874203518937063",
-            "279464221696482690177922",
-            "456648278931495677210040"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "62449586174442498659851",
-            "91984117770625787970323",
-            "-386017533006981165958695",
-            "-252962587854796012161774",
-            "-41590821064900391076386",
-            "-482091979386779184677156",
-            "91503772892342811308019",
-            "-283504385220883938631335",
-            "68755932698885547223664",
-            "-379651999761873616235097"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-126087576931161225003970774",
-            "127239018834369984513800503",
-            "70141064110265604854079590",
-            "154422224583900250448650270",
-            "77231480791207775951166590",
-            "99492320089316975380000682",
-            "-153576307293383539264890034",
-            "-116341636204244696735578596",
-            "-15786876758860723008109946",
-            "-34149255348815753839077980"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "143153832119590577378917526",
-            "-23514921785325046830312515",
-            "-77172712985345097430419628",
-            "-14243153727807957632994400",
-            "-58696496713845538380317529",
-            "69538635574941878208722809",
-            "-26166185622705445056596537",
-            "-62690164472796028840316596",
-            "21101480017403262376196510",
-            "-26276281990810217165918990"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-40333807166719138901605362",
-            "-37987667593309107331951459",
-            "113271936526201411790724188",
-            "-45961181592872567354204492",
-            "-55914627445218102108646757",
-            "-104465866552974080878275370",
-            "123873735196193599773252021",
-            "-69984072371083501932162355",
-            "60408753566988145951843027",
-            "84960611400280128174752202"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "36246979996368740974728708372",
-            "17919686541827178802317575872",
-            "26685274428819984663215559869",
-            "-26830140388908281565789341267",
-            "-2931873170900073034034488176",
-            "33796846013743474981760651067",
-            "-28384722395594446851545817635",
-            "-22654753522493569083372946875",
-            "-32663458189555845828697337353",
-            "-35127901885613742916339593277"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "20660444307893572140115730346",
-            "-3785075277916670195560917943",
-            "505119675982960330877221727",
-            "6140046975369405521925948823",
-            "4736562894917206280220185620",
-            "34734639626599117839339792477",
-            "-37238839274684550289419840966",
-            "-21192307666520898522344443325",
-            "-25731253359857977263230009203",
-            "9784873768788010897306473642"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-5228112207960439532634245527389",
-            "5167964205023544904856267703266",
-            "-3153830415354733573037966725748",
-            "7450883686345014593203587360908",
-            "-6190984559160100747667669453446",
-            "9158379943043982798000435871289",
-            "-5143633836669582578660334205312",
-            "3857866493487182226354931788449",
-            "-1995529191506094552567237788773",
-            "-1939757494685073234017884338772"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "2983226908002458413591863312573",
-            "-532752777081931294958349500501",
-            "1691976820460575299172383596135",
-            "9026960176016243081320400536118",
-            "-6149275498377603931086308362289",
-            "1877762879546909895671695219561",
-            "-5543502816818045577508158461912",
-            "-9721729867149888495285508938337",
-            "-8920180100768743706171922537830",
-            "-5169979352443901899206068056740"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "8702135094804887254191507204010",
-            "7975177441141361458695114972857",
-            "4215501985734737238170439787178",
-            "6544777372478132898809386710105",
-            "2765576461694941619080416997749",
-            "-1508947428389258215537026450679",
-            "5110812407105601388124457686907",
-            "75095474631054730513072856363",
-            "-4279937210566724408068745471134",
-            "-4330630809933126585531848495211"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1504559618154883384814296581669162",
-            "-773390196196490039153882388890703",
-            "-1897752906170923065951917060777094",
-            "142958130493415644926376088950273",
-            "-779836256990434274653725306832085",
-            "-1753325836605413516914447603525700",
-            "-1542378627150307800859873587627455",
-            "-1939970582128933270354383457813584",
-            "-1411234208839859424724556632640107",
-            "-2126244899381031545661748447926471"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1307160371865080630115651820675170",
-            "456003844170818774621646351482357",
-            "631068765196513436260956185922434",
-            "-1965243043509431543877873260642837",
-            "1924094736312307345032078234417418",
-            "-1875239514046642535329927412930852",
-            "928252274243472509987779134671194",
-            "978995848734671073561475467379020",
-            "-2564475835488959647742888457890405",
-            "-570152793522093518749573568631120"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "480389537893603636983558781276270114",
-            "-322627233363211525549283706077204323",
-            "-175773029789054851482330028411371014",
-            "244330382338385690861905900080229456",
-            "-392607940616669928826392153052775593",
-            "-107267728131376637957275222403768541",
-            "-545143790608966683829710014599747249",
-            "364869469591341322932716899752758323",
-            "394858084329837561588098411142592437",
-            "-610840159277877166690985420617619153"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-192669740281245461265542023292550989",
-            "-12603685317720603777562699557006198",
-            "187283379151228677500952715809692379",
-            "513546955692369120286734180331431234",
-            "-482110749762971834845638869557855315",
-            "91471688959029993916111990585487772",
-            "220809860807910859636036119386009639",
-            "652850877928760022088469019476234455",
-            "111668879690942453024321503787659219",
-            "73373210253636230671660785291826427"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "44996590607819977856286386900323601897",
-            "-68502769785321582579070708156248378078",
-            "114506708080602131052528148832194410156",
-            "-83232569015900232819092415317550976561",
-            "-97716408046524726095696560404660126718",
-            "32040614956823782468855275605877008019",
-            "54753377444348733160915719409913741068",
-            "146560799167787084071378433728834118133",
-            "-46659169011613354044672675978630700660",
-            "-18373617990019061846229769982316099682"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "67505677281734524965060455064837775711",
-            "-28713223195193703313300117213126061466",
-            "114670528108596039585803474305454053759",
-            "-109328515397473152172020766238706523521",
-            "-57747808164476452164582125724287659511",
-            "-115039911119596976728830311034338189054",
-            "90118785065736856720547824894744092178",
-            "-89659383715739235835540012679951558145",
-            "35536568601909522172926452268384931891",
-            "-133420441752119085196081353415527833003"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8627303427894096841021728602542914202",
-            "-157430702291942847264537187308979825421",
-            "117495445521490567278694563084720233793",
-            "60657311361342276211434917495326305014",
-            "-46555659115647145900825174050414002012",
-            "38569430641717011417297628092264146455",
-            "104117949912584083295919883245212540224",
-            "126517129168323484921506157524766805721",
-            "-89395247495161073292219697890210210916",
-            "93186204422346566052866526301928198107"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-28716",
-            "-7461",
-            "5893",
-            "1161",
-            "-17035",
-            "-15574",
-            "4237"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-5295",
-            "-19936",
-            "26923",
-            "2510",
-            "31124",
-            "9353",
-            "-28774"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-3553533",
-            "7148395",
-            "3061750",
-            "-1009165",
-            "4381645",
-            "-1818667",
-            "-5730247"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1477251",
-            "-5800734",
-            "4881425",
-            "-7296550",
-            "-1526219",
-            "659450",
-            "-8356198"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-263873982",
-            "-1472352429",
-            "787206308",
-            "761788112",
-            "-2134545176",
-            "1917444990",
-            "-145750272"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-433966181",
-            "-1545963916",
-            "814812077",
-            "1593862724",
-            "-701833517",
-            "706907239",
-            "-544182188"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "805594080",
-            "-1195679709",
-            "882347557",
-            "-1853839955",
-            "646020133",
-            "1484971204",
-            "1300988856"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "4438499204",
-            "135820810048",
-            "-298194796045",
-            "-167913299917",
-            "-257288837544",
-            "289738017191",
-            "-418170170454"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "17906290840",
-            "125414876927",
-            "-275575916904",
-            "86104924740",
-            "-164076860424",
-            "390339975362",
-            "-408791420440"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-43710596027703",
-            "112836996919727",
-            "-105977145834636",
-            "-112904124134240",
-            "94001656040741",
-            "65183044734455",
-            "-131866661735203"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-90977051496274",
-            "-10596476734437",
-            "61560055683609",
-            "133871189520814",
-            "574814014019",
-            "-38018623146961",
-            "68859957958301"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "26944281635514",
-            "79179252721889",
-            "120097494144511",
-            "-76597855106777",
-            "72037045699022",
-            "127107312225912",
-            "-51976566719455"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "386005180963195",
-            "17673684201876788",
-            "-32819779628129716",
-            "-26142734584760798",
-            "-21415081378865369",
-            "27386071060762895",
-            "-25035767854560405"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "28727678942578358",
-            "3716854509922265",
-            "-30765891503268996",
-            "-35428939049280802",
-            "31032813396558579",
-            "21132833493728424",
-            "18323423600720926"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-7388758649832651560",
-            "4890796540741969531",
-            "-6494554253322577454",
-            "5501693823164720471",
-            "-8097047242278575855",
-            "-6038810107886633396",
-            "-2806525281648999824"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "5813079697128581888",
-            "4678184506304863002",
-            "-456855996733358303",
-            "-2121277677973694726",
-            "-2248413943539318365",
-            "6272381020409312259",
-            "1274893351361543565"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1566501292452282639110",
-            "847789298808224186659",
-            "-1381494557864830190709",
-            "-389660191209952286951",
-            "-191009516626814231082",
-            "-96116899012721630801",
-            "1868221459505859782879"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1469408605037106208705",
-            "120169104670163997156",
-            "885213643526004078499",
-            "1656898855207585194216",
-            "1868990072585461344802",
-            "-933261783269672604472",
-            "274307016875459849352"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1897801203902311359499",
-            "-1638391687561633219399",
-            "809233679262405093278",
-            "-1426552107698825838210",
-            "-2156155154558519949123",
-            "375648567641874627428",
-            "-83641445825921590041"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-54554428886951413193957",
-            "-422146139334599760408373",
-            "-181537137117950003153154",
-            "565479726514324786737359",
-            "424173391709408884362222",
-            "-426382471585898970959321",
-            "378989549983955912678977"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "332482827287198457983040",
-            "26269806073413044497682",
-            "221494228699356468610270",
-            "-214742700742291383196050",
-            "-485063025095965310275166",
-            "-206922662880263609184941",
-            "-12269499779054433613668"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2079153784240544880908553",
-            "-108538000488167946369982799",
-            "1337702113416699090369723",
-            "51201975526129906812967855",
-            "95133477031983503992368010",
-            "99560753378096547573231892",
-            "94680749872380168429064405"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-117274302077491880342412021",
-            "133235309557643707264847345",
-            "136425992851983814996249850",
-            "141388968148866833783730856",
-            "136798627735587050485647952",
-            "-19126693188647933554261649",
-            "48757965489875879851975965"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-8286635741174299975868485",
-            "51609959172902905910311173",
-            "-109111488591575501922430237",
-            "-78557116791558802282576538",
-            "-80656136078314199047657721",
-            "-113053382890647628720214794",
-            "-118160471943246572510407260"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-25813553783572142627468328674",
-            "-25977427310356228285126178554",
-            "-23185854957388926526847402942",
-            "-21707862041932744516393466772",
-            "-6421519562360989032505224517",
-            "569338598241172908008799687",
-            "-31836549906764569188743203758"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "37793044332277423478767661867",
-            "20748364196925817852337750787",
-            "392549789846734208161909185",
-            "26297790988587948005258680240",
-            "21586249354499693315147989389",
-            "22288577155677496694419036361",
-            "7345604052580273885509583438"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "9904495274881627900139080199187",
-            "7482827727017947275973272651641",
-            "5495560179907337187222597837509",
-            "-4055007536622081915505189176936",
-            "-9465371767163898005811811099232",
-            "-7331632251430461716607678930512",
-            "7141099397756868279221372659248"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "4169713351778166668753234914191",
-            "5859067319849858664254420101042",
-            "-3754282354044818620313472353105",
-            "2568048327396196032282025142854",
-            "9311607892968389058421897582763",
-            "5977797766778831148484981898236",
-            "-6645965265653096929117017458058"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5801906969242261868600254035787",
-            "-3336257298871507164494778520275",
-            "-2636835112016446965166101852431",
-            "-6885572586792737606252971841764",
-            "1603907679825345662447639552058",
-            "-6879056187486539384923466888462",
-            "-1790707021629779711475082448245"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1034675525852537762364236474862575",
-            "1711882430155290136112735898040514",
-            "-95920345818202387596164300835452",
-            "-2249141525032950659874767503830521",
-            "-1652263065729457379526511839069047",
-            "69137670296199427018181414584483",
-            "-1688424122016258582447918142136846"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1068287357075711311089614491385749",
-            "-950554951242207664534573691846304",
-            "-1956036184083258810589554917733280",
-            "-896537215061273632781289017902857",
-            "-2536258376526122583868387765640523",
-            "-1792994625229025457039629491080247",
-            "1098569487026708584137620128184550"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "175091933681780709419449962505368809",
-            "452587234945438576574474457110999168",
-            "551706621587607711559343522731729738",
-            "205869761865384575133175619802827356",
-            "421828722673799022708318616794744473",
-            "284099079750264743351804395834429375",
-            "-227206504976250724681610321278346086"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "653258876517803228567267877074483421",
-            "88498832885550519275280233629225185",
-            "-76011122884235139182377528836347729",
-            "-306036684553026363758974895394410014",
-            "507096898707325051267095986297417498",
-            "7244969811766625291666288991989734",
-            "-573031189194397866985879798798669571"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-78707895658241450417047565739309187422",
-            "-109360485739432018575519398965631343423",
-            "-2428635583984270308797486033895962820",
-            "42753163486976599252181370759774389112",
-            "50819284555128794452586051816572760071",
-            "-144242532387316071424543222681940814787",
-            "-36156399915684139601256093989051959166"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "162984880645317865260475927948552198958",
-            "85240365845562965434048060592369612866",
-            "-158859671947676245091304105755240830347",
-            "-106305457729982387569448077637482766080",
-            "112063647808441935089339730874648100522",
-            "-89567526888097522782942387372735070337",
-            "-106346834442166901546233152794820385747"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "49579890402336664433922726332197359945",
-            "73089275354843686046803386174212568686",
-            "-114653905042244944982579349957812151500",
-            "127934754145313083729997784370486712512",
-            "-153960964783146902490613407319798440760",
-            "61282287594543529304868203724834609850",
-            "-95735253186395895118322435677049180510"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "27248",
-            "21926",
-            "22498",
-            "-21109",
-            "-13865",
-            "12084",
-            "-10974",
-            "-7421",
-            "11109",
-            "9914"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "24181",
-            "-10020",
-            "-21281",
-            "21049",
-            "19869",
-            "30238",
-            "16713",
-            "3878",
-            "-3800",
-            "12113"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2112580",
-            "-5802445",
-            "-78712",
-            "-4496866",
-            "-5053677",
-            "2079868",
-            "6150553",
-            "-4483834",
-            "-8023488",
-            "6603846"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1291524",
-            "3929930",
-            "-7350947",
-            "1175586",
-            "-3405008",
-            "-5060125",
-            "-8206503",
-            "-1303953",
-            "-6095530",
-            "-2760640"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2147181345",
-            "-267715231",
-            "1287957097",
-            "604610482",
-            "-1548079692",
-            "770882347",
-            "-1892574560",
-            "-253216281",
-            "-399486830",
-            "1325921155"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "1675268343",
-            "554051112",
-            "-1764481009",
-            "-1789514237",
-            "-175051236",
-            "805874123",
-            "1858433827",
-            "-799955854",
-            "-253242360",
-            "31754547"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "861980915",
-            "-1734894499",
-            "5375232",
-            "-1346978107",
-            "-705850170",
-            "2133236007",
-            "759674577",
-            "1654618415",
-            "-1064241799",
-            "205825786"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-439739629851",
-            "546687129596",
-            "-183193050720",
-            "-19380489102",
-            "-295956872287",
-            "185301861617",
-            "-539483275533",
-            "174936140900",
-            "-216157665368",
-            "-323903818433"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-206902602028",
-            "-25523711337",
-            "329376290572",
-            "-547086561793",
-            "-420540489807",
-            "533906771992",
-            "-69356183432",
-            "-15636527669",
-            "-53282559214",
-            "-290867614525"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-71228950033910",
-            "-25738844726735",
-            "7537765437683",
-            "112839875804433",
-            "97538539157933",
-            "23979706973815",
-            "99830033351181",
-            "-98591255279452",
-            "103618021816339",
-            "18626785293021"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-63486282809713",
-            "101701065580704",
-            "70027248433374",
-            "-55296910174840",
-            "-79310707567811",
-            "71500005915799",
-            "-70746573691925",
-            "88747230972798",
-            "37301558421391",
-            "51854510134738"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-87693600270321",
-            "-12454309380745",
-            "-78257696973308",
-            "80285965677822",
-            "125254246716243",
-            "-117675991977555",
-            "10663316581359",
-            "24255903525594",
-            "81254209111391",
-            "-72113987036299"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "29148599662921759",
-            "19685775734681446",
-            "3333245217877997",
-            "2995823413324396",
-            "5176366661056475",
-            "12337102603147756",
-            "-20628365543902019",
-            "-22418243161590754",
-            "-29067802239769240",
-            "-23018730875097178"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-6176426923194882",
-            "-8149067582880393",
-            "-11749166095143035",
-            "18401921003901093",
-            "-1996265112064578",
-            "10197501871192290",
-            "-32253621163897299",
-            "-20847987719333936",
-            "-10659701083886535",
-            "-8278323833998893"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "5136857587879831048",
-            "-4226582843485454109",
-            "-4390294981117989663",
-            "4994818351801512739",
-            "-8267282930090047916",
-            "3039283087909496060",
-            "-4294189184656602394",
-            "-1041549980371122641",
-            "-3656126503669238317",
-            "9105664583047399153"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "8890565452093789405",
-            "516172262246414024",
-            "1562263263000381143",
-            "5536662842752237787",
-            "-8351947536553705606",
-            "6464103264200892007",
-            "-8790661469847258111",
-            "-6209442610558714656",
-            "435574662691177275",
-            "-4406978950610351547"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-288778447471678108496",
-            "217217798831157629251",
-            "-608988687910814932673",
-            "-2240048037329221421107",
-            "141299084981472691413",
-            "-2195387109122670914754",
-            "192149022897618665404",
-            "667039189961523482717",
-            "-2155889747007763781525",
-            "882853814250996329398"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1751402159298369348560",
-            "1451882575998488934096",
-            "1558108778681655864225",
-            "820503763199449595318",
-            "1623615880148157710724",
-            "-1033406684162170713762",
-            "1930159737768844808076",
-            "-940015457688702701592",
-            "25356638204045989132",
-            "758908114106815880742"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1716471103883506022556",
-            "1848997534114484794729",
-            "-1094717836300829658295",
-            "1157808654390779724644",
-            "1974960526678787421302",
-            "-791852644564930461068",
-            "1518936215943205538052",
-            "993164305481300592037",
-            "-2190917609278580708946",
-            "1868797478910203743832"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "107250259596579898525274",
-            "36231469749575876646505",
-            "329436325938797206808627",
-            "-280578826478526573569133",
-            "522936041458815155368518",
-            "192285773258090139021578",
-            "-54285825226099356185035",
-            "-147961354881812346695825",
-            "600347692235230272507966",
-            "-353688820541444702551558"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "365491534656040934517771",
-            "-547465713497612713037502",
-            "116041079260709253587380",
-            "119630447821474156181639",
-            "522081240494430350219263",
-            "-474030018965150641292577",
-            "50270333922267433091553",
-            "-24643818854330102652483",
-            "245112928498664779365511",
-            "-121521490474436234210533"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "26593659860935441804716440",
-            "75646833540201692356918621",
-            "142130608477738687479162886",
-            "-83412542972966251252815465",
-            "-151155951774532976658715599",
-            "76154233043964388249198213",
-            "-46853272352917278017975341",
-            "32486164613383508372076408",
-            "-66829799824523238584057062",
-            "95792417909842220506235101"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "63730088675558873019939745",
-            "143548109718428079482639663",
-            "-27693260291056796500091225",
-            "-72348766321107397898380234",
-            "138677152483427690881537874",
-            "58516156596033347413669914",
-            "-107433759528371577596908748",
-            "-78141621760355595625354145",
-            "57091054796595629043991192",
-            "-123271655549899762394142143"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-38477417050477847045725516",
-            "-95888838803508348417829785",
-            "-93625160413861971562012467",
-            "117087970522726692597218305",
-            "5900192167374488789348559",
-            "-24674580893344344193379627",
-            "140998648377023443587850974",
-            "-66274038957839610112342957",
-            "114522458983086926572397822",
-            "101447863265640837765853036"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-55906306943028913908051930",
-            "-26457941841314857799301954576",
-            "21759711912953355183243610182",
-            "19401890234998887013156330687",
-            "-15933074126275848181591729540",
-            "27293805787497685180871118517",
-            "13704320194409856542280625225",
-            "25216830024686698097083609599",
-            "-33566241896826513638448226962",
-            "-6406030957083785743431792377"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "13296281254042409316527886192",
-            "5338707057590130523225415567",
-            "8819455897090902612324273291",
-            "10450242868251146464691055988",
-            "3984408170044123068649964640",
-            "31173755255592998054061179789",
-            "-19050412661501894628584863098",
-            "24644713794131254858462909618",
-            "25395276076315730035919041533",
-            "-10189071623516303081731732147"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2273158346503188393179401750902",
-            "568616855647559589863643266508",
-            "-4280161068916792824269044568609",
-            "-5682425054604041528765672948927",
-            "2331397238480003292876981020193",
-            "3147988283813769672815110099822",
-            "-7632390386845877850077854509431",
-            "9840981189438011830733564669593",
-            "5308479141310485223873660191378",
-            "118932930720936450551429018688"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "741957915704735308305168907322",
-            "-9762021206507044939694536775050",
-            "-8250703757145415326282325826063",
-            "-1178202689406322490432919428434",
-            "589668456154125344611661965499",
-            "3829126770246418858041384052999",
-            "-4152282954150010503796558904446",
-            "2039899673016755337154781922078",
-            "4170256258494884707646640540653",
-            "8171545852305751294990084682300"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-6962616269350967896600526637270",
-            "-5635024743757428123953554602073",
-            "-3202590711760239385953136717255",
-            "9910046190612877780929595691738",
-            "-3777668629625810788137576085843",
-            "4614409143748488045192848474816",
-            "3938785692531490617884534958248",
-            "5437946965836538604426507932284",
-            "-2545690782086924734038765495913",
-            "616702678702978670407261429789"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1801934502106174445176675096416695",
-            "-1684879803716391669315795499837023",
-            "1886852307739025680614537841032728",
-            "-2087562101318915052443253201738269",
-            "-289564041897678470358656657180353",
-            "1866276858800525721011618985335357",
-            "1482056324539718482806113984364738",
-            "1379406656844501099108553390445618",
-            "447265769955522315901489749442865",
-            "-1608978736986184364139419097387143"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "959483969247063574072923758413354",
-            "451668303782354619245629961105613",
-            "377534722039293380340942675240743",
-            "122765139177423843232789966201962",
-            "-1265814388489880705763330194364716",
-            "-2555618459717759708270107188671150",
-            "2134470347388221582022629725907413",
-            "104244807033941042242397388741541",
-            "-1292911051966102235019381832015662",
-            "2097241241602887003970802334050941"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "547484906495898917724309897034434982",
-            "187296642318494648639964887497107585",
-            "195010449729172050428280546508810633",
-            "594640376620694404142214250754771517",
-            "616088304853668191153025331194418912",
-            "-379044114359687531180765592396048067",
-            "-486181591192683117321273734043119484",
-            "-334064376837986313664550095407721034",
-            "290486366889561681226507320645315096",
-            "-347474821649864554819987979701785016"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "592690007814067700303615752186669589",
-            "-33347738259818305399177703203880591",
-            "-382688857036730057091326853248715857",
-            "340921527686390758273070134422955102",
-            "-246344114285772780156570736620316760",
-            "-87281520666834090344267836809132652",
-            "537245232536815311537081321427376564",
-            "-493728711296235677585761940344917200",
-            "-377081442166516277552025620543264222",
-            "2719688994411558148859579112050541"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-164648696059184796053055559504365982538",
-            "161879775934873933398660278767200250776",
-            "-29323675327274284512731239968352351966",
-            "22303285730412507017282414138333454321",
-            "37099625903665917412076794028736570815",
-            "-19515107152254927806948029059117184611",
-            "156049973457253022366642762662774258557",
-            "-77241044079010949387624313535905707837",
-            "162149982017470420229015929290220014122",
-            "-165344491933828504403531276296434192122"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "65054581186254715937680104906134532841",
-            "-60909757301953794888323625879233446757",
-            "114089158661229718075421585158899052989",
-            "107965178723789597153491785237079504326",
-            "52247619354554812540456199083118815935",
-            "146474344956199824278086927555782062440",
-            "-39425662132630652063257104658393984944",
-            "93755642240344437526921615504564431807",
-            "-151156356500508700657655200155812034666",
-            "-148636865825500491359194083438394642725"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-130344022211343875529807825195567803183",
-            "40014360360807493456218651568578676997",
-            "135874153827020334699855960081428792617",
-            "120470160757792083712774060829445555003",
-            "-146085386552734357896040388977994934530",
-            "64861335611000408584376324518321919018",
-            "6601563302721623021480813949509601323",
-            "-114901836202314275670611766582662166373",
-            "-106800567037776957620875222943893747296",
-            "-163938636407835983157260355753705412692"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "5622",
-            "-4826",
-            "-23503",
-            "-23236",
-            "-24902",
-            "-27443",
-            "-2505"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-18970",
-            "2792",
-            "9559",
-            "29810",
-            "20493",
-            "-9442",
-            "-2618"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7747776",
-            "7378127",
-            "5914824",
-            "-7141645",
-            "-462534",
-            "7839055",
-            "-7683709"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "89932",
-            "427016",
-            "6342615",
-            "2937627",
-            "1091159",
-            "216727",
-            "-6413737"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1508343646",
-            "-714398970",
-            "686052863",
-            "2122626443",
-            "-2055953734",
-            "-1487184058",
-            "-327233497"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "46693013",
-            "-185591736",
-            "-1319806396",
-            "1714735002",
-            "-2133394566",
-            "-125069560",
-            "1637341168"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-24918835",
-            "413164011",
-            "-2057922849",
-            "2056580479",
-            "-457426615",
-            "536434479",
-            "-326452423"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "324353482493",
-            "-224184500030",
-            "-290036567736",
-            "-161876501106",
-            "275173073296",
-            "-357018570713",
-            "-297896568716"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-427281617130",
-            "-497367589935",
-            "73820145481",
-            "-254972813415",
-            "-60399473453",
-            "232313028413",
-            "-327759701859"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-54535480365073",
-            "61199946515142",
-            "-9892000149714",
-            "97913524605648",
-            "-85221226793073",
-            "-12545722671788",
-            "-68773831012552"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-126861055347150",
-            "57631355795057",
-            "9186109685969",
-            "-63002972283329",
-            "-58346149025908",
-            "115782687691468",
-            "139849718208364"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-93813523241112",
-            "119065079857991",
-            "-51189229753892",
-            "15646183077138",
-            "59056284602860",
-            "-92669522393207",
-            "2260801424852"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "1036615300047300",
-            "-28482170773083910",
-            "2678469281283015",
-            "25704309658360513",
-            "-12028318394798682",
-            "-17245374013553022",
-            "-16000168049485216"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-33753168399749839",
-            "-27740542059245417",
-            "-8681968124590170",
-            "32278807399459945",
-            "4851945585153961",
-            "14217157851976499",
-            "-8425777401033048"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2766941444469888895",
-            "1729136918975836660",
-            "-1477513497854998037",
-            "1433050305337001645",
-            "-8233598361619818600",
-            "996969961284840283",
-            "6329284992445382418"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-718575473243337232",
-            "-7375018409999376865",
-            "8283859855328355879",
-            "-4138525682818595012",
-            "-4431847243389561533",
-            "-8084764830291418974",
-            "-3798062670523971527"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-565050117259497763461",
-            "-281556879669412834613",
-            "1705137738829453364168",
-            "-501989730825366398918",
-            "-1424226998969964624602",
-            "-2198902125834852658804",
-            "382157856805932111771"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-303105514873146686437",
-            "-1865673314410343902064",
-            "-1739893893314072462832",
-            "199753736014467107913",
-            "277323073744563230355",
-            "-1117856351014668186043",
-            "2336687337270391579606"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-285211332299958353660",
-            "-1511512024403761316173",
-            "-1568309493555178992532",
-            "1640762644342585812496",
-            "-393568821945143862673",
-            "1038579276245861014094",
-            "-862919179403309677858"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "592348192569902724704840",
-            "-26223245863895268294610",
-            "-338508635422316199664947",
-            "-486334758177154752056666",
-            "-326020328807272087893596",
-            "306693173070483770415643",
-            "-231885616351380144700249"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "147342012649640932496745",
-            "-365590949715364851039873",
-            "-238949724961989355524360",
-            "-20804180906842992000207",
-            "98422693216257524451712",
-            "99343894264393231770703",
-            "5240277192766874192955"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "97249345115448597432142646",
-            "8875195937074039828120226",
-            "1542565882778023075834635",
-            "11772316605485844570699635",
-            "70103217733879642573345968",
-            "-102512631348831506793442303",
-            "-30574606355593089220215659"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "119081714072400880086737325",
-            "-117489206105111877901926548",
-            "128872288419083705914038986",
-            "130736458515802378822355935",
-            "-121556241169153639422095686",
-            "72946657503235618393823866",
-            "-125663836339334145024409857"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-140434705281044213047311138",
-            "-28116089490630336228630975",
-            "103267266309928582800251241",
-            "-109508303463489441066925072",
-            "-37447408761258714290948079",
-            "-48348712769317916926342261",
-            "-140369639756363883929708964"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-9728758914128859071321834279",
-            "33309572658775989148537936017",
-            "-24668259330599725242298254275",
-            "32381561123351360763354670731",
-            "27825802768031595606954105738",
-            "12938216164626281948188731232",
-            "38931244077102153608387825162"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "10382809776177658355331432551",
-            "5168110327267343534258764218",
-            "-3267242975961960293350853731",
-            "18434029108189696411322869404",
-            "35091091873636227218260118505",
-            "21108165552752916181263958022",
-            "3661245166176387607640692752"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "7740613132371376696717495398418",
-            "-7707941191956096108812155008476",
-            "-577241601325072443290122836094",
-            "600167824497967521284893595791",
-            "3272067843081989787146120493930",
-            "-1030145054800689456877805292349",
-            "-3650234270988646330203349279059"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "7680286774308848437433168536793",
-            "6647565199451142367949930365916",
-            "-2999133161143853022620246013872",
-            "8804348153856092578496854714407",
-            "-4952285004482144846215389827781",
-            "-5318507214755856895477853590188",
-            "3057348036468872181146029422349"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "3851649300561843980682812308976",
-            "-5882755312906144634290218148759",
-            "8705902980707176681205204470899",
-            "-7226642038551930671682828321801",
-            "-437315629757074034698382119925",
-            "-7001534311562577654291968216882",
-            "-5286321524483593992727653959615"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-2529962123499222848219244545038324",
-            "395962666703149974739931139610831",
-            "57550468475234656216408472967844",
-            "16338486361970318802019682813255",
-            "-1828779660992541246630598587074810",
-            "-1623395548149665302699111049897215",
-            "-1192580008134980600742905854055406"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1236661467304426090883166445264402",
-            "-371744076376489711195615032257743",
-            "2054398363329009304225110885914248",
-            "2282254142354611780924986446846003",
-            "1335098616305012872647529459955419",
-            "-2333515867164879976023231383269539",
-            "114078543021693938325750457951500"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "464104358696147522307181233407201836",
-            "528236181487245695215532819816780192",
-            "-49582519618663647096439258967309615",
-            "179810448282591210237518073467287227",
-            "641083621863607981646658838917064705",
-            "-588820141403146033804863670906323881",
-            "-209172547311926173294677521407025768"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "27559909638983289023355911880960481",
-            "-225884217842248648518867386017704678",
-            "179899274801825611492587037729547162",
-            "-645804265572868735329412546507385081",
-            "-182001003702797629603891592835717884",
-            "-196383748000158684449875627005718638",
-            "168348539043763218469877957630344248"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "117107436058598227102369350940703879876",
-            "109883501439450473736462013508285281794",
-            "-101387654941698733435373306911208832174",
-            "120539446302766831060730844387212578122",
-            "36010116834354981290778572290676615335",
-            "70903063265292543021168853120103056998",
-            "110744444106697685492892984617486125322"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "139776289567340167051908795098181848110",
-            "24016711019305619625037775723051412673",
-            "151016471675979627009310128091857241769",
-            "136878330327275804538678500765431659719",
-            "-8175489881016674742304549992648258102",
-            "25386838486740756955389088300546155350",
-            "-58709249744971886150026166430504011518"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-156704989705626079171987231966068215654",
-            "144772934450911580494762210707331833351",
-            "-62369821560188986732383850394596682312",
-            "80247096547059282305305172602938473045",
-            "10035303749721112586071998129175567777",
-            "92716485473901404146553068374146350189",
-            "161388554243068610590428401872902762267"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-17578",
-            "-532",
-            "-29058",
-            "3924",
-            "-4368",
-            "19542",
-            "-9728",
-            "-30043",
-            "8547",
-            "-22611"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-8228",
-            "28186",
-            "27587",
-            "1067",
-            "-14722",
-            "-4268",
-            "19776",
-            "32332",
-            "24421",
-            "-18365"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1997107",
-            "1099651",
-            "-6097698",
-            "-5444647",
-            "2942038",
-            "6725671",
-            "-1283058",
-            "-2877113",
-            "7395450",
-            "-3898388"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "3550186",
-            "1817302",
-            "2814668",
-            "-2514642",
-            "-135513",
-            "5746437",
-            "5761493",
-            "-2082501",
-            "-2006387",
-            "-32607"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1478559549",
-            "-1775015351",
-            "1327820002",
-            "2075513820",
-            "535530878",
-            "1674041100",
-            "38780695",
-            "-618881922",
-            "-1971347341",
-            "271829544"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-140335353",
-            "1487240277",
-            "232889439",
-            "-1753621058",
-            "-1650070658",
-            "-1744522644",
-            "445853726",
-            "1638982616",
-            "-2109491538",
-            "-2031080162"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-316389553",
-            "625297203",
-            "-876965397",
-            "-450718571",
-            "943406065",
-            "1809117943",
-            "-1839008717",
-            "-502467791",
-            "-1208669208",
-            "-640379010"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-183748795627",
-            "277910510532",
-            "142611883754",
-            "444329076374",
-            "347496352230",
-            "-310879611982",
-            "-445269624502",
-            "-110940203350",
-            "414382789989",
-            "-299514156855"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "219186267200",
-            "-45309151531",
-            "361805447006",
-            "429814377541",
-            "185451738517",
-            "-10717952791",
-            "-455894293535",
-            "-331945266020",
-            "434683169128",
-            "-427092008228"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-35787970178921",
-            "126503320146241",
-            "-47160409383224",
-            "59076874352542",
-            "-54218256211143",
-            "131768259093096",
-            "-140694998895085",
-            "139329340093293",
-            "2946344253399",
-            "-11352879480875"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-47865164294131",
-            "18996772330627",
-            "82776417283585",
-            "-48069371769128",
-            "121080667078025",
-            "-69990715553720",
-            "-100167359977899",
-            "-117897159499581",
-            "-37425616598022",
-            "-61336459221473"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "24962306301532",
-            "1342549247965",
-            "69591424177484",
-            "20605092392111",
-            "96006776802363",
-            "103132673511125",
-            "-74474597325207",
-            "123891091031891",
-            "64647602566462",
-            "-33817908700461"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-19023776449141216",
-            "-16616980776723277",
-            "3679087078886167",
-            "667623252211990",
-            "28848050655097494",
-            "35358382636133989",
-            "-5528487795104389",
-            "-35321874926701485",
-            "33150704456809249",
-            "-35673170700881073"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "9170335166359676",
-            "-29152376325887866",
-            "27394714588707273",
-            "-18771083725437163",
-            "-22856196754531896",
-            "30245430696795348",
-            "-11339487304468022",
-            "11795737209688712",
-            "17769114732159794",
-            "-31196892450377756"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-7484701409133991703",
-            "446279878089310952",
-            "-9094698745269615531",
-            "-635203874310126070",
-            "-3266768293641445962",
-            "8803106083192049543",
-            "-3447545194464331596",
-            "-74015213448162434",
-            "-3494919863524679499",
-            "4736749662952258658"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-7862885775777111821",
-            "-2258339050710865419",
-            "8640626623613280261",
-            "1725474079450247834",
-            "718161694297051028",
-            "8263883702397073425",
-            "7878929139943328067",
-            "4794616785419809038",
-            "1846785796472594179",
-            "1051708514867826862"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-290275855847029699526",
-            "2324764544272157302715",
-            "-172538644237854396534",
-            "-1015287161642688964086",
-            "1083861575526398116043",
-            "390994735554610775082",
-            "-1196474592645325657445",
-            "1865761624558280233031",
-            "-1180403655805921813793",
-            "530628104087968783213"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "954362787050824981929",
-            "-667973333297772026679",
-            "-1003872443597233202904",
-            "421871596895408794289",
-            "-1020239034548744444861",
-            "718583437320525106540",
-            "-379642667164083852664",
-            "-202130841394416991102",
-            "-1679999734562681423770",
-            "-1700441593695289764413"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2355756035699002368979",
-            "1788582608362609979068",
-            "976621959978375116033",
-            "551918345212846459001",
-            "2038738001872254112254",
-            "-104241764012041061597",
-            "1815004322628837717025",
-            "-366030095473004039888",
-            "-212188636908643977409",
-            "-2212197067753662412081"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-157029864053237435585940",
-            "580349464450639935626054",
-            "274606111559531706158496",
-            "-271531107176514984144572",
-            "-283271260947610926629996",
-            "-102992963880630057053386",
-            "-151438874243484297766280",
-            "267231765639661935826287",
-            "6412575179562556131083",
-            "-447284995394712155520012"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "82122697814709630556960",
-            "-173674944109113014109917",
-            "-545487196009632239998847",
-            "497347624990809943036106",
-            "-403342273894709674210901",
-            "-408545942001809410098345",
-            "-596472526090909588749503",
-            "-516275782103386775147265",
-            "571758314045638582710655",
-            "-260772039821490889738006"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "151997540068811973892699427",
-            "75525965773514350955041445",
-            "86334400095685499194704768",
-            "-99446476458777770659737285",
-            "-36773561228702583990719229",
-            "114833233963970911445935291",
-            "-53580285648134851613933202",
-            "-107255936095104666984539508",
-            "11411674730798920037840357",
-            "144310491490477735136741915"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "111539513842329174253547474",
-            "134891345910083773681115377",
-            "4883280022715795599398831",
-            "-93475601770663945655266004",
-            "69463434873811940745671423",
-            "123064229528351805775861869",
-            "-150461278409905335393794684",
-            "5582686657272910816484271",
-            "-41856573658852576713916684",
-            "138680097641830104297300861"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-151772029737772929726728403",
-            "35642043181692385372706993",
-            "22083653620753836019287236",
-            "-132784292547512147409668783",
-            "-68828393278683857783700197",
-            "-76581151082179815290212905",
-            "39692809847260519264925858",
-            "100268541173636388889856795",
-            "-84443541640950891574906466",
-            "-56403642052264302619910023"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-28164201707581895339796457396",
-            "18512437657026840590853158320",
-            "-725631091722477987250581723",
-            "12378738266464188323153378043",
-            "1884164162561779726605459613",
-            "27835210450137278935849561805",
-            "-33957093897194026793294927588",
-            "24705712105631658413881985230",
-            "-20752699574766143719562108952",
-            "-25390963174699799711871467610"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-30515239169198036972672053279",
-            "-16714522371588133629312659687",
-            "20089473716367036753654096200",
-            "-26078971629524511775014771330",
-            "17501247017496478629908047849",
-            "-2928637003025782311993801087",
-            "21291695736216764696592795686",
-            "31536521455601627910426594990",
-            "23365283652803300319589541711",
-            "-21352428429043964655987017640"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-1871820427329445630900753275833",
-            "3231762858097800568377706484053",
-            "-7593147127830990171207926819911",
-            "-1328646573449438418929234745911",
-            "7929494242245932071338824047776",
-            "-3966690046585197915967741713421",
-            "-2665638134601027112326964326194",
-            "9493723499691953230194922419753",
-            "-192784910368186052857726341060",
-            "968457352886861403532133623589"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1799593923874731933560217881204",
-            "-4108892863880965470839888494269",
-            "-9288585435136926537350897814111",
-            "5657445890165360156029413482367",
-            "9566538541825565997512161866226",
-            "-8660816252467569077590355298227",
-            "-8872018686223204958393278690220",
-            "2747605566704311318475704614163",
-            "-5898641587743100416084001786515",
-            "-3297823611414655609450786579230"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "3031062632211056878773391959697",
-            "4539157404236993497036298560754",
-            "-89011930344651313281485505381",
-            "6329124475577017732572836547528",
-            "10013839443292860323774055369057",
-            "-1017595829075308067813401189014",
-            "2867701530636012507846076321736",
-            "5049199938873542782410309132373",
-            "-8360248192335873845319826952230",
-            "-8573205393401942663978510341713"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1119504478489389158114715132398217",
-            "-1196861483850018707503891203312216",
-            "1577676525610019362542143335287170",
-            "-828524918774712338254714242796201",
-            "2195372295538823359262046660137804",
-            "-2090592767226916350765817876441046",
-            "1267778113117072331278680263282405",
-            "1899343874503183337053685132483541",
-            "-1547991409572962043085814686518526",
-            "1902230290372078686946188304673897"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "693293489583149990962930554361914",
-            "440506011505476370060528227243171",
-            "-1325383072032732660105399745630800",
-            "917607968990684241788700315356108",
-            "1743560964081196656600523814562949",
-            "-1632234260262962178728375599295415",
-            "-1245497842582367367033445464435845",
-            "-1845276210960982951119705348291628",
-            "-852049233534078951923277630775327",
-            "-1061875438802298101158411197338174"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "662874337110619540246196737572533840",
-            "-646712275200560229865863897728322608",
-            "378197263526199456522160076139313754",
-            "-655367409488714240118815274020981441",
-            "-117363023724417392064609064984193546",
-            "379968998004796503715316062979365386",
-            "581971463075521396879850081437709346",
-            "486590909317284352288769404708849420",
-            "339153058170383739672141264076027632",
-            "368011261202186797510454029551864010"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "611471791995589932000290011287342073",
-            "-238320595795246885451815237904493030",
-            "129885954954066668429052045867305389",
-            "-593881411984223406801058087690854990",
-            "208716878349646304461338632058153168",
-            "294341067601902100416283102151104072",
-            "48828028516396476570316169415440949",
-            "621606094524397617471379378110976418",
-            "-24429954817222979379361646729750851",
-            "174309609239946237584153302119176933"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "38764350872143269830409050492580474774",
-            "-1783556143128429347444249923707622466",
-            "-73796525965417826742774297120572978723",
-            "130398981933491578275105091583750862109",
-            "166691015795481448891415156743596861442",
-            "137059374902539614554733085225910695585",
-            "-52077108529588489247990938655971916018",
-            "91346637728026911154761148563604037923",
-            "33500089399138437200753844820194648392",
-            "-129284621583923871181594899462237973804"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "155321932412457790454079866994618338188",
-            "27813009907673742133398066472232685666",
-            "39272698207745895563541959640721556926",
-            "-122722120683994266643963991712613165291",
-            "-130174397926461656752602397741063391588",
-            "82090308774368119635497681294792018586",
-            "-59839129775569455414641041372080794175",
-            "-24104505156877231797915313008748415591",
-            "-108881215793562491957481808068270876072",
-            "76694630138799355396392615062949976885"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "165547688447137835687250676649889094237",
-            "-163339935116527850906013137286281712121",
-            "-71022445758504577564847869973739799734",
-            "145194176986878243647893329429477538354",
-            "64521796946193208156404560040536806244",
-            "39300237731247748947718794529964696310",
-            "-57247755378136552231880640476421831435",
-            "-46273099289129264614986219324959153834",
-            "-55042141398285192896194894621330572941",
-            "-152341554718452744063215754531967241888"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "18698",
-            "5226",
-            "22280",
-            "556",
-            "8799",
-            "29440",
-            "451"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-23904",
-            "31878",
-            "21043",
-            "7840",
-            "-4061",
-            "973",
-            "-1228"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "2724325",
-            "-4798020",
-            "1908664",
-            "-1806352",
-            "-6499685",
-            "-7280271",
-            "-2257879"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-4011001",
-            "6863924",
-            "-6697732",
-            "-2217484",
-            "1921902",
-            "4699368",
-            "5306140"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-121080047",
-            "1970737025",
-            "177569772",
-            "-675421071",
-            "-412793147",
-            "1025987892",
-            "-1489708604"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2045004499",
-            "539874307",
-            "-1997427023",
-            "1708485386",
-            "541003597",
-            "-2142889980",
-            "-1571929387"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-1277841834",
-            "369437735",
-            "115131390",
-            "1767292952",
-            "-737609351",
-            "-1060380702",
-            "1495387052"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "197387161100",
-            "-254436366157",
-            "286370837399",
-            "19374886452",
-            "-98965142936",
-            "-44474737185",
-            "443205205790"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-11626723519",
-            "446888208290",
-            "385477838312",
-            "269092016708",
-            "-115706867693",
-            "186662180742",
-            "443402603648"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-101903913010014",
-            "-17846116772043",
-            "-127568468992217",
-            "138034513755219",
-            "-22440181460716",
-            "63908344819874",
-            "71092752187712"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-10514368675102",
-            "18576548276665",
-            "11989898233479",
-            "-94964748076982",
-            "-25130417074236",
-            "-12150591292188",
-            "29627314247145"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-128065487316393",
-            "-51607804296775",
-            "9339364520761",
-            "136634838298533",
-            "-51187175560258",
-            "120582565367596",
-            "-113392529877605"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-6014210637334865",
-            "8607066096461461",
-            "24796296381889212",
-            "-21982938527186312",
-            "22830978621256619",
-            "-26845542068057233",
-            "-1207835268472696"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "3833038092952487",
-            "22879010815516439",
-            "35249449760784991",
-            "-17068864041186991",
-            "-26423231151454707",
-            "-3215687274393412",
-            "-23458194802999605"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "3125947421774122944",
-            "-8281228069349294860",
-            "-8475285212132358531",
-            "-5284781313458999470",
-            "8164712809196122859",
-            "1812915631649193077",
-            "4405900031418971351"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "4032410419461492356",
-            "-3461877490707766960",
-            "-1034170339182657409",
-            "-3390159984142309139",
-            "-8014068544953344330",
-            "-2322898039699171514",
-            "-4866093356373866447"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "746866223721616048807",
-            "-1092102356202329139788",
-            "-1546383537243345586308",
-            "-147480023935690463533",
-            "-1613816966398143873591",
-            "-1366145607207253623527",
-            "-1277834349517264956600"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-779628592648894155798",
-            "833551847015048377342",
-            "2350685094213395401616",
-            "-646450799987582052640",
-            "512671457318054258029",
-            "889600361052664942457",
-            "-1281226453859217419451"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-189794651087146365523",
-            "1730990859510508481978",
-            "84730118226610466482",
-            "-2271149966448749710655",
-            "-457693344089241611732",
-            "220532349183084708104",
-            "667161504208011399088"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-84007006749190537913356",
-            "-246149963758082151700698",
-            "58599320110198036377337",
-            "419084729775542661330649",
-            "-414234870389293282071427",
-            "-525262946081080156584518",
-            "136640685388491267545797"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-119294228731180826417958",
-            "8761229936388021822082",
-            "487012390130773891175460",
-            "-311845427865456314818185",
-            "559648900054229910709345",
-            "139393885514427519830624",
-            "107325890167816018081235"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "17089147827907561627837757",
-            "-94429323577754654200100992",
-            "-4473969571146714207261485",
-            "141782659389643845693155915",
-            "-93892358423502207196670410",
-            "-145554766670598055216282741",
-            "37597111607123600576198257"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-137314033837313163998637",
-            "72449797169876132616353909",
-            "-70161038289080296659386196",
-            "-43462961961878972425525973",
-            "42101201201192529980096415",
-            "-81066870591720969078480725",
-            "90267013220354821004402329"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "117713797316457619471160158",
-            "-70167250212359158255102362",
-            "-11552912460279859107138583",
-            "-29885413874861556795770843",
-            "4421888524449146349137592",
-            "104643958570092735443054627",
-            "50425644614078606322832703"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-30334928923978531796147629088",
-            "27288518731802156666631771366",
-            "13824378221071923474948637231",
-            "4644693338626225213907016302",
-            "11634130769035763812486389217",
-            "7684952376163662025235478239",
-            "-33239678106944925691053930083"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-11528961365515593522622576679",
-            "17133737086982694882922251878",
-            "13646045761710072112428841241",
-            "-11389171932161374967609239435",
-            "4257823513423339355354889471",
-            "-28413425236629841784233274651",
-            "39588941214204919522713866880"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1793447129255862870401371387102",
-            "-4521183177824322286238857131690",
-            "-7015296797702626396918062112070",
-            "-8405199754772912051218827051767",
-            "-5847103288844519371863856372805",
-            "-4986004223819988818141294208919",
-            "1152074979591001029103861569975"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-6349141188765631755738960028456",
-            "-2660433342897400293313691984408",
-            "8110414928660755884872240488403",
-            "-3255774704770639692268716192582",
-            "-5624565439076989481811168712985",
-            "8242854258628200994627074750006",
-            "-632483613318590601476620619686"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1906797773505486015084475661167",
-            "1831532006604140257182189698277",
-            "8658935091181123523496177509351",
-            "4083753014008812543656172710815",
-            "-703732616202838478277623562522",
-            "-6578720101664337167243397144316",
-            "-4231412865947716065230260553709"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1481793740573226627257507227084301",
-            "1987274798160197648897728495716203",
-            "-2253699799337436551660654810527205",
-            "-1664891149611323142615003737883555",
-            "-812147342830058889078154049835125",
-            "1133591471991032412967586858920266",
-            "373066807517996728955491798981682"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1308500817719514731390159580539356",
-            "-2472263601229082178453567330649492",
-            "806886383595845079530117586003857",
-            "1483914875922945517574389647107123",
-            "-2447637035834905490061551060827517",
-            "-2584877975554282277356767257919022",
-            "1137264392772462522125091324886529"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-202694815737861835748583337438619141",
-            "-567475487177382119320244018738653105",
-            "240870396569462382448904278424042886",
-            "565877554788860310777372508885337792",
-            "-16105501605830402808140696954471983",
-            "-608678904857721513901782286805392766",
-            "89500838347412802178721155164713004"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-92477909222259270232496020800286668",
-            "-253868659242284214237281896032894612",
-            "-571911363839430504720309156797127441",
-            "-630228046136182620305988015405040527",
-            "-145796823877333917115220895453473596",
-            "-544416500996245714271727684022145559",
-            "62108147716790867959393946884530570"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "30196559748662473034683824360446700718",
-            "-145993220223129636351442638734923612124",
-            "-31744581905865529412669045728747964315",
-            "-42689243253906548960505899054623799466",
-            "-3278727297709430585641819106144408715",
-            "-139194553088228069126405551246144950996",
-            "-18860658848674927408656595634636715361"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "14098620813169356460637219212014489435",
-            "-25133450166458778557679753986808320092",
-            "-10717831626644290242659474112607023736",
-            "61898419746062756560226489821314179510",
-            "19338062857571632481395798424446979882",
-            "-80563484496287165417026379634301213058",
-            "38933787489872054716116934865976579056"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-18244737545312093171930563627683906325",
-            "-69817450526652822027490267764416914485",
-            "-161214969184468418385603069469725822547",
-            "132041756256234747183020020523975575773",
-            "-57875703366203729680850430132447338202",
-            "133741584114580239596914015216689701177",
-            "-104202051211600429556397759132978847898"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-25325",
-            "10828",
-            "-13355",
-            "8467",
-            "-14673",
-            "13128",
-            "-11338",
-            "-7976",
-            "-2935",
-            "28799"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-25899",
-            "15808",
-            "5036",
-            "5817",
-            "21295",
-            "6991",
-            "30262",
-            "-29206",
-            "22545",
-            "14281"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "5139488",
-            "-4603800",
-            "-4322358",
-            "5568494",
-            "2927252",
-            "-2770864",
-            "3950127",
-            "-402389",
-            "-1551328",
-            "4307703"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "1273196",
-            "-6043029",
-            "-2124152",
-            "6239939",
-            "486272",
-            "1367187",
-            "-4466034",
-            "-7300079",
-            "1984393",
-            "3056986"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "389208900",
-            "185157703",
-            "-2134187956",
-            "217215497",
-            "-2063962325",
-            "284328714",
-            "-1798439100",
-            "-1345866522",
-            "-44759387",
-            "1568455956"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-1988645525",
-            "793006818",
-            "-251491455",
-            "247123050",
-            "2046505050",
-            "-1728516425",
-            "-435424560",
-            "-308364872",
-            "-1892211705",
-            "-126815551"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-773671966",
-            "1358683392",
-            "-1755115842",
-            "1643669576",
-            "-878872476",
-            "-1809618284",
-            "-1045892795",
-            "-1775853987",
-            "-1403818658",
-            "482449875"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "241099970526",
-            "514993919499",
-            "-496567360082",
-            "502604322768",
-            "-28679500586",
-            "519917943945",
-            "413447742457",
-            "221064262119",
-            "-391763012706",
-            "-181222719579"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "509145597895",
-            "47721898418",
-            "201713081857",
-            "183700101234",
-            "314513786407",
-            "-33405756748",
-            "-532243541621",
-            "-107548030858",
-            "126151420688",
-            "285956004348"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "116275668335152",
-            "122141214739207",
-            "-63430344564549",
-            "-111832080367574",
-            "112155501448142",
-            "19656387304429",
-            "96601821131959",
-            "57545046918456",
-            "107104563639101",
-            "-59870112678790"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "45356471648224",
-            "14779609611199",
-            "-33962279108195",
-            "-98944840181309",
-            "91625511308220",
-            "-110850158882954",
-            "87916556152463",
-            "80467617162481",
-            "93925586648150",
-            "-113372051519249"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "19606854898583",
-            "-55504890190933",
-            "-15147315545027",
-            "40456424289866",
-            "-6247604760181",
-            "-93639696496745",
-            "-84665878592107",
-            "-100053850686284",
-            "16367469522358",
-            "99753371265059"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "24282640953032762",
-            "10091709048435857",
-            "-21974172647175281",
-            "14073179053430222",
-            "34109384946231056",
-            "5226653906582893",
-            "-33819520810414763",
-            "-22931875185563773",
-            "-24002071163260726",
-            "-1715146803898567"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-30659716847381795",
-            "-15836145091878170",
-            "-30830890473364625",
-            "-25423275503125707",
-            "-15385992609067487",
-            "-27328827163588642",
-            "-26765399453321294",
-            "21083654833354492",
-            "-19809350790025647",
-            "-2472980520466774"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "946065176298096897",
-            "520206069634010822",
-            "-2372009740528541735",
-            "-3605114825675420401",
-            "-4132067089809310737",
-            "705141097139262042",
-            "-7256635106430568358",
-            "-8105301464259245359",
-            "599492648809263584",
-            "4365466939375502140"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "8277129333648717097",
-            "-8448354335880876032",
-            "2913319982453504823",
-            "8736245116433424334",
-            "6387017288276853607",
-            "-4081208528945745050",
-            "46515463897966715",
-            "-1495751169585677679",
-            "-6665852657838015529",
-            "1497421528845365759"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "867602266070578599219",
-            "2247746875415261031076",
-            "1934169958376882247885",
-            "-1983965311174074790761",
-            "994286831208120914465",
-            "-2053360980630830501597",
-            "-352322923068724990708",
-            "-275529843474582648430",
-            "117569307044473834744",
-            "-2057119187357998311386"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-983989144481816608421",
-            "-227041553316359265394",
-            "-2338398780830635151885",
-            "-1425288624511611388041",
-            "-1200460011151461084288",
-            "-37860255133068080397",
-            "168815163262920902402",
-            "-1589043880708207878151",
-            "1999861056072554689170",
-            "-1063012832871660661701"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-934629893504979755792",
-            "1330023560256145633360",
-            "471809371618383733343",
-            "2321922756694883212096",
-            "-1145621103195820184004",
-            "432986056770166636184",
-            "527912618672815906694",
-            "-1383597906408951487454",
-            "-1840681975964590350984",
-            "1003431919766458755951"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-295917082043583082770621",
-            "-231343988449013068326631",
-            "5312383381819468949750",
-            "-139157207556611762942758",
-            "-241655483652404463403757",
-            "-512476477719184343596604",
-            "599410803946810481042938",
-            "67078249271685046714164",
-            "409870524862445838681667",
-            "-198986259949659924965247"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-278030681373064235595749",
-            "393693012596137044946808",
-            "113099188405109327204683",
-            "415775568903274402438459",
-            "-42076558072135973151428",
-            "-219378272136268135495431",
-            "-582613624074409026792710",
-            "191194427072366781075751",
-            "-9835457748214809790370",
-            "442340177819471571537141"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-125407723627032808185149189",
-            "-127693057085441986254509099",
-            "143049524315591523657757604",
-            "66172074121241277336416638",
-            "105043654403595832965542333",
-            "88321001961584231003626866",
-            "43148804784313926260363839",
-            "33183564004779395803780452",
-            "-145197017290377600759079842",
-            "119167929014336096222821000"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "119039071826650750074654630",
-            "44751775197664106490961349",
-            "27864406843200354265918393",
-            "15658656552850314500730985",
-            "-8220185761405769037321341",
-            "-83569483397839034074232516",
-            "-15999238535942008358971638",
-            "51943353221378823545548335",
-            "124460320105770697840371762",
-            "96188240730380539592133999"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-23740546198484978874875407",
-            "76636632473705803978381047",
-            "-56311328440996031370265536",
-            "-17243365633279424695862822",
-            "-86114647089246738996946962",
-            "77779733094924174077783969",
-            "-154377399990419141152689913",
-            "-58108558577026614888610010",
-            "32011657995884029676678558",
-            "-85849178273273349349099772"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "38268503482208460783689168776",
-            "415498958203045688529744846",
-            "-5469243189225899466540717631",
-            "-27069951860473838447007129302",
-            "2300819963695030297957821979",
-            "27013864454418030545712879052",
-            "33795947339603501913179687623",
-            "-36867304093401804903210992872",
-            "6652565972383263112675657430",
-            "21252184018008067722844465790"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "20488449679781423383625400864",
-            "28945181199727711698700316165",
-            "9535784301505998719738045771",
-            "-20854663557065706429017034430",
-            "-8496482734431467304571929654",
-            "39529776626237782521053868212",
-            "20282963743253661057874523422",
-            "39168299995389261713687626653",
-            "-2895774161826797358583901454",
-            "27415786790395091445855072594"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "7274372610033635352026015117499",
-            "-9390827953122518631957223639932",
-            "-2203836129140192889937266167905",
-            "4596600214642310892345897847127",
-            "983389576577548413649282888500",
-            "1964366100910371172669585857215",
-            "-4168439792076922929733693975481",
-            "3161618514384549987863457101037",
-            "-7790441321891779327083714442512",
-            "-7686467965572840837470847326318"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "9529887427430029315427723731097",
-            "4336235122315854607986015683663",
-            "-9706927952229870397920454025649",
-            "4499727370692865250957373478909",
-            "-5923209179547863758996820315917",
-            "-2626628904315332468993978106025",
-            "685916912461697873229704570250",
-            "-2838726730006480465962589525945",
-            "2039415276453860859795422056351",
-            "7628942068105897131623029254615"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "126535036553237060539012806767",
-            "-6939129554517585745715778319177",
-            "-7532363115381746277033981571367",
-            "7225306379513685172919544982624",
-            "2081180225728056445004841883009",
-            "6331729734153410979163746567493",
-            "5450234392691226980537948053828",
-            "-3339385174687947070096507831241",
-            "-6555844461598841325077996060011",
-            "9279765521180487317778800396224"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2228023644252832655241598402411269",
-            "431676701798775425411616196133933",
-            "478260014584588677437872352249827",
-            "-1507262382979849604564706747863757",
-            "-2288462503836870608309925185139281",
-            "49393515288688670462360817470707",
-            "-2579210515571147629042989663475866",
-            "589507628712335934139197077166366",
-            "1989953354399049606431153717140929",
-            "-965660095005622252483438158567899"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1816053260927088757790173812582767",
-            "-2405480415192625953224616207989887",
-            "-2328044646297041482107281923018610",
-            "872987268389289710890938214776251",
-            "643667272856490093246696929059356",
-            "2135937810867387131247124235309141",
-            "-348035586025203024239919226158367",
-            "1200248021086499011518529585918610",
-            "2026575827504135717840864217744664",
-            "-1601765059510950727183880983778417"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "65074355550728584791094991091725510",
-            "655697096560546628903998665713057646",
-            "-526498334932676728875521670389483820",
-            "-660406393116184719913940975963998661",
-            "198613257448920495951253934679652556",
-            "-43713779768026581579783258854735948",
-            "24173852238556377483338028432771484",
-            "-323536680150552559099100992362365559",
-            "216972493779019710120712154999597849",
-            "391545022377807490738436750954965632"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-128389779235154808800484297421230508",
-            "491001613177916842185576260455747135",
-            "-455096123184868191344797938977008190",
-            "-309905590996917800177765369517052165",
-            "349603248086460094879044594595289453",
-            "173998676594990878495537914769309496",
-            "580673547960002977806631871571859052",
-            "304595872857331938936691935503967494",
-            "-309341788503071907892541600073298273",
-            "-445388828339388242207829894494395187"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-116759118799696740987833268006312595507",
-            "-240339187668656185170580579099921345",
-            "-165524819667082744814917029626210589845",
-            "112546391769223555027822608825303955489",
-            "-48744565225770459292490161985480679384",
-            "-61852298378918957927732680541183991273",
-            "-109815699785003222394734941309206527496",
-            "-161541054014304007303713671841308424373",
-            "38232801342956757143716333070831819830",
-            "-82876982197717752657894986064058509459"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "166626734583125926562909642736739648863",
-            "-537561525487190105228039554746904245",
-            "56724835995658384592515263322742572769",
-            "154738535117659769768747849261742373987",
-            "133841382783265265669107205599295242333",
-            "-82481830171752743723415208240895428708",
-            "47401574357301211579457100619126454320",
-            "101450166334449946734731337888765885526",
-            "-9655734409491446777009001964705514650",
-            "-20474375954705981387014226963404713903"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "97166129096528442889485736329241954705",
-            "-20654655171391656743269829102430663484",
-            "-19774868324035406536117826166021377349",
-            "-14595360169302341242602534087132194253",
-            "-77171889502077963021661942682977180668",
-            "-67805573373674104708253116675406619851",
-            "107903125463174461399865488130215282736",
-            "13666179504242759743615908229099766154",
-            "-14923042555307260112864102940917241528",
-            "-93735255641317514829426639104109826896"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-15637",
-            "-21826",
-            "23207",
-            "24299",
-            "9996",
-            "18466",
-            "7067"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-26781",
-            "22205",
-            "-30862",
-            "4191",
-            "22380",
-            "-31397",
-            "-16113"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5606512",
-            "-841159",
-            "-1722865",
-            "-7412802",
-            "3421093",
-            "1404395",
-            "1763678"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-4174091",
-            "-6797376",
-            "-6735178",
-            "3654374",
-            "433672",
-            "1994930",
-            "1820130"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-27695193",
-            "235417726",
-            "1925960030",
-            "-1068170333",
-            "-1618156350",
-            "-317495919",
-            "1423560212"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-613673600",
-            "875021835",
-            "1453808997",
-            "1717180769",
-            "1580762908",
-            "1840132086",
-            "-1345743252"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "582856351",
-            "1284574124",
-            "340320670",
-            "-1092859214",
-            "1110297876",
-            "1357226248",
-            "1402761903"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-3179119623",
-            "450280234735",
-            "-246304555798",
-            "-119827255352",
-            "-525274364087",
-            "-230257922796",
-            "256828899002"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "172087714641",
-            "446734015461",
-            "215626082740",
-            "310099426632",
-            "262400844124",
-            "-403709578552",
-            "-543955348408"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "79497412466729",
-            "-17627606697345",
-            "-56306219857785",
-            "-44419610515947",
-            "-10505875477448",
-            "-137201986324719",
-            "-41490578530344"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "87785849879213",
-            "72153641766797",
-            "81344597122488",
-            "116608220424101",
-            "120127927299953",
-            "91392864468246",
-            "789277742054"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "16742530979330",
-            "-27276173304601",
-            "112787046376927",
-            "80422014882468",
-            "-53996799818821",
-            "-51482063936845",
-            "-109285996873057"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-27011971722513841",
-            "-25715520475567957",
-            "-31692200074647251",
-            "19797016206092429",
-            "13033529853072966",
-            "-34190512535950112",
-            "21391090647858827"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2689551968658208",
-            "-11978754119332225",
-            "27943059826706703",
-            "30925593314872225",
-            "-25299415665884227",
-            "-6588871840929638",
-            "-13529612932491138"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-5877424150753455644",
-            "-750157543599527648",
-            "7844548247743823168",
-            "1983390184771773250",
-            "8109668973322170403",
-            "4662100181419928346",
-            "-7990733746417221683"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-4001316145812913855",
-            "8636276014947384575",
-            "255439123904346461",
-            "-5910657878241983749",
-            "-8574194995013797995",
-            "6656912349600694116",
-            "-153848629100633274"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "251402997439201416147",
-            "-773260098260956584464",
-            "-219271115207772204546",
-            "-1036039623941759511644",
-            "359482472533162316496",
-            "1965913949245283018894",
-            "599718122444765908168"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1438319238194982234339",
-            "1577759903359206474839",
-            "188186678199824158300",
-            "1276273466028897015455",
-            "-1836059768603829828246",
-            "-571809172339201000757",
-            "-1423862618055329967277"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "1054493543273151908590",
-            "-996798431306463901700",
-            "1030912998214022157210",
-            "1165909344715451535690",
-            "1678758991439476296198",
-            "-1261232816117225764157",
-            "-275535923846867412400"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-265478781031709465954466",
-            "-45885532800194657389599",
-            "47123250342923949029333",
-            "-28918098710716253013235",
-            "-216245678184360771226258",
-            "-67592927029058001825983",
-            "-216606971904693341187546"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-454834495768691198335625",
-            "-121587423919595203596630",
-            "-180702613619856867200053",
-            "-586233612775783081876233",
-            "-146313510918473805475897",
-            "-19249352342706744822274",
-            "602537232274909092052368"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-138817970110646913589715549",
-            "71212874681781732508199238",
-            "-36634575975569063090531384",
-            "-118838660864234798642972931",
-            "-63677435476346500972940088",
-            "-143253302639820088137695781",
-            "-10005431182625326908184063"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-24132845688739832600198664",
-            "70223772618132296366621411",
-            "39697053813238829872031989",
-            "-4463405036654040634416246",
-            "-114850114696918748689370315",
-            "24197714526405477903473970",
-            "-85613480517918645906993903"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-78615821810256843179885264",
-            "-9435616174371737446306696",
-            "14724235985325181617831683",
-            "-77554225473063349798518023",
-            "-151687049843944286803049399",
-            "152830772381840371720809534",
-            "41342447912435620711044487"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-7452626331051061693783872103",
-            "-37477886858762005988951878072",
-            "29024564721311845466178480817",
-            "27253762906471645828276940493",
-            "-19788635697675024252549748007",
-            "33227312025585737614263740454",
-            "-37713444931406134334378281082"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-25886791622624942457173736636",
-            "34370751906575221175682318842",
-            "-9932886803302690926326494218",
-            "3324237332180497322466960837",
-            "21125203591871926273778796597",
-            "-11276967068824629033564949936",
-            "28441370093039134290858059521"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "8912358001421025895832248632442",
-            "-8916798266948379553115396290654",
-            "-161154141964359329876263021833",
-            "3858086459715378537257910522289",
-            "8040021746182360241076098633516",
-            "4716833692114616471008198034491",
-            "3496285339125640710658712687020"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-9184049173255469554998225870729",
-            "-1938356198264242814346866467899",
-            "-4206826697895630793180053762195",
-            "-9497517245200463036658297067684",
-            "-5584086501913874255219443240156",
-            "8412140854426525037463120473138",
-            "-6042832331708829719042645761969"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-6643586848533296755722567177838",
-            "-1193404893030123421103724263326",
-            "-7351808613718633597834537706852",
-            "-4546872325918455995201693474980",
-            "5044513193984398500316947717350",
-            "-3564202300291159147721754279587",
-            "9899326223400708541507662547701"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "2538490507550203557654476537964592",
-            "-171852815793316039580834325499002",
-            "579673614387874228055248480157807",
-            "1547316751704920851604992499434244",
-            "82956532861960233155706332616871",
-            "2270532599099227110701079190556481",
-            "-1551256727215408667915785904404011"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-1697323961096836989990113960348683",
-            "2269492088271616903476594268476027",
-            "563384931675005850944800674271399",
-            "1829983204109953557442975861814188",
-            "-2099108441853345032440560303311823",
-            "-1159901622227230738337097223322335",
-            "1320399948477362419558701661162682"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-227649207549335409555288103485379868",
-            "541380090188013381867176032991003854",
-            "259040738101837697543772263422611758",
-            "468607824887048977270254889483333053",
-            "-37414275284716090078813150850969270",
-            "414632729703080747958410749710577970",
-            "-628951504936585588032719800558474149"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-585201720045860251224192209434417167",
-            "468582923778969233979378862262684223",
-            "134642897337460953327600517844593153",
-            "36157897287467373309609536222700125",
-            "42661449938741236454803304780412295",
-            "212096786713676119368154634300273677",
-            "585017229375111099843942749410082953"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-138591685930594567129919412699083355323",
-            "77060413350994913049260494214760663038",
-            "39700904836694418018645309917065762876",
-            "-31664403115710800671259751306315806980",
-            "63928998864039165846312590158916247833",
-            "-3586180789611960233999050211148582684",
-            "-42878742931457980860298222400389073217"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-102158662182543310745650009612358481115",
-            "-110662400233487451872440612242183030235",
-            "-4734079005823009383561681338545373884",
-            "25428205135817899705171309423993396942",
-            "119935163858170485692044331984703633688",
-            "27795979506302295159346827031425803891",
-            "-17630802775799110077215936154218710903"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-167820728718740728757244841820454776505",
-            "-95721966128938572947248972085749061555",
-            "140529351854457382631585268999194010048",
-            "-169071957026901707361219133333712549941",
-            "-70939221559844798247914114191797953094",
-            "-127614892614854677120213423457262257204",
-            "-102794811166159877868688547277286760364"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "21474",
-            "4094",
-            "16234",
-            "-10475",
-            "-25906",
-            "-12657",
-            "13211",
-            "20482",
-            "29407",
-            "-3604"
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "9720",
-            "-23643",
-            "9540",
-            "-23720",
-            "31318",
-            "-25292",
-            "18536",
-            "-9162",
-            "58",
-            "-7786"
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-7627572",
-            "-38899",
-            "2443108",
-            "-438758",
-            "-2210056",
-            "2273095",
-            "3114432",
-            "-124491",
-            "-1605021",
-            "8009315"
-          ]
-        },
-        {
-          "name": "f3",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "574992",
-            "-1257531",
-            "-2806474",
-            "-3352205",
-            "2915457",
-            "-7014958",
-            "-7579817",
-            "-2215757",
-            "-576189",
-            "-8360149"
-          ]
-        },
-        {
-          "name": "f4",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "-2041265396",
-            "732584234",
-            "-1999454822",
-            "1704993828",
-            "-210935878",
-            "929286432",
-            "1109525853",
-            "582363395",
-            "-1825179353",
-            "1409680841"
-          ]
-        },
-        {
-          "name": "f5",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "1991977558",
-            "1762056301",
-            "1455216951",
-            "1449185192",
-            "254303971",
-            "140252798",
-            "935225387",
-            "1899985780",
-            "-927824213",
-            "-208960670"
-          ]
-        },
-        {
-          "name": "f6",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "1480625771",
-            "1040969656",
-            "-1003085364",
-            "-553744456",
-            "1343292649",
-            "-325165443",
-            "-1346706809",
-            "-965803077",
-            "723994410",
-            "-20304136"
-          ]
-        },
-        {
-          "name": "f7",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-101818947634",
-            "-229200189261",
-            "-424288334493",
-            "227262504132",
-            "432555641000",
-            "328751277087",
-            "50785160524",
-            "387280003539",
-            "323702572325",
-            "-130440892777"
-          ]
-        },
-        {
-          "name": "f8",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "285258640838",
-            "-31233562378",
-            "413535063358",
-            "366447174903",
-            "51794529119",
-            "81104642011",
-            "-229146846972",
-            "-500253706209",
-            "26427555726",
-            "238540328738"
-          ]
-        },
-        {
-          "name": "f9",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "72984542244109",
-            "-85349566014644",
-            "-61750715247480",
-            "-107963169778383",
-            "-72064927212019",
-            "74634683457234",
-            "-5692709274261",
-            "-137801733360366",
-            "66863319822840",
-            "53790391904569"
-          ]
-        },
-        {
-          "name": "f10",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-30506162400564",
-            "44134792179061",
-            "43208822949445",
-            "116111507835088",
-            "-52652763068808",
-            "30227545743701",
-            "54132435978158",
-            "-84979416074353",
-            "-77767629770125",
-            "-49700250599015"
-          ]
-        },
-        {
-          "name": "f11",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-33646284874231",
-            "-39843156046137",
-            "135855350625826",
-            "67173686029441",
-            "47373973603503",
-            "-81315792116685",
-            "126362930268105",
-            "62326866041404",
-            "-79917419899133",
-            "116346318505097"
-          ]
-        },
-        {
-          "name": "f12",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-17623564370335172",
-            "13940102868728695",
-            "31159892605228020",
-            "19288139749976327",
-            "-32162377831099808",
-            "-25334882778439881",
-            "-9293849274157177",
-            "25753846620057242",
-            "-2715500844487831",
-            "17297835213572781"
-          ]
-        },
-        {
-          "name": "f13",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-24802265556783267",
-            "-1071851274851707",
-            "-20708121978765252",
-            "21106785059579409",
-            "895452156504814",
-            "-17439295017291261",
-            "-29860734942289352",
-            "-24366392879871907",
-            "-24844781251317766",
-            "5691042499081415"
-          ]
-        },
-        {
-          "name": "f14",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            "-950656153293958588",
-            "-7026895800290111295",
-            "-2906486337048393634",
-            "-2487298974163906537",
-            "-7240801780393004497",
-            "-5928987398455158527",
-            "91252511169998609",
-            "-4434565223927059941",
-            "6114237547594359253",
-            "-5649241382570014194"
-          ]
-        },
-        {
-          "name": "f15",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-9125944744613843645",
-            "2767912703851717499",
-            "-5594414080371870722",
-            "1326878363883364298",
-            "6250061466047884457",
-            "4167357360257738660",
-            "3185444479792598034",
-            "2850893211432323540",
-            "4099400621617587983",
-            "1911788567774553475"
-          ]
-        },
-        {
-          "name": "f16",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "2243798170232923011194",
-            "1260790852369524872646",
-            "1926129514370913291084",
-            "1923482934016917609948",
-            "-1337597225338052576342",
-            "-1396976913710878087379",
-            "1760383914304461201041",
-            "-2084424105474946896583",
-            "546847183858239970168",
-            "-950422829529740640046"
-          ]
-        },
-        {
-          "name": "f17",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "2278561335636612407116",
-            "2226551432527285815529",
-            "1102614999141365247364",
-            "282444931594177029536",
-            "1707175857213323708724",
-            "-1813457685182877716617",
-            "1969563893365610364950",
-            "-1294229647104229980192",
-            "1058028980431521243786",
-            "1425804620843155435443"
-          ]
-        },
-        {
-          "name": "f18",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-666605901201678736091",
-            "2294247840458377820087",
-            "-120100005268248092109",
-            "-2117030120296482991359",
-            "-936538133650490467428",
-            "1909556929153544496029",
-            "668148430777958474013",
-            "1300546260152428176254",
-            "-1307847030795641403330",
-            "962024918692270891085"
-          ]
-        },
-        {
-          "name": "f19",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "429007353965964812441246",
-            "-539416061647283176800407",
-            "-246119986866263363195168",
-            "519288706159858079097852",
-            "145290868494128799776491",
-            "435391066127563014503225",
-            "-212517380359649480302803",
-            "229639965616877780412338",
-            "-228549196983767607874750",
-            "254322220652598819404701"
-          ]
-        },
-        {
-          "name": "f20",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "302744770146464834277007",
-            "349890188007940826732505",
-            "-395767415302716050551365",
-            "-55506738483590549708985",
-            "-42546607637771046763757",
-            "599890205870578843548554",
-            "-566080596849854240867084",
-            "240819660280603920408014",
-            "490355076012318604086830",
-            "-444452608521493383189339"
-          ]
-        },
-        {
-          "name": "f21",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "140098423234498101984955781",
-            "114972555620228418385387046",
-            "-103855128687529946029391332",
-            "-56453596465478079539961341",
-            "112899417755966489798807822",
-            "92479416756872049033014234",
-            "-20220375538499957175667596",
-            "49619147776130236286406382",
-            "75868169169602577596893114",
-            "-33991855971785669167684812"
-          ]
-        },
-        {
-          "name": "f22",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-27955923849772806651093661",
-            "-15134268062501921536631099",
-            "-76180691187952624554132166",
-            "8417609600056713913269682",
-            "122210737333544046425988875",
-            "-8255971110072598553761320",
-            "72059712120402848706275333",
-            "136669805857501664860962453",
-            "117226067843670223572552823",
-            "9538509353520989293188292"
-          ]
-        },
-        {
-          "name": "f23",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "140326260020124618484882670",
-            "-7604232162274599406456263",
-            "-37578322955437058565218623",
-            "82251242821235569071412696",
-            "48934521009186759426554144",
-            "-111502425314556830584865049",
-            "143399285732546087389279250",
-            "-145031030627834093577440455",
-            "-56753812486185622944448939",
-            "-131020484598181539722605940"
-          ]
-        },
-        {
-          "name": "f24",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "7163957691918374413440392122",
-            "29895408949428293949825637565",
-            "24953244787599080815469023689",
-            "12933037616695046483291587011",
-            "12911061711671395434197711654",
-            "-662465023864870915737125277",
-            "32902737578296234199724114196",
-            "-13332149788556638691010135470",
-            "28732116950622282825950924835",
-            "-606082615276279539679739878"
-          ]
-        },
-        {
-          "name": "f25",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2225441768919818543256115590",
-            "36300525663713292309356899587",
-            "22146605949936394498917396829",
-            "-13799763611538096768550340984",
-            "13697106267730772282848050012",
-            "37987370502999491375497665834",
-            "-15959212476158770181464939730",
-            "37740896499376085097100094638",
-            "-3277570747229261911544243044",
-            "34646859779346958641044018113"
-          ]
-        },
-        {
-          "name": "f26",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "8464727847598438214667266343191",
-            "3659092136516017614153405697408",
-            "8898836896743628102604107262318",
-            "-5124678781048461345216331096076",
-            "7048310126754458455427182472252",
-            "-7485149236907192851539148176189",
-            "4765944987612723450221212104859",
-            "3507852604123913333443796199231",
-            "-3638691289771499903484086224708",
-            "-1548294157076139554924261118715"
-          ]
-        },
-        {
-          "name": "f27",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "1960248254240505083559553622556",
-            "6334649991475602141352059045232",
-            "5429973568679996304865347312737",
-            "-5574768356761641457841827808332",
-            "2921634229104833962007853636995",
-            "6645606916555794304028632924702",
-            "7402711760974614198662134839264",
-            "-2430215409038042282074825546118",
-            "9189456250491239952337287624422",
-            "-6746525342617036236303085693943"
-          ]
-        },
-        {
-          "name": "f28",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "-2303252604266546830450692395647",
-            "24931561165839460953255704242",
-            "3539774568243302781625620724843",
-            "-4119755165665461319885896453094",
-            "9980798001735069049033995442687",
-            "6400453710768026204203981933498",
-            "-1785561568444900500617881894975",
-            "-1238657151175445676210732724686",
-            "-4115303461735084227982174922353",
-            "-4830151905286143893643036559970"
-          ]
-        },
-        {
-          "name": "f29",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-744732514813865310675102410677837",
-            "586923153993520038833541626305861",
-            "631405070127015389249055779739635",
-            "2375722591461493864257181946361349",
-            "536327416123747764992062327728379",
-            "4403250929897292075500020549198",
-            "-920102429093431209270145990206427",
-            "-1943957685901230324468842397328959",
-            "-1793159792601568795672835117263773",
-            "2539832186764726126109095059589925"
-          ]
-        },
-        {
-          "name": "f30",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "1736943855683500361344260536843977",
-            "-1041915987085848668127887646443139",
-            "-2073351044084729515377756324458994",
-            "-2499860712727710930829417979309376",
-            "-1334132038144948687896176896558215",
-            "2497357047334342837216894037461981",
-            "-2593640175489681036725320634980356",
-            "83143781366050188466245498529346",
-            "-1907502149335575039303599318337661",
-            "769063293620504337906197233553371"
-          ]
-        },
-        {
-          "name": "f31",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-250745229891973039581681177880223505",
-            "327446904412556324074846927736374445",
-            "-549111820347488138618064952270999012",
-            "-107667493114547862984588921499141796",
-            "-213442200532407781713670495439019398",
-            "-357538486078878970354893736102694429",
-            "556639003636036852879832060230162340",
-            "-263609850789709040712893190708950606",
-            "83507483892195138402414967192218438",
-            "122845115500690774528208372788074092"
-          ]
-        },
-        {
-          "name": "f32",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            "155941392458135251949747004728456096",
-            "-351841600639304120253871824228008989",
-            "13489132228213437891031310407260140",
-            "98346439010414420839370528660894148",
-            "110095662267504106346877402686062417",
-            "272056686592458102197893958630607521",
-            "-568455603353918918719268251254453391",
-            "-641181026054843530064046004084619896",
-            "-153598039697896424251301260354494095",
-            "-238169729901866634377216907979943085"
-          ]
-        },
-        {
-          "name": "f33",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "-76486506229583148953575426031378420083",
-            "-25268246003138515244204194206040713884",
-            "151680852047855885899827416129131343552",
-            "-65868597846063019193194432937954865449",
-            "-37353304147507335221409678836410716004",
-            "-83375093114704443137943855826794265870",
-            "58765750477038687599983055893883073980",
-            "-124247461021880357230108144628851373656",
-            "-97168006373071667635001937044389371121",
-            "147332252855265140513988431868146207163"
-          ]
-        },
-        {
-          "name": "f34",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "-93004622235567469002573559852323599733",
-            "-136486146006693484453265708648174772555",
-            "50333349154635707168287760155624850500",
-            "56065748751155225550881020072304819143",
-            "-89047403980608497862076968023015862559",
-            "-138188932216419239057464674728657893212",
-            "73805817848460887264703472962238324754",
-            "-146887621381330685164768807944413153241",
-            "-58194523976849290302949585080581301830",
-            "-147081260537816177520155637200701099095"
-          ]
-        },
-        {
-          "name": "f35",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "-40110048976612650804598426597711067016",
-            "124144731433352682852630636540845469156",
-            "145245442856314145141703280651554450780",
-            "-144190927886671777348422824785547904228",
-            "51752695865288273345113477117624659857",
-            "147665067149574600679327527424233686202",
-            "51752916559949464310444304180016487848",
-            "65187705658195518441807850839061980569",
-            "-132615731354653260112463459795520015874",
-            "-16458882186479214359093418885286436364"
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/test/arrowjson/dictionary.json b/test/arrowjson/dictionary.json
deleted file mode 100644
index 2307f3e3..00000000
--- a/test/arrowjson/dictionary.json
+++ /dev/null
@@ -1,422 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "dict0",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": [],
-        "dictionary": {
-          "id": 0,
-          "indexType": {
-            "name": "int",
-            "isSigned": true,
-            "bitWidth": 8
-          },
-          "isOrdered": false
-        }
-      },
-      {
-        "name": "dict1",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": [],
-        "dictionary": {
-          "id": 1,
-          "indexType": {
-            "name": "int",
-            "isSigned": true,
-            "bitWidth": 32
-          },
-          "isOrdered": false
-        }
-      },
-      {
-        "name": "dict2",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": [],
-        "dictionary": {
-          "id": 2,
-          "indexType": {
-            "name": "int",
-            "isSigned": true,
-            "bitWidth": 16
-          },
-          "isOrdered": false
-        }
-      }
-    ]
-  },
-  "dictionaries": [
-    {
-      "id": 0,
-      "data": {
-        "count": 10,
-        "columns": [
-          {
-            "name": "DICT0",
-            "count": 10,
-            "VALIDITY": [
-              0,
-              0,
-              1,
-              0,
-              1,
-              1,
-              1,
-              1,
-              0,
-              0
-            ],
-            "OFFSET": [
-              0,
-              0,
-              0,
-              7,
-              7,
-              20,
-              27,
-              36,
-              45,
-              45,
-              45
-            ],
-            "DATA": [
-              "",
-              "",
-              "kfii3eo",
-              "",
-              "\u00f4eh5\u77e2\u20ac\u00a3",
-              "wa3fdmj",
-              "3\u00b5i\u00a3146",
-              "eo\u00f4rp3\u00b5",
-              "",
-              ""
-            ]
-          }
-        ]
-      }
-    },
-    {
-      "id": 1,
-      "data": {
-        "count": 5,
-        "columns": [
-          {
-            "name": "DICT1",
-            "count": 5,
-            "VALIDITY": [
-              1,
-              0,
-              1,
-              0,
-              0
-            ],
-            "OFFSET": [
-              0,
-              11,
-              11,
-              20,
-              20,
-              20
-            ],
-            "DATA": [
-              "n6\u20ac\u00b54g\u00b0",
-              "",
-              "o3\u77e2kbr2",
-              "",
-              ""
-            ]
-          }
-        ]
-      }
-    },
-    {
-      "id": 2,
-      "data": {
-        "count": 50,
-        "columns": [
-          {
-            "name": "DICT2",
-            "count": 50,
-            "VALIDITY": [
-              1,
-              1,
-              0,
-              0,
-              0,
-              1,
-              1,
-              1,
-              0,
-              1,
-              0,
-              1,
-              1,
-              1,
-              1,
-              1,
-              1,
-              0,
-              1,
-              1,
-              0,
-              1,
-              1,
-              0,
-              1,
-              1,
-              0,
-              0,
-              1,
-              1,
-              0,
-              1,
-              1,
-              1,
-              1,
-              1,
-              0,
-              0,
-              1,
-              0,
-              0,
-              1,
-              1,
-              1,
-              0,
-              0,
-              1,
-              0,
-              1,
-              1
-            ],
-            "DATA": [
-              "-2147483648",
-              "2147483647",
-              "2063303031",
-              "575556936",
-              "994232893",
-              "-733018692",
-              "-1869839205",
-              "818048194",
-              "-780203826",
-              "1956041779",
-              "1352257839",
-              "-411979330",
-              "-1676682633",
-              "-284358770",
-              "-1409435091",
-              "722395458",
-              "2117191004",
-              "-1448425086",
-              "-1128563576",
-              "-1190200669",
-              "1780667813",
-              "-987872595",
-              "-160215270",
-              "-2042614145",
-              "-801319359",
-              "940981753",
-              "-1432601950",
-              "-546534432",
-              "970337383",
-              "319587202",
-              "494356019",
-              "1832436202",
-              "-932834552",
-              "1463915583",
-              "1779474803",
-              "253308913",
-              "1534215558",
-              "1946313834",
-              "87626535",
-              "-2043979004",
-              "1625504442",
-              "-1819229860",
-              "-176171291",
-              "135039336",
-              "-836907545",
-              "792617942",
-              "602157568",
-              "81724808",
-              "103096742",
-              "282026629"
-            ]
-          }
-        ]
-      }
-    }
-  ],
-  "batches": [
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "dict0",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            5,
-            9,
-            1,
-            8,
-            0,
-            8,
-            5
-          ]
-        },
-        {
-          "name": "dict1",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            4,
-            2,
-            2,
-            3,
-            0,
-            0,
-            3
-          ]
-        },
-        {
-          "name": "dict2",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            8,
-            44,
-            46,
-            42,
-            11,
-            26,
-            15
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "dict0",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            6,
-            8,
-            2,
-            3,
-            8,
-            4,
-            9,
-            2,
-            4,
-            8
-          ]
-        },
-        {
-          "name": "dict1",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            4,
-            2,
-            3,
-            3,
-            4,
-            1,
-            3,
-            0,
-            2,
-            4
-          ]
-        },
-        {
-          "name": "dict2",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            1,
-            38,
-            40,
-            32,
-            19,
-            46,
-            30,
-            25,
-            32,
-            28
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/test/arrowjson/dictionary_unsigned.json b/test/arrowjson/dictionary_unsigned.json
deleted file mode 100644
index f6a61dfb..00000000
--- a/test/arrowjson/dictionary_unsigned.json
+++ /dev/null
@@ -1,323 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "f0",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": [],
-        "dictionary": {
-          "id": 0,
-          "indexType": {
-            "name": "int",
-            "isSigned": false,
-            "bitWidth": 8
-          },
-          "isOrdered": false
-        }
-      },
-      {
-        "name": "f1",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": [],
-        "dictionary": {
-          "id": 1,
-          "indexType": {
-            "name": "int",
-            "isSigned": false,
-            "bitWidth": 16
-          },
-          "isOrdered": false
-        }
-      },
-      {
-        "name": "f2",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": [],
-        "dictionary": {
-          "id": 2,
-          "indexType": {
-            "name": "int",
-            "isSigned": false,
-            "bitWidth": 32
-          },
-          "isOrdered": false
-        }
-      }
-    ]
-  },
-  "dictionaries": [
-    {
-      "id": 0,
-      "data": {
-        "count": 5,
-        "columns": [
-          {
-            "name": "DICT0",
-            "count": 5,
-            "VALIDITY": [
-              1,
-              1,
-              1,
-              1,
-              1
-            ],
-            "OFFSET": [
-              0,
-              7,
-              17,
-              26,
-              37,
-              45
-            ],
-            "DATA": [
-              "nai4kkd",
-              "1\u00a3n\u00a3\u00a336",
-              "2f\u77e2wei4",
-              "f\u00c2g\u00b5\u00b5m\u00f4",
-              "\u00b5r2bkd1"
-            ]
-          }
-        ]
-      }
-    },
-    {
-      "id": 1,
-      "data": {
-        "count": 5,
-        "columns": [
-          {
-            "name": "DICT1",
-            "count": 5,
-            "VALIDITY": [
-              1,
-              0,
-              0,
-              1,
-              1
-            ],
-            "OFFSET": [
-              0,
-              7,
-              7,
-              7,
-              15,
-              23
-            ],
-            "DATA": [
-              "bor21pg",
-              "",
-              "",
-              "erohj\u00c2d",
-              "5\u00b0jogf2"
-            ]
-          }
-        ]
-      }
-    },
-    {
-      "id": 2,
-      "data": {
-        "count": 5,
-        "columns": [
-          {
-            "name": "DICT2",
-            "count": 5,
-            "VALIDITY": [
-              0,
-              1,
-              1,
-              1,
-              1
-            ],
-            "OFFSET": [
-              0,
-              0,
-              10,
-              18,
-              29,
-              39
-            ],
-            "DATA": [
-              "",
-              "\u77e2\u00a3efhcg",
-              "lii\u00b5wwm",
-              "1\u20ace2\u77e24c",
-              "bio\u20ac\u00b04l"
-            ]
-          }
-        ]
-      }
-    }
-  ],
-  "batches": [
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            3,
-            1,
-            1,
-            0,
-            4,
-            1,
-            0
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            1,
-            2,
-            0,
-            2,
-            1,
-            0,
-            0
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            0,
-            3,
-            4,
-            3,
-            2,
-            0,
-            1
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "f0",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            4,
-            3,
-            2,
-            2,
-            0,
-            2,
-            4,
-            2,
-            2,
-            0
-          ]
-        },
-        {
-          "name": "f1",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            1,
-            0,
-            4,
-            4,
-            4,
-            2,
-            4,
-            2,
-            2,
-            4
-          ]
-        },
-        {
-          "name": "f2",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            1,
-            1,
-            4,
-            0,
-            1,
-            1,
-            1,
-            4,
-            3,
-            2
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/test/arrowjson/map.json b/test/arrowjson/map.json
deleted file mode 100644
index 78a21596..00000000
--- a/test/arrowjson/map.json
+++ /dev/null
@@ -1,291 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "map_nullable",
-        "type": {
-          "name": "map",
-          "keysSorted": false
-        },
-        "nullable": true,
-        "children": [
-          {
-            "name": "entries",
-            "type": {
-              "name": "struct"
-            },
-            "nullable": false,
-            "children": [
-              {
-                "name": "key",
-                "type": {
-                  "name": "utf8"
-                },
-                "nullable": false,
-                "children": []
-              },
-              {
-                "name": "value",
-                "type": {
-                  "name": "int",
-                  "isSigned": true,
-                  "bitWidth": 32
-                },
-                "nullable": true,
-                "children": []
-              }
-            ]
-          }
-        ]
-      }
-    ]
-  },
-  "batches": [
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "map_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            3,
-            3,
-            3,
-            3,
-            5,
-            6,
-            9
-          ],
-          "children": [
-            {
-              "name": "entries",
-              "count": 9,
-              "VALIDITY": [
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1
-              ],
-              "children": [
-                {
-                  "name": "key",
-                  "count": 9,
-                  "VALIDITY": [
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1
-                  ],
-                  "OFFSET": [
-                    0,
-                    7,
-                    18,
-                    26,
-                    35,
-                    42,
-                    50,
-                    59,
-                    67,
-                    77
-                  ],
-                  "DATA": [
-                    "nk23ghl",
-                    "hr\u00b0rr\u77e2\u00b0",
-                    "b\u00b5reapd",
-                    "\u00a3\u00a3fprlo",
-                    "42lfc64",
-                    "ifcmf\u00b54",
-                    "mo\u00b51\u00b5gr",
-                    "alfkm\u00c2m",
-                    "r\u20acj333\u00f4"
-                  ]
-                },
-                {
-                  "name": "value",
-                  "count": 9,
-                  "VALIDITY": [
-                    1,
-                    0,
-                    1,
-                    0,
-                    1,
-                    1,
-                    1,
-                    0,
-                    1
-                  ],
-                  "DATA": [
-                    -2147483648,
-                    2147483647,
-                    -364117737,
-                    -1036293739,
-                    595547911,
-                    -136984751,
-                    1113642047,
-                    -174490757,
-                    247058944
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "map_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            0,
-            3,
-            5,
-            5,
-            5,
-            9,
-            9,
-            9,
-            12,
-            12
-          ],
-          "children": [
-            {
-              "name": "entries",
-              "count": 12,
-              "VALIDITY": [
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1,
-                1
-              ],
-              "children": [
-                {
-                  "name": "key",
-                  "count": 12,
-                  "VALIDITY": [
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1
-                  ],
-                  "OFFSET": [
-                    0,
-                    7,
-                    15,
-                    23,
-                    31,
-                    41,
-                    48,
-                    57,
-                    67,
-                    76,
-                    88,
-                    95,
-                    106
-                  ],
-                  "DATA": [
-                    "nii3ppw",
-                    "am3a\u00c2f4",
-                    "pc\u00a3heh3",
-                    "d\u00c2a6n5b",
-                    "\u00f4mf2\u20acc4",
-                    "r1jdf4r",
-                    "njo4\u00b0\u00b0k",
-                    "or\u20acm\u00f4lr",
-                    "em\u00f4i\u00f4ab",
-                    "\u00a3\u20acg\u00c2\u00b53a",
-                    "nfrim36",
-                    "\u00b0\u00c2b\u00f4a\u00b5w"
-                  ]
-                },
-                {
-                  "name": "value",
-                  "count": 12,
-                  "VALIDITY": [
-                    1,
-                    0,
-                    1,
-                    1,
-                    1,
-                    0,
-                    1,
-                    1,
-                    1,
-                    1,
-                    1,
-                    0
-                  ],
-                  "DATA": [
-                    -2147483648,
-                    2147483647,
-                    -296180340,
-                    -44923686,
-                    2123774743,
-                    1831761340,
-                    1290652534,
-                    68203103,
-                    1896803149,
-                    -1837559303,
-                    -517631115,
-                    289945925
-                  ]
-                }
-              ]
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/test/arrowjson/nested.json b/test/arrowjson/nested.json
deleted file mode 100644
index 50a73a18..00000000
--- a/test/arrowjson/nested.json
+++ /dev/null
@@ -1,537 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "list_nullable",
-        "type": {
-          "name": "list"
-        },
-        "nullable": true,
-        "children": [
-          {
-            "name": "item",
-            "type": {
-              "name": "int",
-              "isSigned": true,
-              "bitWidth": 32
-            },
-            "nullable": true,
-            "children": []
-          }
-        ]
-      },
-      {
-        "name": "fixedsizelist_nullable",
-        "type": {
-          "name": "fixedsizelist",
-          "listSize": 4
-        },
-        "nullable": true,
-        "children": [
-          {
-            "name": "item",
-            "type": {
-              "name": "int",
-              "isSigned": true,
-              "bitWidth": 32
-            },
-            "nullable": true,
-            "children": []
-          }
-        ]
-      },
-      {
-        "name": "struct_nullable",
-        "type": {
-          "name": "struct"
-        },
-        "nullable": true,
-        "children": [
-          {
-            "name": "f1",
-            "type": {
-              "name": "int",
-              "isSigned": true,
-              "bitWidth": 32
-            },
-            "nullable": true,
-            "children": []
-          },
-          {
-            "name": "f2",
-            "type": {
-              "name": "utf8"
-            },
-            "nullable": true,
-            "children": []
-          }
-        ]
-      }
-    ]
-  },
-  "batches": [
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "list_nullable",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1
-          ],
-          "OFFSET": [
-            0,
-            0,
-            4,
-            4,
-            4,
-            4,
-            4,
-            7
-          ],
-          "children": [
-            {
-              "name": "item",
-              "count": 7,
-              "VALIDITY": [
-                1,
-                0,
-                0,
-                0,
-                1,
-                1,
-                1
-              ],
-              "DATA": [
-                -2147483648,
-                2147483647,
-                1151956889,
-                -381487027,
-                873948027,
-                1643402405,
-                1658614443
-              ]
-            }
-          ]
-        },
-        {
-          "name": "fixedsizelist_nullable",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "children": [
-            {
-              "name": "item",
-              "count": 28,
-              "VALIDITY": [
-                0,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                1
-              ],
-              "DATA": [
-                -2147483648,
-                2147483647,
-                1455417103,
-                -386721267,
-                1200555928,
-                416671823,
-                -426485775,
-                1024100580,
-                1264993422,
-                -1001974859,
-                1688456056,
-                1130147884,
-                -1020099019,
-                1848995454,
-                2101085138,
-                1609275375,
-                1517442455,
-                -1648565699,
-                994186796,
-                2006991970,
-                -620340903,
-                -846162493,
-                1646215825,
-                468219400,
-                1580372269,
-                -1426972627,
-                1957501966,
-                1539427720
-              ]
-            }
-          ]
-        },
-        {
-          "name": "struct_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "children": [
-            {
-              "name": "f1",
-              "count": 7,
-              "VALIDITY": [
-                1,
-                1,
-                1,
-                1,
-                0,
-                0,
-                0
-              ],
-              "DATA": [
-                -2147483648,
-                2147483647,
-                531016632,
-                1805412611,
-                -1194513600,
-                -1267423429,
-                1000139479
-              ]
-            },
-            {
-              "name": "f2",
-              "count": 7,
-              "VALIDITY": [
-                1,
-                0,
-                0,
-                0,
-                1,
-                0,
-                0
-              ],
-              "OFFSET": [
-                0,
-                9,
-                9,
-                9,
-                9,
-                21,
-                21,
-                21
-              ],
-              "DATA": [
-                "dej\u00c2\u00a3pr",
-                "",
-                "",
-                "",
-                "i\u77e2j\u00a3\u00b0\u00b5m",
-                "",
-                ""
-              ]
-            }
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "list_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "OFFSET": [
-            0,
-            2,
-            5,
-            9,
-            9,
-            9,
-            9,
-            11,
-            13,
-            13,
-            13
-          ],
-          "children": [
-            {
-              "name": "item",
-              "count": 13,
-              "VALIDITY": [
-                0,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1
-              ],
-              "DATA": [
-                -2147483648,
-                2147483647,
-                248935155,
-                -322392706,
-                -115480117,
-                -1828031254,
-                -1766278277,
-                444059471,
-                -805219796,
-                1061714770,
-                423821865,
-                1278080160,
-                -1936049755
-              ]
-            }
-          ]
-        },
-        {
-          "name": "fixedsizelist_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "children": [
-            {
-              "name": "item",
-              "count": 40,
-              "VALIDITY": [
-                0,
-                1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                1,
-                1,
-                0,
-                0,
-                1,
-                0,
-                1,
-                0,
-                0,
-                1,
-                1,
-                1,
-                0,
-                1,
-                0,
-                0,
-                0,
-                0,
-                0,
-                0
-              ],
-              "DATA": [
-                -2147483648,
-                2147483647,
-                -376399341,
-                -1632957441,
-                -2143340689,
-                -159866261,
-                419032293,
-                1196087612,
-                784095846,
-                -435963426,
-                -574319754,
-                534646696,
-                -444534026,
-                1281811213,
-                -105831675,
-                -23408446,
-                348235550,
-                -1986936151,
-                -1558484167,
-                941484009,
-                2144967535,
-                830399805,
-                31470129,
-                -792586642,
-                -29778291,
-                1445584989,
-                -1344862682,
-                -1973973713,
-                -875795314,
-                556638175,
-                1282112437,
-                -2054079892,
-                -881420523,
-                1038384760,
-                846630800,
-                -442527632,
-                -975132694,
-                84102477,
-                1771796204,
-                -153752454
-              ]
-            }
-          ]
-        },
-        {
-          "name": "struct_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1
-          ],
-          "children": [
-            {
-              "name": "f1",
-              "count": 10,
-              "VALIDITY": [
-                0,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                1,
-                1,
-                1
-              ],
-              "DATA": [
-                -2147483648,
-                2147483647,
-                -1568585736,
-                1732529716,
-                1236302061,
-                -232126550,
-                -1554873925,
-                191321500,
-                570901234,
-                -2063634007
-              ]
-            },
-            {
-              "name": "f2",
-              "count": 10,
-              "VALIDITY": [
-                0,
-                0,
-                0,
-                1,
-                1,
-                1,
-                1,
-                0,
-                0,
-                1
-              ],
-              "OFFSET": [
-                0,
-                0,
-                0,
-                0,
-                9,
-                20,
-                28,
-                36,
-                36,
-                36,
-                46
-              ],
-              "DATA": [
-                "",
-                "",
-                "",
-                "h3\u00f46c\u00b0i",
-                "opa\u20acdf\u20ac",
-                "ncdcpe\u00f4",
-                "4fwflo\u00b0",
-                "",
-                "",
-                "pf41\u00c2\u77e24"
-              ]
-            }
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/test/arrowjson/primitive-empty.json b/test/arrowjson/primitive-empty.json
deleted file mode 100644
index 1e162592..00000000
--- a/test/arrowjson/primitive-empty.json
+++ /dev/null
@@ -1,879 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "bool_nullable",
-        "type": {
-          "name": "bool"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "bool_nonnullable",
-        "type": {
-          "name": "bool"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int8_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 8
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int8_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 8
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int16_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 16
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int16_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 16
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int32_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int32_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 32
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int64_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int64_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 64
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint8_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 8
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint8_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 8
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint16_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 16
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint16_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 16
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint32_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint32_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 32
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint64_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint64_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 64
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "float32_nullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "SINGLE"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "float32_nonnullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "SINGLE"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "float64_nullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "DOUBLE"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "float64_nonnullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "DOUBLE"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "binary_nullable",
-        "type": {
-          "name": "binary"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "binary_nonnullable",
-        "type": {
-          "name": "binary"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "utf8_nullable",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "utf8_nonnullable",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_19_nullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 19
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_19_nonnullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 19
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_120_nullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 120
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_120_nonnullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 120
-        },
-        "nullable": false,
-        "children": []
-      }
-    ]
-  },
-  "batches": [
-    {
-      "count": 0,
-      "columns": [
-        {
-          "name": "bool_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "bool_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int16_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int16_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint16_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint16_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "binary_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "binary_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "utf8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "utf8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_19_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_19_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_120_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_120_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        }
-      ]
-    },
-    {
-      "count": 0,
-      "columns": [
-        {
-          "name": "bool_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "bool_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int16_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int16_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint16_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint16_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "binary_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "binary_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "utf8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "utf8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_19_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_19_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_120_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_120_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        }
-      ]
-    },
-    {
-      "count": 0,
-      "columns": [
-        {
-          "name": "bool_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "bool_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int16_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int16_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "int64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint16_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint16_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "uint64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float32_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float32_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float64_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "float64_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "binary_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "binary_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "utf8_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "utf8_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "OFFSET": [
-            0
-          ],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_19_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_19_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_120_nullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        },
-        {
-          "name": "fixedsizebinary_120_nonnullable",
-          "count": 0,
-          "VALIDITY": [],
-          "DATA": []
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/test/arrowjson/primitive.json b/test/arrowjson/primitive.json
deleted file mode 100644
index 1b0ff10b..00000000
--- a/test/arrowjson/primitive.json
+++ /dev/null
@@ -1,1890 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "bool_nullable",
-        "type": {
-          "name": "bool"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "bool_nonnullable",
-        "type": {
-          "name": "bool"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int8_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 8
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int8_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 8
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int16_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 16
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int16_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 16
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int32_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int32_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 32
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int64_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int64_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 64
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint8_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 8
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint8_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 8
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint16_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 16
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint16_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 16
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint32_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint32_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 32
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint64_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint64_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 64
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "float32_nullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "SINGLE"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "float32_nonnullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "SINGLE"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "float64_nullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "DOUBLE"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "float64_nonnullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "DOUBLE"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "binary_nullable",
-        "type": {
-          "name": "binary"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "binary_nonnullable",
-        "type": {
-          "name": "binary"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "utf8_nullable",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "utf8_nonnullable",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_19_nullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 19
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_19_nonnullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 19
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_120_nullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 120
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_120_nonnullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 120
-        },
-        "nullable": false,
-        "children": []
-      }
-    ]
-  },
-  "batches": [
-    {
-      "count": 7,
-      "columns": [
-        {
-          "name": "bool_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            true,
-            false,
-            true,
-            true,
-            true,
-            true,
-            true
-          ]
-        },
-        {
-          "name": "bool_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            true,
-            true,
-            false,
-            false,
-            true,
-            true,
-            true
-          ]
-        },
-        {
-          "name": "int8_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            -128,
-            127,
-            -122,
-            28,
-            -83,
-            84,
-            6
-          ]
-        },
-        {
-          "name": "int8_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -128,
-            127,
-            70,
-            -103,
-            82,
-            -1,
-            32
-          ]
-        },
-        {
-          "name": "int16_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            -32768,
-            32767,
-            -28794,
-            -4798,
-            -9144,
-            -6471,
-            -28809
-          ]
-        },
-        {
-          "name": "int16_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -32768,
-            32767,
-            -29297,
-            -8851,
-            -7684,
-            22714,
-            16282
-          ]
-        },
-        {
-          "name": "int32_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            -2147483648,
-            2147483647,
-            -279511779,
-            789939398,
-            1566952883,
-            459144944,
-            112645645
-          ]
-        },
-        {
-          "name": "int32_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -2147483648,
-            2147483647,
-            1460305573,
-            -781342537,
-            -894485209,
-            -611261236,
-            -1733393626
-          ]
-        },
-        {
-          "name": "int64_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2147483648",
-            "2147483647",
-            "-1338619198",
-            "1195898730",
-            "-196833435",
-            "65722453",
-            "227331787"
-          ]
-        },
-        {
-          "name": "int64_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2147483648",
-            "2147483647",
-            "134673412",
-            "-1352599527",
-            "799755210",
-            "-1393335016",
-            "-1401944839"
-          ]
-        },
-        {
-          "name": "uint8_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            0,
-            255,
-            120,
-            36,
-            174,
-            74,
-            109
-          ]
-        },
-        {
-          "name": "uint8_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            255,
-            0,
-            157,
-            120,
-            198,
-            153
-          ]
-        },
-        {
-          "name": "uint16_nullable",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            65535,
-            58782,
-            40076,
-            39160,
-            7864,
-            28844
-          ]
-        },
-        {
-          "name": "uint16_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            65535,
-            19124,
-            52442,
-            22182,
-            56048,
-            17204
-          ]
-        },
-        {
-          "name": "uint32_nullable",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1
-          ],
-          "DATA": [
-            0,
-            2147483647,
-            919579300,
-            484217231,
-            723422877,
-            219335907,
-            1153201262
-          ]
-        },
-        {
-          "name": "uint32_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            2147483647,
-            1433308719,
-            68323683,
-            1195265875,
-            2106315800,
-            348904267
-          ]
-        },
-        {
-          "name": "uint64_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "0",
-            "2147483647",
-            "731435646",
-            "90213947",
-            "1630338070",
-            "1558676470",
-            "1207455205"
-          ]
-        },
-        {
-          "name": "uint64_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "0",
-            "2147483647",
-            "1521875652",
-            "1531293596",
-            "277775570",
-            "618952130",
-            "1948103139"
-          ]
-        },
-        {
-          "name": "float32_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            138.786,
-            335.978,
-            868.094,
-            -252.928,
-            433.858,
-            -1044.852,
-            -540.461
-          ]
-        },
-        {
-          "name": "float32_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -1645.756,
-            -1634.941,
-            -469.511,
-            489.177,
-            89.502,
-            -1068.882,
-            -1212.052
-          ]
-        },
-        {
-          "name": "float64_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            915.264,
-            45.397,
-            1247.676,
-            724.292,
-            -78.253,
-            -751.91,
-            1169.159
-          ]
-        },
-        {
-          "name": "float64_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -404.256,
-            -348.975,
-            273.1,
-            691.512,
-            -448.703,
-            632.765,
-            -1195.87
-          ]
-        },
-        {
-          "name": "binary_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0
-          ],
-          "OFFSET": [
-            0,
-            0,
-            5,
-            7,
-            8,
-            14,
-            14,
-            14
-          ],
-          "DATA": [
-            "",
-            "51D99B869B",
-            "F442",
-            "83",
-            "7C2BEBE65E6C",
-            "",
-            ""
-          ]
-        },
-        {
-          "name": "binary_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            10,
-            14,
-            15,
-            16,
-            17,
-            26,
-            26
-          ],
-          "DATA": [
-            "D6DDC948702117DC0840",
-            "533708DF",
-            "FB",
-            "EA",
-            "44",
-            "BCCD4C61F06C883F73",
-            ""
-          ]
-        },
-        {
-          "name": "utf8_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            12,
-            12,
-            12,
-            12,
-            20,
-            27,
-            35
-          ],
-          "DATA": [
-            "\u00b0\u00c2mgw\u20ac\u00b0",
-            "",
-            "",
-            "",
-            "iah6c\u00a36",
-            "rokidwr",
-            "6ja\u00b5fa1"
-          ]
-        },
-        {
-          "name": "utf8_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            10,
-            19,
-            28,
-            36,
-            44,
-            52,
-            59
-          ],
-          "DATA": [
-            "g\u77e2\u00a3k4c2",
-            "orfbb\u77e2a",
-            "m2k23\u00a3\u00b5",
-            "5rl6\u00f45d",
-            "egijr\u00b0b",
-            "jple\u00b0ch",
-            "rkiw42p"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_19_nullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "50243F2281B31338EF651FCF9256388A319101",
-            "9BECDDC65F62CFAB152F965E8C5311662E972F",
-            "C7599811DDB43DFD35EAD3D3FB7FAF0AAFB9F2",
-            "619D0F38B15A69CEA060657758CD9F6820C3DE",
-            "C977E16BB93CFE804EB187E0DB4FB5C7E5E613",
-            "2339A0EE888B27EFC693DF65DD717AB624DF0F",
-            "F8F3629704844DAEF6E952A498504192D33913"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_19_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "9AD533F0DD44FC7229F465337FDAC9BEF5FACA",
-            "E0EC91C117CC0C3E82BF9B288D7C3A7CB48A2E",
-            "CC930B39BCAA159A659588751DC6EEA7F3F933",
-            "2B236ECB372BF9606EC626C1CFA6928D7D0CE2",
-            "DDF3F3C8D9DAA76406FCF6D6BEA375FF474C0E",
-            "828A465C7EF01C9341782A7421C877718F2282",
-            "FC34EC8BFEEF50D51F04B14DA64D1CD180757A"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_120_nullable",
-          "count": 7,
-          "VALIDITY": [
-            0,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            "8B96BE80C69B5CEA1C7535D822E8E8B93D22836318AD95BD33F2502084DF803C94735559F3191BB6D44DCE09BB77F9AF48E1851C0483B47A8EAE37ED92ABC071E46975F17685E9DD44640414E24F9C9F150BD29B0E2CABD4FB235A6D2CD5655D647724520C47AB1FE4DC7D418CDF3F55459E6DDF5B46F726",
-            "ED0007F8435C9848C5F886245DC9C0AF5CA5796136146A967771E50DE82CA664B3C94C5AF0B10C8A6AB36B51D88E761181CEC6B8729FD6EB781255084F3A19F2CE1B0B2469B1E5B41468C125A391AED7313F8D088CB50C1B4090BA34BE96532377215DB8D02740C3577AEAB769CDC11F5C45EEFA54607F95",
-            "E8253141328AE443B2DBC4217FFC251D7C8501924A54071DDEDF06D249F88119161DE1B4CFA929868E965E2EA102BBECA7908180C867F24E5CE1519DD734BC1E8EC77F12D9BF2876077B2A497E03B46B0203FB7BB9173B5A401B4A9D8DA152A13CC5AC218B0BED3131DE47F99909103754CB890104DCB4CD",
-            "EE2CA14099A48D8E69A3EF6FBC20389F83F39692BD5E2490D25542EACB623FB79578CDD66C40A26B7732D1EFD5B5930E851F9E8C1E18C18455DA76D8BDB1562F7C6704F071B7707863AB91C9B3D10B5DB17BB451F3EF1FF1F1F2DD4AC2FB10FE6CB43E8F00EDDC5AF4785E7C4EED05BC5FEA73B9D08FDFB8",
-            "277EB8E2CDCE71E471B8AF106BC682F76FA50F580EA09031E797D68464736EA29C50326845A935E1E8EFE77387B4DC4424DC1AA84834BB07779869BF50059953020034FF201E10CC710C76F87366435FD20AE6292712BB4A746ED0B8D263D3BE2A8E8DE8AF54E0667D04B1F8B3147206C74BECFD010320FC",
-            "784E3DF66A677FD1D5D30EC37B3A9D8E77D876D1FE23EB4EDA9B721CF62D0C1AACBAEE2A4AF953547E472AF6D5F78BAE10D6FA7A2ED19F0C3D716F9C955157245EA7BAED58F6473DD03B6891CAA7AD551B1847A5C196A98716782C4C8479F0ED5BF5E505F01C0A772FA1805E2E7A81BC1409AC4D33CA25C7",
-            "51BD3890033C88951DE28101F9A5B90D77083C4342065B86B5D7057F0E07827E70F398DAD0CF60AEAF30CADF988F6CD096F1B58AC48DBB4928BB0831A10D6180F300CBE31AF3D8388C8AF52EEA5DD317A213DFE69F53516DD90A2EDC015B29E73C07ED04C2DABC2EB63C42C474D26DCC4CBAD785D39533D3"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_120_nonnullable",
-          "count": 7,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "E6439C34B42D20E636A6263B095E98EE7BFE0B33DFFF009EA4B9A14E15E5C7898D0408BB4FB41E73E50A25DE7210FDAF36B1DC57ACD9516236DE6C2B1D6B22618EE24EE657C4DE5001CF05088BCBDFD3B9B1048329DF8A9DF6AAF7A4747461A11E1A425D9007217C9542B7F93DAA9766338C4276A5D00B79",
-            "D721489C85BF19A80DB99F84C529B900677A8647FFB6704A33914E8A80448E50143E2F7805F54D52B4B5C6920D57023D1B7FC4B8C4720F8768A9455D35F28097709CB8BE7EED669F20FFF7D8A11903AD66C61F1FC4D3761A487010F8164A20C02F7381F08C335DF4EF28E7E07E8CD1956B73C3805728CCF7",
-            "D29C90A96829D519E24EA6E91C59CA3484BCD7E3E7ABD9FEA6358355C67A6F1E903466D1DCCF99ED5205E19C0B3E744827B1F1F4BF1F1438F818482591EC4CED55A21B0F8FE49E18E6CF8BC17920F62710F193A9D7CE786D4FFEA5AB2F86FC375B25239203F9CEF85144252D8D51D953A0AD549D82FF24E1",
-            "665D643C48F33A6DC1C6D2A182F693BE49729C1976886AA5709E10B47992D4AC81682FD815447EC072852A112C5E056B21ACA45C4259DC6101893EF693CC83AB8023D431FD226C30DD9D543004D4655F18F1176B0A216FA425482244AB58E7B35C98E87A67D24723E17FB6009CD7520C1DDD6965F028CECF",
-            "B6F739AA817BF09B1D324D2ED41CAC7BF2BB48DFA36539661EB015619365D109D56DD3B0FC0D6D1F88A3C14D20E130CE3F2AC7544983145B33D0F431556093958077967AC3420545A786C18F3C3C8A3358D5EB4EFE6829F4A7E989810578C9A1B2CEDC6A4154DE1138497E7EF69DCBCC96FC28DD50CAB9B2",
-            "FF506B98BF6FB212E31A785A4B31BF897BBA4043C90FA9BE028183FB7A00B27055D4524EA9996A5CBC8C1A1EFC85D24A88385064245D9F694B504FCAB55A6DA2462FA3A0238990C3EBED78291272520D8C4DF6A8AB930562A0372C15CE02C89CF157819C8C8C1D39767BC413B64587EE41B95145B4C458E3",
-            "EF0D024C1652A39F750EEEDC0C116634A844F238724C6825D30D228DA51CC7CFFA0F249B46A72B3A50C80593D070C91424625A738F810238EBE5DB26B3ED0D3358E3E762EDB538FB7A6CEBEDAA0EC2606061DC7AFD2F2707AC1EE64D25053BCE5351F15C297CC17382C81C1F6AEBBACBB54C6452E0B28F94"
-          ]
-        }
-      ]
-    },
-    {
-      "count": 10,
-      "columns": [
-        {
-          "name": "bool_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            false,
-            false,
-            false,
-            true,
-            true,
-            false,
-            true,
-            true,
-            true,
-            false
-          ]
-        },
-        {
-          "name": "bool_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            true,
-            true,
-            false,
-            false,
-            true,
-            true,
-            false,
-            true,
-            false,
-            true
-          ]
-        },
-        {
-          "name": "int8_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            -128,
-            127,
-            -65,
-            89,
-            -62,
-            -22,
-            -34,
-            65,
-            120,
-            15
-          ]
-        },
-        {
-          "name": "int8_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -128,
-            127,
-            123,
-            70,
-            100,
-            -36,
-            113,
-            -108,
-            -6,
-            86
-          ]
-        },
-        {
-          "name": "int16_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            0,
-            0,
-            0,
-            0,
-            0,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            -32768,
-            32767,
-            9740,
-            -7733,
-            2637,
-            -2516,
-            -17569,
-            11730,
-            -2908,
-            -8593
-          ]
-        },
-        {
-          "name": "int16_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -32768,
-            32767,
-            11718,
-            15880,
-            -6679,
-            -22888,
-            23270,
-            18088,
-            20637,
-            -15533
-          ]
-        },
-        {
-          "name": "int32_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -2147483648,
-            2147483647,
-            477524758,
-            -606134564,
-            393807314,
-            -128112077,
-            717176459,
-            -1600977792,
-            978954235,
-            1860414687
-          ]
-        },
-        {
-          "name": "int32_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -2147483648,
-            2147483647,
-            -829757574,
-            -578351845,
-            -1348186787,
-            1890352675,
-            1086502698,
-            855304232,
-            181164543,
-            1057305604
-          ]
-        },
-        {
-          "name": "int64_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0
-          ],
-          "DATA": [
-            "-2147483648",
-            "2147483647",
-            "794060722",
-            "198709512",
-            "-8995664",
-            "-620701969",
-            "1130202008",
-            "415910253",
-            "-84549711",
-            "1106943323"
-          ]
-        },
-        {
-          "name": "int64_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "-2147483648",
-            "2147483647",
-            "674480972",
-            "1486723112",
-            "633112390",
-            "245208998",
-            "-1174152026",
-            "-321990725",
-            "-902510995",
-            "2067119255"
-          ]
-        },
-        {
-          "name": "uint8_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            0,
-            0,
-            1,
-            1,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            255,
-            239,
-            62,
-            105,
-            206,
-            159,
-            158,
-            131,
-            187
-          ]
-        },
-        {
-          "name": "uint8_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            255,
-            228,
-            195,
-            119,
-            246,
-            233,
-            73,
-            227,
-            240
-          ]
-        },
-        {
-          "name": "uint16_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            65535,
-            45066,
-            6178,
-            34711,
-            47964,
-            27512,
-            44887,
-            24908,
-            55701
-          ]
-        },
-        {
-          "name": "uint16_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            65535,
-            34339,
-            47690,
-            52236,
-            13,
-            16102,
-            11524,
-            57102,
-            29731
-          ]
-        },
-        {
-          "name": "uint32_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            0,
-            2147483647,
-            1647048552,
-            2065866351,
-            1252022470,
-            1848990303,
-            16726832,
-            597785424,
-            1240213577,
-            867494515
-          ]
-        },
-        {
-          "name": "uint32_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            0,
-            2147483647,
-            1852519148,
-            672549034,
-            1636451193,
-            2103372287,
-            680709579,
-            969728024,
-            959488127,
-            712543217
-          ]
-        },
-        {
-          "name": "uint64_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1,
-            1,
-            0,
-            0
-          ],
-          "DATA": [
-            "0",
-            "2147483647",
-            "706989612",
-            "89417634",
-            "753617711",
-            "863868960",
-            "844763261",
-            "1277577256",
-            "520788201",
-            "1438973022"
-          ]
-        },
-        {
-          "name": "uint64_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "0",
-            "2147483647",
-            "343654149",
-            "1874151572",
-            "1405305125",
-            "1695099154",
-            "1823719899",
-            "1099199355",
-            "649954155",
-            "1371446104"
-          ]
-        },
-        {
-          "name": "float32_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            0,
-            0
-          ],
-          "DATA": [
-            -1963.405,
-            -521.792,
-            -1054.599,
-            -908.552,
-            478.058,
-            689.984,
-            -728.344,
-            -328.966,
-            -992.419,
-            357.03
-          ]
-        },
-        {
-          "name": "float32_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            -3537.833,
-            887.934,
-            -844.73,
-            -564.775,
-            -1264.466,
-            45.573,
-            -1352.096,
-            -1115.417,
-            62.628,
-            19.499
-          ]
-        },
-        {
-          "name": "float64_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            1,
-            1,
-            0
-          ],
-          "DATA": [
-            2290.58,
-            1382.481,
-            304.522,
-            919.074,
-            -224.893,
-            941.403,
-            746.143,
-            -945.379,
-            -335.496,
-            -92.736
-          ]
-        },
-        {
-          "name": "float64_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            1537.239,
-            1200.259,
-            900.506,
-            -183.952,
-            1331.255,
-            2447.965,
-            -394.255,
-            -1930.895,
-            -85.89,
-            -67.091
-          ]
-        },
-        {
-          "name": "binary_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            1,
-            1,
-            0,
-            0,
-            1,
-            0,
-            0,
-            1,
-            0
-          ],
-          "OFFSET": [
-            0,
-            0,
-            9,
-            11,
-            11,
-            11,
-            13,
-            13,
-            13,
-            13,
-            13
-          ],
-          "DATA": [
-            "",
-            "EA766EF95797A0C9B8",
-            "84D5",
-            "",
-            "",
-            "AD57",
-            "",
-            "",
-            "",
-            ""
-          ]
-        },
-        {
-          "name": "binary_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            0,
-            1,
-            3,
-            4,
-            6,
-            7,
-            10,
-            12,
-            13,
-            14
-          ],
-          "DATA": [
-            "",
-            "3D",
-            "9E86",
-            "EA",
-            "C091",
-            "AD",
-            "2D3828",
-            "3EE2",
-            "84",
-            "F8"
-          ]
-        },
-        {
-          "name": "utf8_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            1,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            10,
-            10,
-            19,
-            28,
-            39,
-            39,
-            49,
-            59,
-            73,
-            83
-          ],
-          "DATA": [
-            "f5\u77e2jnm\u00a3",
-            "",
-            "lnc\u77e2bbe",
-            "a\u77e2r2pd1",
-            "2d\u00f4\u00c2e\u20acg",
-            "",
-            "\u00b5\u00c2rh\u00c2rn",
-            "g\u00b5e\u00f4h\u00f4r",
-            "\u00a32\u77e2a\u77e2\u00b5\u00c2",
-            "m\u00f4\u00f4\u00b56in"
-          ]
-        },
-        {
-          "name": "utf8_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "OFFSET": [
-            0,
-            10,
-            19,
-            26,
-            37,
-            46,
-            57,
-            65,
-            77,
-            86,
-            95
-          ],
-          "DATA": [
-            "5j\u00a3n\u77e265",
-            "pdwf\u00f4\u00f45",
-            "ifwnble",
-            "1g\u00c2\u00b0h\u00b0\u00c2",
-            "4e\u00c2fkb\u00c2",
-            "\u00a3\u20ac\u00b55omr",
-            "4f36\u00a3rp",
-            "jhw\u20ac\u20ac\u00f4c",
-            "5r\u77e2wl2h",
-            "6\u77e2bnin1"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_19_nullable",
-          "count": 10,
-          "VALIDITY": [
-            0,
-            0,
-            1,
-            1,
-            1,
-            0,
-            1,
-            0,
-            0,
-            1
-          ],
-          "DATA": [
-            "C85E25A3CCE5865762DCFC6E07E23481189581",
-            "833BACCDA190F764DEDB416EE08B8BC302AB63",
-            "D7573E24B94D3B70E23743918DBE9BA3272FA5",
-            "E3AE2D60B3E7513863A71E78874BE0B714524A",
-            "833E27429BC71A6CBCC0A1349F58112AA5307E",
-            "CB3F3571BCA366F6DA6AD3B182452529BDEA1C",
-            "5B4F8DD3A1694411902AAF6C0087143581B2CB",
-            "D7C308DBC4A59CCD176076941788705CFDA2ED",
-            "D5C307EEE12A6E4D0B2AD848DC52EB252ECDEF",
-            "D778B9EB37E4D5FFC1BF753ABAEB069A5E45E2"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_19_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "C75F1645509DC011AB32AC2F576CAE7ECA7B16",
-            "CB8E1A1F0A4B75B4E8E199EE6959E2C0CC64B6",
-            "9D53CFDBD99B04F4FB034256CDDAAC86CD134A",
-            "0B78B4D2F163FC63BF2F36FEC8E9466B79A3C8",
-            "D89F13F6448B6E7FD84B2E19A460AD8E105E31",
-            "CE7121C392A8560257CB0F36A3D4CEFEAA120D",
-            "540FE8D61D90A7B5984B45A082BF2842126253",
-            "97EC73B3236B90B522AAC15817626E0566780D",
-            "3A8B546C8FE7624CD4E1EE8B3E0D77D89D5EC1",
-            "3E601ED2EA586F69F56387556D17512A482A08"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_120_nullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            0,
-            1,
-            1,
-            1,
-            1,
-            0,
-            0,
-            1,
-            1
-          ],
-          "DATA": [
-            "D49D31D22EB091811343B3B583AE276D5DF5BC8EA636000DE72FCBB3031FBA4D05F433EBC75124D60C56656F5411B3A0E6EECDA4346CF3105F87E7B1DEBF3C6FCF938F07B3C470DDE33436D19C07D9BA128B47554E5276D47C21C715BEF67E3802ECA55BB6759E50F130590ADEDDCD86A958F56C9D077C70",
-            "6AC6110369AFA04648213B52CD109586E85CD77D5B3F262576BC3FF98A9EC90761912FC88940F798CDA6163F3E3D7994285A903470365243F551111621F6350B078CA055001EB406B5A7C07706F2E04B2730A2335D87C151368A160EDBC0C26201EA6441990354ED302894B8ACC1A257D6DE9E17B2564898",
-            "DCE126B0DCB6195E93DC878CAF5F064BAE1184A6DBC06C2C8A1628D019BCEC17411521E3BC58A8ACBC73FCCE887B9D6E45645B7C2100AD624FF6734241676C747A3C6DC61C52D605A379F906C662215DCE3115A7BD1213B6E7F5C9AFF2D6221BFE4C0C4FF4AF9B18BA2E7D425BD8D98C0D7BDA249EA37BA8",
-            "4B18DD4F1927AD7AF60F7C11C982FCCCFD42A17849EA8654A30DDC58C1CBD641C1B70A924EA1F3D2DCF750DBF87B16CBC4E00D9617E88737A22B9F9B7D20F779381A71879FC46D591A7C0426A2BC5FF563C6F33CA0566A6E7D471033961D45F685D403F4E9D3164FE8CF5ECBF131D3EFBA371DAE1C6C2E6B",
-            "33C9DE972AD49D58C52F895B0F81EEE1E819BA427E9197F2DC3F37FD9D6B31E847016B4590BC72C60BA40C89D0647A0064C5192FD917CCBC7351650885DAA03217E8FFA1B568582AC2354499852CDCC17967F3301DE60EAB044A66AD0A0175DCE71229D5ECD83325B0D2A4D75169A38DC11F6504A8CF9F92",
-            "943EA9C4927C15AB07594F7FABFAE47061670FF75663C9B3AF5F08C8EE1523AACA9E631996D3A17644B23DC1CC6FB3157A177340CA9F93FC7D0E2C3BF907EB74AB4C5DE8B49319B86BB9457649360DA39B66BC145721A6BAF056961172EC6C93CB7CBFC9A2C682DBE8A74F8CDC20324CDAB7388480908F18",
-            "00FA841BCDD7C5D584C9C27E3577C7CC3FD1AC6C760B1914D1CBF765418EF21005AB7E065AF3C08424F7CEF98EECAE1694939728B71F750A096B3FF8F78843AC768C37FC7712A075786C7F1FC90AD316D20838693002DEA9B32B5864948709B200FF3E278B578E0B47A1E63583DAB18AABED963207642992",
-            "4DCB937A9E3144A2383FFF5C3EF93EFFD128FC3C131DD9469A2CB0E59DA7EBDBA77AD01A0979B99FBA10055567EDA3CFCA77A515BD1D4D632C6BA9B698813F1C0AFFBEFF227D140407BF5728EC943F9D3833DA1B8D2B5B60398CB219500022B1AB9312273C5275D6282EC4A4E648B6491212B954470CA6BE",
-            "A0BBC95D4894952D2E4945538AF4CE60828A1B94949143EEA065C0917BD5CDDBD68AA838AA1F75EFED37DC7256618C0CA762EE7CF75A287D529ADBFC81FD11A5F75CE23BF27940150E737E73992ACF085F52AE14E02BCEE2D229F20AEB862A8CC3D5881AE4E6267CC8B1EEF1D2AC97D4769CAD14DD4BFB96",
-            "F54B84661C426B3D0E37A455738000E50EF024258EBCE2AA3FEC5AA4E2EC3C48150B56BD44E96658C7CCB6267DB8C5484DA153FBFE0478073720BCBB65927681B36C17AE976568129E3C2FD1CBBDE89DBEE1D461FD7C6DBA455D80DC02A107855C5D04808AA164D85CF1F72EDB153685B2046E12968DB052"
-          ]
-        },
-        {
-          "name": "fixedsizebinary_120_nonnullable",
-          "count": 10,
-          "VALIDITY": [
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1,
-            1
-          ],
-          "DATA": [
-            "383BB0920976B030D92B51AA60DC74922A0EB112955D1D934E19EC0CDE12CAB87C6E069439EB4F9FC105F7250BFE7DD983CC10728B8445735A7E52720FBDCD4AB7113BF52B797A05B187F572A330DABEA5E8DB5698168538775825001E7EB6CA0468F06F623A77AD99E5BB63D90A267AF243D7840B099F2C",
-            "074AC397B235ADA4A90B56B3B37D5148BEA22D6A6746B308DEA7E81A7294AEF6F3C6097A0941CA8DF01147B27040A672D5DCCF073DEB5DC0AC360E083BFB8378D7364EB2E4A09D629264BC9ED28D967184A6710424DC36D80E7D4FF499FA3CF1C0D77117CFB3E5783735F8B00D52A1243521A598F44A139F",
-            "0612AE357E65463291258B15782DA04D8B8F004F4360EB1DAB17FB57B5A5772ECCF419EE132FC94A1C0D00A2C731B887C25CDAF192BE78E6C94145421884243B234DC7A80592E70D6ECCCAEA8C08AEAE2A1AD70D786B039DA894B6FE7996F5BF6EC6670FCBBE7042430D0174D5CA9043DB7B79899A360C94",
-            "FE0A6A2B3A475AF6AA63CE24997BCAFA096B9269DA9368CEBD03444223F2497907FBD66CA071A7BEAA68D76CFD9A507280BF6108303F16558225883351E2FDF88E425DBE6ACEBE29E69CF57E41B74952391DF1B04F80363E3879A1326B9DD2D4AD94092D1FDD8EE574AC69D1F22A1BC1EC7F04BBAEC32AB7",
-            "588F15533772FD3C26415F6DC5DDB98264BEB79868908B6CB216D59A3A227E75F443A448B0D7A405AA248F6A6F049EB247B1826A02DA6F2624E16B0A899056B1D0565429434006CB11D5E3D224CA4AE7A4C19817685CB46DC0BF789AC94BF755A47B4668EBA8898CF85CD0C4F2309E97F0FE25EFB508B635",
-            "5351D21576971DFFDF48693B65895450FC098F21722B44E4CE583E969ACDF47A686AA849B265CECEAAD67CD122C10FBA7069E52326B64FD146054EE8C3F621AF28FFB2127E75FFC99B0E72B72BC615C4E9B7310C088CE5883CF41AC717DABCDF6F140B9933C831CB828EF9C02E02DC35501B527E46B1933C",
-            "6B7D83AB9AC067A38C0F2A95A4B4A3CE63C4731C729C9ED568FDA35D750262B5E7B44809D131F9F7996B2630C6075C083F31736EBA9CBB1CC62A257EBE294C55B750154E004F768EB670F648E17EB5DA40E28350B19070E924001F16846F6BC197897F189E31F30C93D43098DBE39F0EBF2E4A7FD7A25A55",
-            "26C342B09B0D6D690753743D15F78B9F2CDBAF14B95DF0D5BC9D7E1AC0C4416F3852AD0CD3D51610A6B7B6BEC766672E274C971E5692FA9AB982C3C828EA9A270BFB524EDCA50D0E8444540B82752201BDC9BA56CE6A01A04E25D5514C045515FDE12AE0B0A0533AAFD5E5FF18ABD22312DFEC854C496391",
-            "7C6D76970A57EFEC88857971E84675A3EDC47F0B2E1AA20B916601842394BC674F3CF10729DF32D10BC7BE05B74B8F68E24884637F0553A7EC84353C43B4640AC5582EBAF0827D247CE49BC95B74D842E2EE25D80741F80C3019D7EDF58CCB47112C70835F32E538F3664B5625C5FC3C761FE96E329AF03C",
-            "3A97DD53C812EBB096458C9B8E382F9404BB5F1F29FFF7973E15FB547A06F32DAFD300719AEE30E11DF794603B5D196AAAB5BE44A127590388E420367C3F542E6288A1505D83283B63417F9DBD5E2609D436773106940756DDB71910ACFD5FEF8A1F92AD3366E778FD1849C1CB2C0439B6D5719299E59D96"
-          ]
-        }
-      ]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/test/arrowjson/primitive_no_batches.json b/test/arrowjson/primitive_no_batches.json
deleted file mode 100644
index e9eac55a..00000000
--- a/test/arrowjson/primitive_no_batches.json
+++ /dev/null
@@ -1,287 +0,0 @@
-{
-  "schema": {
-    "fields": [
-      {
-        "name": "bool_nullable",
-        "type": {
-          "name": "bool"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "bool_nonnullable",
-        "type": {
-          "name": "bool"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int8_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 8
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int8_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 8
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int16_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 16
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int16_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 16
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int32_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int32_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 32
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "int64_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "int64_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": true,
-          "bitWidth": 64
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint8_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 8
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint8_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 8
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint16_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 16
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint16_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 16
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint32_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 32
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint32_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 32
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "uint64_nullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 64
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "uint64_nonnullable",
-        "type": {
-          "name": "int",
-          "isSigned": false,
-          "bitWidth": 64
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "float32_nullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "SINGLE"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "float32_nonnullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "SINGLE"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "float64_nullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "DOUBLE"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "float64_nonnullable",
-        "type": {
-          "name": "floatingpoint",
-          "precision": "DOUBLE"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "binary_nullable",
-        "type": {
-          "name": "binary"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "binary_nonnullable",
-        "type": {
-          "name": "binary"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "utf8_nullable",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "utf8_nonnullable",
-        "type": {
-          "name": "utf8"
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_19_nullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 19
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_19_nonnullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 19
-        },
-        "nullable": false,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_120_nullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 120
-        },
-        "nullable": true,
-        "children": []
-      },
-      {
-        "name": "fixedsizebinary_120_nonnullable",
-        "type": {
-          "name": "fixedsizebinary",
-          "byteWidth": 120
-        },
-        "nullable": false,
-        "children": []
-      }
-    ]
-  },
-  "batches": []
-}
\ No newline at end of file
diff --git a/test/arrowtypes_compat_tests.jl b/test/arrowtypes_compat_tests.jl
new file mode 100644
index 00000000..80a6e772
--- /dev/null
+++ b/test/arrowtypes_compat_tests.jl
@@ -0,0 +1,7219 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# ArrowTypes logical-type lowering, extension metadata, and lifting through
+# the public read/write facade; included from runtests.jl.
+
+using ArrowTypes
+using DataAPI
+using Dates
+using Tables
+using UUIDs
+import Durations
+
+struct ArrowTypesTestBytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::ArrowTypesTestBytesSource) = length(s.data)
+Arrow.readrange(s::ArrowTypesTestBytesSource, off, len) = s.data[(off + 1):(off + len)]
+
+struct ArrowTypesTestRetainedPartitions{S,P}
+    schema::S
+    parts::P
+end
+Tables.partitions(source::ArrowTypesTestRetainedPartitions) = source.parts
+Arrow._retainedschema(source::ArrowTypesTestRetainedPartitions) = source.schema
+
+struct ArrowTypesTestID
+    value::Int64
+end
+Base.:(==)(a::ArrowTypesTestID, b::ArrowTypesTestID) = a.value == b.value
+Base.isequal(a::ArrowTypesTestID, b::ArrowTypesTestID) = isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_ID_NAME = Symbol("JuliaLang.ArrowTests.ID")
+const ARROWTYPES_TEST_ID_JULIATYPE_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestID}) = Int64
+ArrowTypes.toarrow(x::ArrowTypesTestID) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestID}) = ARROWTYPES_TEST_ID_NAME
+function ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ID_NAME}, S, metadata)
+    ARROWTYPES_TEST_ID_JULIATYPE_CALLS[] += 1
+    return ArrowTypesTestID
+end
+ArrowTypes.fromarrow(::Type{ArrowTypesTestID}, x::Int64) = ArrowTypesTestID(x)
+
+struct ArrowTypesTestCountedID
+    value::Int32
+end
+Base.:(==)(a::ArrowTypesTestCountedID, b::ArrowTypesTestCountedID) = a.value == b.value
+Base.isequal(a::ArrowTypesTestCountedID, b::ArrowTypesTestCountedID) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_COUNTED_ID_NAME = Symbol("JuliaLang.ArrowTests.CountedID")
+const ARROWTYPES_TEST_COUNTED_ID_TYPE_CALLS = Ref(0)
+const ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS = Ref(0)
+function ArrowTypes.ArrowType(::Type{ArrowTypesTestCountedID})
+    ARROWTYPES_TEST_COUNTED_ID_TYPE_CALLS[] += 1
+    return Int32
+end
+function ArrowTypes.toarrow(x::ArrowTypesTestCountedID)
+    ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] += 1
+    return x.value
+end
+ArrowTypes.arrowname(::Type{ArrowTypesTestCountedID}) = ARROWTYPES_TEST_COUNTED_ID_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_COUNTED_ID_NAME}, S, metadata) =
+    ArrowTypesTestCountedID
+ArrowTypes.fromarrow(::Type{ArrowTypesTestCountedID}, x::Int32) = ArrowTypesTestCountedID(x)
+
+struct ArrowTypesTestWriteOnly
+    value::Int32
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestWriteOnly}) = Int32
+ArrowTypes.toarrow(x::ArrowTypesTestWriteOnly) = x.value
+
+struct ArrowTypesTestAlternateWriteOnly
+    value::Int32
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAlternateWriteOnly}) = Int32
+ArrowTypes.toarrow(x::ArrowTypesTestAlternateWriteOnly) = x.value
+
+abstract type ArrowTypesTestAbstractWriteOnly end
+struct ArrowTypesTestAbstractWriteA <: ArrowTypesTestAbstractWriteOnly
+    value::Int32
+end
+struct ArrowTypesTestAbstractWriteB <: ArrowTypesTestAbstractWriteOnly
+    value::Int32
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAbstractWriteA}) = Int32
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAbstractWriteB}) = Int32
+ArrowTypes.toarrow(x::ArrowTypesTestAbstractWriteA) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestAbstractWriteB) = x.value
+
+abstract type ArrowTypesTestAbstractMixedWrite end
+struct ArrowTypesTestAbstractMixedInt <: ArrowTypesTestAbstractMixedWrite
+    value::Int32
+end
+struct ArrowTypesTestAbstractMixedString <: ArrowTypesTestAbstractMixedWrite
+    value::String
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAbstractMixedInt}) = Int32
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAbstractMixedString}) = String
+ArrowTypes.toarrow(x::ArrowTypesTestAbstractMixedInt) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestAbstractMixedString) = x.value
+
+abstract type ArrowTypesTestDeclaredAbstract end
+struct ArrowTypesTestDeclaredConcrete <: ArrowTypesTestDeclaredAbstract
+    value::Int32
+end
+ArrowTypes.ArrowType(::Type{<:ArrowTypesTestDeclaredAbstract}) = Int32
+ArrowTypes.toarrow(x::ArrowTypesTestDeclaredAbstract) = x.value
+
+struct ArrowTypesTestLogicalUnion
+    value::Union{Int64,String}
+end
+Base.:(==)(a::ArrowTypesTestLogicalUnion, b::ArrowTypesTestLogicalUnion) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestLogicalUnion, b::ArrowTypesTestLogicalUnion) =
+    isequal(a.value, b.value)
+Base.hash(x::ArrowTypesTestLogicalUnion, h::UInt) = hash(x.value, h)
+
+const ARROWTYPES_TEST_LOGICAL_UNION_NAME = Symbol("JuliaLang.ArrowTests.LogicalUnion")
+const ARROWTYPES_TEST_LOGICAL_UNION_TYPE_CALLS = Ref(0)
+const ARROWTYPES_TEST_LOGICAL_UNION_CALLS = Ref(0)
+function ArrowTypes.ArrowType(::Type{ArrowTypesTestLogicalUnion})
+    ARROWTYPES_TEST_LOGICAL_UNION_TYPE_CALLS[] += 1
+    return Union{Int64,String}
+end
+function ArrowTypes.toarrow(x::ArrowTypesTestLogicalUnion)
+    ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] += 1
+    return x.value
+end
+ArrowTypes.arrowname(::Type{ArrowTypesTestLogicalUnion}) =
+    ARROWTYPES_TEST_LOGICAL_UNION_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_LOGICAL_UNION_NAME}, S, metadata) =
+    ArrowTypesTestLogicalUnion
+ArrowTypes.fromarrow(::Type{ArrowTypesTestLogicalUnion}, x::Int64) =
+    ArrowTypesTestLogicalUnion(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestLogicalUnion}, x::AbstractString) =
+    ArrowTypesTestLogicalUnion(String(x))
+
+struct ArrowTypesTestLogicalListUnion
+    value::Union{Vector{Int64},String}
+end
+Base.:(==)(a::ArrowTypesTestLogicalListUnion, b::ArrowTypesTestLogicalListUnion) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestLogicalListUnion, b::ArrowTypesTestLogicalListUnion) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_LOGICAL_LIST_UNION_NAME =
+    Symbol("JuliaLang.ArrowTests.LogicalListUnion")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestLogicalListUnion}) = Union{Vector{Int64},String}
+ArrowTypes.toarrow(x::ArrowTypesTestLogicalListUnion) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestLogicalListUnion}) =
+    ARROWTYPES_TEST_LOGICAL_LIST_UNION_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_LOGICAL_LIST_UNION_NAME}, S, metadata) =
+    ArrowTypesTestLogicalListUnion
+ArrowTypes.fromarrow(::Type{ArrowTypesTestLogicalListUnion}, x::AbstractVector) =
+    ArrowTypesTestLogicalListUnion(Int64[x...])
+ArrowTypes.fromarrow(::Type{ArrowTypesTestLogicalListUnion}, x::AbstractString) =
+    ArrowTypesTestLogicalListUnion(String(x))
+
+struct ArrowTypesTestWriteOnlyLogicalUnion
+    value::Union{Int64,String}
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestWriteOnlyLogicalUnion}) = Union{Int64,String}
+ArrowTypes.toarrow(x::ArrowTypesTestWriteOnlyLogicalUnion) = x.value
+
+struct ArrowTypesTestLogicalNullUnion
+    value::Union{Nothing,String}
+end
+Base.:(==)(a::ArrowTypesTestLogicalNullUnion, b::ArrowTypesTestLogicalNullUnion) =
+    isequal(a.value, b.value)
+Base.isequal(a::ArrowTypesTestLogicalNullUnion, b::ArrowTypesTestLogicalNullUnion) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_LOGICAL_NULL_UNION_NAME =
+    Symbol("JuliaLang.ArrowTests.LogicalNullUnion")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestLogicalNullUnion}) = Union{Nothing,String}
+ArrowTypes.toarrow(x::ArrowTypesTestLogicalNullUnion) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestLogicalNullUnion}) =
+    ARROWTYPES_TEST_LOGICAL_NULL_UNION_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_LOGICAL_NULL_UNION_NAME}, S, metadata) =
+    ArrowTypesTestLogicalNullUnion
+ArrowTypes.fromarrow(::Type{ArrowTypesTestLogicalNullUnion}, ::Nothing) =
+    ArrowTypesTestLogicalNullUnion(nothing)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestLogicalNullUnion}, x::AbstractString) =
+    ArrowTypesTestLogicalNullUnion(String(x))
+
+struct ArrowTypesTestAmbiguousMissingUnion
+    value::Union{Missing,String}
+end
+Base.:(==)(a::ArrowTypesTestAmbiguousMissingUnion, b::ArrowTypesTestAmbiguousMissingUnion) =
+    isequal(a.value, b.value)
+Base.isequal(
+    a::ArrowTypesTestAmbiguousMissingUnion,
+    b::ArrowTypesTestAmbiguousMissingUnion,
+) = isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_AMBIGUOUS_MISSING_UNION_NAME =
+    Symbol("JuliaLang.ArrowTests.AmbiguousMissingUnion")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAmbiguousMissingUnion}) = Union{Missing,String}
+ArrowTypes.toarrow(x::ArrowTypesTestAmbiguousMissingUnion) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestAmbiguousMissingUnion}) =
+    ARROWTYPES_TEST_AMBIGUOUS_MISSING_UNION_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_AMBIGUOUS_MISSING_UNION_NAME}, S, metadata) =
+    ArrowTypesTestAmbiguousMissingUnion
+ArrowTypes.fromarrow(::Type{ArrowTypesTestAmbiguousMissingUnion}, ::Missing) =
+    ArrowTypesTestAmbiguousMissingUnion(missing)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestAmbiguousMissingUnion}, x::AbstractString) =
+    ArrowTypesTestAmbiguousMissingUnion(String(x))
+
+struct ArrowTypesTestNamedWriteOnly
+    value::Int32
+end
+const ARROWTYPES_TEST_NAMED_WRITE_ONLY = Symbol("JuliaLang.ArrowTests.NamedWriteOnly")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNamedWriteOnly}) = Int32
+ArrowTypes.toarrow(x::ArrowTypesTestNamedWriteOnly) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestNamedWriteOnly}) =
+    ARROWTYPES_TEST_NAMED_WRITE_ONLY
+ArrowTypes.arrowmetadata(::Type{ArrowTypesTestNamedWriteOnly}) = "write-only"
+
+abstract type ArrowTypesTestAbstractReadID end
+struct ArrowTypesTestConcreteWriteID <: ArrowTypesTestAbstractReadID
+    value::Int32
+end
+Base.:(==)(a::ArrowTypesTestConcreteWriteID, b::ArrowTypesTestConcreteWriteID) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestConcreteWriteID, b::ArrowTypesTestConcreteWriteID) =
+    isequal(a.value, b.value)
+const ARROWTYPES_TEST_ABSTRACT_READ_ID = Symbol("JuliaLang.ArrowTests.AbstractReadID")
+const ARROWTYPES_TEST_CONCRETE_WRITE_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestConcreteWriteID}) = Int32
+function ArrowTypes.toarrow(x::ArrowTypesTestConcreteWriteID)
+    ARROWTYPES_TEST_CONCRETE_WRITE_CALLS[] += 1
+    return x.value
+end
+ArrowTypes.arrowname(::Type{ArrowTypesTestConcreteWriteID}) =
+    ARROWTYPES_TEST_ABSTRACT_READ_ID
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ABSTRACT_READ_ID}, S, metadata) =
+    ArrowTypesTestAbstractReadID
+ArrowTypes.fromarrow(::Type{ArrowTypesTestAbstractReadID}, x::Int32) =
+    ArrowTypesTestConcreteWriteID(x)
+
+abstract type ArrowTypesTestManyDictRuntime end
+struct ArrowTypesTestManyDictValue{N} <: ArrowTypesTestManyDictRuntime
+    value::Int16
+end
+const ARROWTYPES_TEST_MANY_DICT_TYPE_CALLS = Ref(0)
+function ArrowTypes.ArrowType(::Type{<:ArrowTypesTestManyDictValue})
+    ARROWTYPES_TEST_MANY_DICT_TYPE_CALLS[] += 1
+    return Int16
+end
+ArrowTypes.toarrow(x::ArrowTypesTestManyDictValue) = x.value
+
+function arrowtypes_test_many_dict_values(n::Int)
+    values = ArrowTypesTestManyDictRuntime[]
+    for i = 1:n
+        T = Core.apply_type(ArrowTypesTestManyDictValue, i)
+        push!(values, T(Int16(i)))
+    end
+    return values
+end
+
+abstract type ArrowTypesTestManyRegisteredRuntime end
+struct ArrowTypesTestManyRegisteredValue{N} <: ArrowTypesTestManyRegisteredRuntime
+    value::Int16
+end
+
+const ARROWTYPES_TEST_MANY_REGISTERED_NAME =
+    Symbol("JuliaLang.ArrowTests.ManyRegisteredRuntime")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestManyRegisteredRuntime}) = Int16
+ArrowTypes.ArrowType(::Type{<:ArrowTypesTestManyRegisteredValue}) = Int16
+ArrowTypes.toarrow(x::ArrowTypesTestManyRegisteredValue) = x.value
+ArrowTypes.arrowname(::Type{<:ArrowTypesTestManyRegisteredRuntime}) =
+    ARROWTYPES_TEST_MANY_REGISTERED_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_MANY_REGISTERED_NAME}, S, metadata) =
+    ArrowTypesTestManyRegisteredRuntime
+ArrowTypes.fromarrow(::Type{ArrowTypesTestManyRegisteredRuntime}, x::Int16) =
+    ArrowTypesTestManyRegisteredValue{0}(x)
+
+function arrowtypes_test_many_registered_values(n::Int)
+    values = ArrowTypesTestManyRegisteredRuntime[]
+    for i = 1:n
+        T = Core.apply_type(ArrowTypesTestManyRegisteredValue, i)
+        push!(values, T(Int16(i)))
+    end
+    return values
+end
+
+abstract type ArrowTypesTestAbstractTupleStorage end
+struct ArrowTypesTestTupleStorageValue{N} <: ArrowTypesTestAbstractTupleStorage
+    value::Int16
+end
+
+const ARROWTYPES_TEST_TUPLE_STORAGE_LOWER_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAbstractTupleStorage}) = Tuple
+function ArrowTypes.toarrow(x::ArrowTypesTestTupleStorageValue{N}) where {N}
+    ARROWTYPES_TEST_TUPLE_STORAGE_LOWER_CALLS[] += 1
+    return ntuple(_ -> x.value, Val(N))
+end
+
+function arrowtypes_test_tuple_storage_value(n::Int, value::Integer=n)
+    T = Core.apply_type(ArrowTypesTestTupleStorageValue, n)
+    return T(Int16(value))
+end
+
+struct ArrowTypesTestFlexTuple
+    values::Vector{Int16}
+end
+Base.:(==)(a::ArrowTypesTestFlexTuple, b::ArrowTypesTestFlexTuple) = a.values == b.values
+Base.isequal(a::ArrowTypesTestFlexTuple, b::ArrowTypesTestFlexTuple) =
+    isequal(a.values, b.values)
+Base.hash(x::ArrowTypesTestFlexTuple, h::UInt) = hash(x.values, h)
+
+const ARROWTYPES_TEST_FLEX_TUPLE_NAME = Symbol("JuliaLang.ArrowTests.FlexTuple")
+const ARROWTYPES_TEST_FLEX_TUPLE_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestFlexTuple}) = Tuple
+function ArrowTypes.toarrow(x::ArrowTypesTestFlexTuple)
+    ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] += 1
+    return Tuple(x.values)
+end
+ArrowTypes.arrowname(::Type{ArrowTypesTestFlexTuple}) = ARROWTYPES_TEST_FLEX_TUPLE_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_FLEX_TUPLE_NAME}, S, metadata) =
+    ArrowTypesTestFlexTuple
+ArrowTypes.fromarrow(::Type{ArrowTypesTestFlexTuple}, x) =
+    ArrowTypesTestFlexTuple(Int16[x...])
+
+abstract type ArrowTypesTestSameFieldStorage end
+struct ArrowTypesTestSameFieldStorageValue{N} <: ArrowTypesTestSameFieldStorage
+    value::Int16
+end
+abstract type ArrowTypesTestSameFieldLogical end
+struct ArrowTypesTestSameFieldLogicalValue{N} <: ArrowTypesTestSameFieldLogical
+    value::Int16
+end
+
+const ARROWTYPES_TEST_SAME_FIELD_NAME = Symbol("JuliaLang.ArrowTests.SameFieldStorage")
+const ARROWTYPES_TEST_SAME_FIELD_LOWER_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestSameFieldStorageValue{N}}) where {N} = Int16
+ArrowTypes.toarrow(x::ArrowTypesTestSameFieldStorageValue) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestSameFieldStorageValue{N}}) where {N} =
+    ARROWTYPES_TEST_SAME_FIELD_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_SAME_FIELD_NAME}, S, metadata) =
+    ArrowTypesTestSameFieldStorage
+ArrowTypes.fromarrow(::Type{ArrowTypesTestSameFieldStorage}, x::Int16) =
+    ArrowTypesTestSameFieldStorageValue{0}(x)
+
+ArrowTypes.ArrowType(::Type{ArrowTypesTestSameFieldLogical}) =
+    ArrowTypesTestSameFieldStorage
+function ArrowTypes.toarrow(x::ArrowTypesTestSameFieldLogicalValue{N}) where {N}
+    ARROWTYPES_TEST_SAME_FIELD_LOWER_CALLS[] += 1
+    return ArrowTypesTestSameFieldStorageValue{N}(x.value)
+end
+
+function arrowtypes_test_same_field_values(range)
+    values = ArrowTypesTestSameFieldLogical[]
+    for n in range
+        T = Core.apply_type(ArrowTypesTestSameFieldLogicalValue, n)
+        push!(values, T(Int16(n)))
+    end
+    return values
+end
+
+struct ArrowTypesTestDeclaredRegisteredUnionValue{N}
+    value::Int16
+end
+
+Base.:(==)(
+    a::ArrowTypesTestDeclaredRegisteredUnionValue,
+    b::ArrowTypesTestDeclaredRegisteredUnionValue,
+) = typeof(a) === typeof(b) && a.value == b.value
+ArrowTypes.ArrowType(::Type{<:ArrowTypesTestDeclaredRegisteredUnionValue}) = Int16
+ArrowTypes.toarrow(x::ArrowTypesTestDeclaredRegisteredUnionValue) = x.value
+ArrowTypes.fromarrow(
+    ::Type{ArrowTypesTestDeclaredRegisteredUnionValue{N}},
+    x::Int16,
+) where {N} = ArrowTypesTestDeclaredRegisteredUnionValue{N}(x)
+
+const ARROWTYPES_TEST_DECLARED_REGISTERED_UNION_NAMES =
+    ntuple(n -> Symbol("JuliaLang.ArrowTests.DeclaredRegisteredUnionValue.$n"), 9)
+ArrowTypes.arrowname(::Type{ArrowTypesTestDeclaredRegisteredUnionValue{N}}) where {N} =
+    ARROWTYPES_TEST_DECLARED_REGISTERED_UNION_NAMES[N]
+for n = 1:9
+    T = Core.apply_type(ArrowTypesTestDeclaredRegisteredUnionValue, n)
+    name = ARROWTYPES_TEST_DECLARED_REGISTERED_UNION_NAMES[n]
+    @eval ArrowTypes.JuliaType(::Val{$(QuoteNode(name))}, S, metadata) = $T
+end
+
+const ArrowTypesTestDeclaredRegisteredUnion = Union{
+    ArrowTypesTestDeclaredRegisteredUnionValue{1},
+    ArrowTypesTestDeclaredRegisteredUnionValue{2},
+    ArrowTypesTestDeclaredRegisteredUnionValue{3},
+    ArrowTypesTestDeclaredRegisteredUnionValue{4},
+    ArrowTypesTestDeclaredRegisteredUnionValue{5},
+    ArrowTypesTestDeclaredRegisteredUnionValue{6},
+    ArrowTypesTestDeclaredRegisteredUnionValue{7},
+    ArrowTypesTestDeclaredRegisteredUnionValue{8},
+    ArrowTypesTestDeclaredRegisteredUnionValue{9},
+}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestDeclaredRegisteredUnion}) =
+    ArrowTypesTestDeclaredRegisteredUnion
+
+struct ArrowTypesTestNestedLeaf
+    value::Int16
+end
+struct ArrowTypesTestNestedFixed
+    value::NTuple{2,ArrowTypesTestNestedLeaf}
+end
+struct ArrowTypesTestNestedList
+    value::Vector{ArrowTypesTestNestedLeaf}
+end
+struct ArrowTypesTestNestedUnion
+    value::Union{ArrowTypesTestNestedFixed,ArrowTypesTestNestedList}
+end
+struct ArrowTypesTestNestedOuter
+    value::Vector{ArrowTypesTestNestedUnion}
+end
+
+Base.:(==)(a::ArrowTypesTestNestedLeaf, b::ArrowTypesTestNestedLeaf) = a.value == b.value
+Base.:(==)(a::ArrowTypesTestNestedFixed, b::ArrowTypesTestNestedFixed) = a.value == b.value
+Base.:(==)(a::ArrowTypesTestNestedList, b::ArrowTypesTestNestedList) = a.value == b.value
+Base.:(==)(a::ArrowTypesTestNestedUnion, b::ArrowTypesTestNestedUnion) = a.value == b.value
+Base.:(==)(a::ArrowTypesTestNestedOuter, b::ArrowTypesTestNestedOuter) = a.value == b.value
+
+const ARROWTYPES_TEST_NESTED_LEAF_NAME = Symbol("JuliaLang.ArrowTests.NestedLeaf")
+const ARROWTYPES_TEST_NESTED_FIXED_NAME = Symbol("JuliaLang.ArrowTests.NestedFixed")
+const ARROWTYPES_TEST_NESTED_LIST_NAME = Symbol("JuliaLang.ArrowTests.NestedList")
+const ARROWTYPES_TEST_NESTED_UNION_NAME = Symbol("JuliaLang.ArrowTests.NestedUnion")
+const ARROWTYPES_TEST_NESTED_OUTER_NAME = Symbol("JuliaLang.ArrowTests.NestedOuter")
+
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedLeaf}) = Int16
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedFixed}) = NTuple{2,ArrowTypesTestNestedLeaf}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedList}) = Vector{ArrowTypesTestNestedLeaf}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedUnion}) =
+    Union{ArrowTypesTestNestedFixed,ArrowTypesTestNestedList}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedOuter}) = Vector{ArrowTypesTestNestedUnion}
+
+ArrowTypes.toarrow(x::ArrowTypesTestNestedLeaf) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedFixed) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedList) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedUnion) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedOuter) = x.value
+
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedLeaf}) = ARROWTYPES_TEST_NESTED_LEAF_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedFixed}) = ARROWTYPES_TEST_NESTED_FIXED_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedList}) = ARROWTYPES_TEST_NESTED_LIST_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedUnion}) = ARROWTYPES_TEST_NESTED_UNION_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedOuter}) = ARROWTYPES_TEST_NESTED_OUTER_NAME
+
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_LEAF_NAME}, S, metadata) =
+    ArrowTypesTestNestedLeaf
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_FIXED_NAME}, S, metadata) =
+    ArrowTypesTestNestedFixed
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_LIST_NAME}, S, metadata) =
+    ArrowTypesTestNestedList
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_UNION_NAME}, S, metadata) =
+    ArrowTypesTestNestedUnion
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_OUTER_NAME}, S, metadata) =
+    ArrowTypesTestNestedOuter
+
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNestedLeaf}, x::Int16) =
+    ArrowTypesTestNestedLeaf(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNestedFixed}, x) =
+    ArrowTypesTestNestedFixed(Tuple(ArrowTypesTestNestedLeaf[y for y in x]))
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNestedList}, x) =
+    ArrowTypesTestNestedList(collect(ArrowTypesTestNestedLeaf, x))
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNestedUnion}, x::ArrowTypesTestNestedFixed) =
+    ArrowTypesTestNestedUnion(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNestedUnion}, x::ArrowTypesTestNestedList) =
+    ArrowTypesTestNestedUnion(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNestedOuter}, x) =
+    ArrowTypesTestNestedOuter(collect(ArrowTypesTestNestedUnion, x))
+
+abstract type ArrowTypesTestNestedAbstractLeaf end
+struct ArrowTypesTestNestedAbstractLeafValue <: ArrowTypesTestNestedAbstractLeaf
+    value::Int32
+end
+struct ArrowTypesTestNestedAbstractFixed
+    value::NTuple{2,ArrowTypesTestNestedAbstractLeaf}
+end
+struct ArrowTypesTestNestedAbstractList
+    value::Vector{ArrowTypesTestNestedAbstractLeaf}
+end
+struct ArrowTypesTestNestedAbstractUnion
+    value::Union{ArrowTypesTestNestedAbstractFixed,ArrowTypesTestNestedAbstractList}
+end
+struct ArrowTypesTestNestedAbstractOuter
+    value::Vector{ArrowTypesTestNestedAbstractUnion}
+end
+
+const ARROWTYPES_TEST_NESTED_ABSTRACT_LEAF_NAME =
+    Symbol("JuliaLang.ArrowTests.NestedAbstractLeaf")
+const ARROWTYPES_TEST_NESTED_ABSTRACT_FIXED_NAME =
+    Symbol("JuliaLang.ArrowTests.NestedAbstractFixed")
+const ARROWTYPES_TEST_NESTED_ABSTRACT_LIST_NAME =
+    Symbol("JuliaLang.ArrowTests.NestedAbstractList")
+const ARROWTYPES_TEST_NESTED_ABSTRACT_UNION_NAME =
+    Symbol("JuliaLang.ArrowTests.NestedAbstractUnion")
+const ARROWTYPES_TEST_NESTED_ABSTRACT_OUTER_NAME =
+    Symbol("JuliaLang.ArrowTests.NestedAbstractOuter")
+
+ArrowTypes.ArrowType(::Type{<:ArrowTypesTestNestedAbstractLeaf}) = Int32
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedAbstractFixed}) =
+    NTuple{2,ArrowTypesTestNestedAbstractLeaf}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedAbstractList}) =
+    Vector{ArrowTypesTestNestedAbstractLeaf}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedAbstractUnion}) =
+    Union{ArrowTypesTestNestedAbstractFixed,ArrowTypesTestNestedAbstractList}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedAbstractOuter}) =
+    Vector{ArrowTypesTestNestedAbstractUnion}
+
+ArrowTypes.toarrow(x::ArrowTypesTestNestedAbstractLeafValue) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedAbstractFixed) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedAbstractList) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedAbstractUnion) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestNestedAbstractOuter) = x.value
+
+ArrowTypes.arrowname(::Type{<:ArrowTypesTestNestedAbstractLeaf}) =
+    ARROWTYPES_TEST_NESTED_ABSTRACT_LEAF_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedAbstractFixed}) =
+    ARROWTYPES_TEST_NESTED_ABSTRACT_FIXED_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedAbstractList}) =
+    ARROWTYPES_TEST_NESTED_ABSTRACT_LIST_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedAbstractUnion}) =
+    ARROWTYPES_TEST_NESTED_ABSTRACT_UNION_NAME
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedAbstractOuter}) =
+    ARROWTYPES_TEST_NESTED_ABSTRACT_OUTER_NAME
+
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_ABSTRACT_LEAF_NAME}, S, metadata) =
+    ArrowTypesTestNestedAbstractLeaf
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_ABSTRACT_FIXED_NAME}, S, metadata) =
+    ArrowTypesTestNestedAbstractFixed
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_ABSTRACT_LIST_NAME}, S, metadata) =
+    ArrowTypesTestNestedAbstractList
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_ABSTRACT_UNION_NAME}, S, metadata) =
+    ArrowTypesTestNestedAbstractUnion
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_ABSTRACT_OUTER_NAME}, S, metadata) =
+    ArrowTypesTestNestedAbstractOuter
+
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNestedAbstractLeaf}, x::Int32) =
+    ArrowTypesTestNestedAbstractLeafValue(x)
+
+abstract type ArrowTypesTestAbstractUnionRead end
+struct ArrowTypesTestConcreteUnionWrite <: ArrowTypesTestAbstractUnionRead
+    value::Union{Int64,String}
+end
+Base.:(==)(a::ArrowTypesTestConcreteUnionWrite, b::ArrowTypesTestConcreteUnionWrite) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestConcreteUnionWrite, b::ArrowTypesTestConcreteUnionWrite) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_ABSTRACT_UNION_READ_NAME =
+    Symbol("JuliaLang.ArrowTests.AbstractUnionRead")
+const ARROWTYPES_TEST_CONCRETE_UNION_WRITE_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAbstractUnionRead}) = Union{Int64,String}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestConcreteUnionWrite}) = Union{Int64,String}
+function ArrowTypes.toarrow(x::ArrowTypesTestConcreteUnionWrite)
+    ARROWTYPES_TEST_CONCRETE_UNION_WRITE_CALLS[] += 1
+    return x.value
+end
+ArrowTypes.arrowname(::Type{<:ArrowTypesTestAbstractUnionRead}) =
+    ARROWTYPES_TEST_ABSTRACT_UNION_READ_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ABSTRACT_UNION_READ_NAME}, S, metadata) =
+    ArrowTypesTestAbstractUnionRead
+ArrowTypes.fromarrow(::Type{ArrowTypesTestAbstractUnionRead}, x::Int64) =
+    ArrowTypesTestConcreteUnionWrite(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestAbstractUnionRead}, x::AbstractString) =
+    ArrowTypesTestConcreteUnionWrite(String(x))
+
+struct ArrowTypesTestNestedUnionParent
+    child::Union{Missing,ArrowTypesTestAbstractUnionRead}
+end
+Base.:(==)(a::ArrowTypesTestNestedUnionParent, b::ArrowTypesTestNestedUnionParent) =
+    a.child == b.child
+Base.isequal(a::ArrowTypesTestNestedUnionParent, b::ArrowTypesTestNestedUnionParent) =
+    isequal(a.child, b.child)
+
+const ARROWTYPES_TEST_NESTED_UNION_PARENT_NAME =
+    Symbol("JuliaLang.ArrowTests.NestedUnionParent")
+const ArrowTypesTestNestedUnionParentStorage =
+    @NamedTuple{child::Union{Missing,ArrowTypesTestAbstractUnionRead}}
+const ARROWTYPES_TEST_NESTED_UNION_PARENT_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedUnionParent}) =
+    ArrowTypesTestNestedUnionParentStorage
+function ArrowTypes.toarrow(x::ArrowTypesTestNestedUnionParent)
+    ARROWTYPES_TEST_NESTED_UNION_PARENT_CALLS[] += 1
+    return (child=x.child,)
+end
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedUnionParent}) =
+    ARROWTYPES_TEST_NESTED_UNION_PARENT_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_UNION_PARENT_NAME}, S, metadata) =
+    ArrowTypesTestNestedUnionParent
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestNestedUnionParent},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestNestedUnionParent(row.child)
+end
+
+abstract type ArrowTypesTestRoutedRead end
+struct ArrowTypesTestRoutedInt <: ArrowTypesTestRoutedRead
+    value::Int32
+end
+struct ArrowTypesTestRoutedString <: ArrowTypesTestRoutedRead
+    value::String
+end
+Base.:(==)(a::ArrowTypesTestRoutedInt, b::ArrowTypesTestRoutedInt) = a.value == b.value
+Base.:(==)(a::ArrowTypesTestRoutedString, b::ArrowTypesTestRoutedString) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestRoutedInt, b::ArrowTypesTestRoutedInt) =
+    isequal(a.value, b.value)
+Base.isequal(a::ArrowTypesTestRoutedString, b::ArrowTypesTestRoutedString) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_ROUTED_READ_NAME = Symbol("JuliaLang.ArrowTests.RoutedRead")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestRoutedRead}) = Union{Int32,String}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestRoutedInt}) = Int32
+ArrowTypes.ArrowType(::Type{ArrowTypesTestRoutedString}) = String
+ArrowTypes.toarrow(x::ArrowTypesTestRoutedInt) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestRoutedString) = x.value
+ArrowTypes.arrowname(::Type{<:ArrowTypesTestRoutedRead}) = ARROWTYPES_TEST_ROUTED_READ_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ROUTED_READ_NAME}, S, metadata) =
+    ArrowTypesTestRoutedRead
+ArrowTypes.fromarrow(::Type{ArrowTypesTestRoutedRead}, x::Int32) =
+    ArrowTypesTestRoutedInt(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestRoutedRead}, x::AbstractString) =
+    ArrowTypesTestRoutedString(String(x))
+
+struct ArrowTypesTestRecursiveSchema
+    value::Int32
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestRecursiveSchema}) =
+    Vector{ArrowTypesTestRecursiveSchema}
+ArrowTypes.toarrow(::ArrowTypesTestRecursiveSchema) = ArrowTypesTestRecursiveSchema[]
+
+struct ArrowTypesTestRelabeledWriteID <: ArrowTypesTestAbstractReadID
+    value::Int32
+end
+Base.:(==)(a::ArrowTypesTestRelabeledWriteID, b::ArrowTypesTestRelabeledWriteID) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestRelabeledWriteID, b::ArrowTypesTestRelabeledWriteID) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_RELABELED_WRITE_ID_NAME =
+    Symbol("JuliaLang.ArrowTests.RelabeledWriteID")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestRelabeledWriteID}) = Int32
+ArrowTypes.toarrow(x::ArrowTypesTestRelabeledWriteID) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestRelabeledWriteID}) =
+    ARROWTYPES_TEST_RELABELED_WRITE_ID_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_RELABELED_WRITE_ID_NAME}, S, metadata) =
+    ArrowTypesTestRelabeledWriteID
+ArrowTypes.fromarrow(::Type{ArrowTypesTestRelabeledWriteID}, x::Int32) =
+    ArrowTypesTestRelabeledWriteID(x)
+
+abstract type ArrowTypesTestAmbiguousRouteRead end
+struct ArrowTypesTestAmbiguousRouteLeft <: ArrowTypesTestAmbiguousRouteRead
+    value::Int32
+end
+struct ArrowTypesTestAmbiguousRouteRight <: ArrowTypesTestAmbiguousRouteRead
+    value::Int32
+end
+Base.:(==)(a::ArrowTypesTestAmbiguousRouteLeft, b::ArrowTypesTestAmbiguousRouteLeft) =
+    a.value == b.value
+Base.:(==)(a::ArrowTypesTestAmbiguousRouteRight, b::ArrowTypesTestAmbiguousRouteRight) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestAmbiguousRouteLeft, b::ArrowTypesTestAmbiguousRouteLeft) =
+    isequal(a.value, b.value)
+Base.isequal(a::ArrowTypesTestAmbiguousRouteRight, b::ArrowTypesTestAmbiguousRouteRight) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_AMBIGUOUS_ROUTE_NAME = Symbol("JuliaLang.ArrowTests.AmbiguousRoute")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAmbiguousRouteRead}) =
+    Union{ArrowTypesTestAmbiguousRouteLeft,ArrowTypesTestAmbiguousRouteRight}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAmbiguousRouteLeft}) = Int32
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAmbiguousRouteRight}) = Int32
+ArrowTypes.toarrow(x::ArrowTypesTestAmbiguousRouteLeft) = x.value
+ArrowTypes.toarrow(x::ArrowTypesTestAmbiguousRouteRight) = -x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestAmbiguousRouteRead}) =
+    ARROWTYPES_TEST_AMBIGUOUS_ROUTE_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_AMBIGUOUS_ROUTE_NAME}, S, metadata) =
+    ArrowTypesTestAmbiguousRouteRead
+ArrowTypes.fromarrow(::Type{ArrowTypesTestAmbiguousRouteRead}, x::Int32) =
+    x < 0 ? ArrowTypesTestAmbiguousRouteRight(-x) : ArrowTypesTestAmbiguousRouteLeft(x)
+
+struct ArrowTypesTestSecondTimestamp
+    value::DateTime
+end
+Base.:(==)(a::ArrowTypesTestSecondTimestamp, b::ArrowTypesTestSecondTimestamp) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestSecondTimestamp, b::ArrowTypesTestSecondTimestamp) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_SECOND_TIMESTAMP_NAME = Symbol("JuliaLang.ArrowTests.SecondTimestamp")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestSecondTimestamp}) = DateTime
+ArrowTypes.toarrow(x::ArrowTypesTestSecondTimestamp) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestSecondTimestamp}) =
+    ARROWTYPES_TEST_SECOND_TIMESTAMP_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_SECOND_TIMESTAMP_NAME}, S, metadata) =
+    ArrowTypesTestSecondTimestamp
+ArrowTypes.fromarrow(::Type{ArrowTypesTestSecondTimestamp}, x::DateTime) =
+    ArrowTypesTestSecondTimestamp(x)
+
+struct ArrowTypesTestNestedLogicalUnion
+    child::ArrowTypesTestLogicalUnion
+end
+Base.:(==)(a::ArrowTypesTestNestedLogicalUnion, b::ArrowTypesTestNestedLogicalUnion) =
+    a.child == b.child
+Base.isequal(a::ArrowTypesTestNestedLogicalUnion, b::ArrowTypesTestNestedLogicalUnion) =
+    isequal(a.child, b.child)
+
+const ARROWTYPES_TEST_NESTED_LOGICAL_UNION_NAME =
+    Symbol("JuliaLang.ArrowTests.NestedLogicalUnion")
+const ArrowTypesTestNestedLogicalUnionStorage =
+    @NamedTuple{child::ArrowTypesTestLogicalUnion}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNestedLogicalUnion}) =
+    ArrowTypesTestNestedLogicalUnionStorage
+ArrowTypes.toarrow(x::ArrowTypesTestNestedLogicalUnion) = (child=x.child,)
+ArrowTypes.arrowname(::Type{ArrowTypesTestNestedLogicalUnion}) =
+    ARROWTYPES_TEST_NESTED_LOGICAL_UNION_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NESTED_LOGICAL_UNION_NAME}, S, metadata) =
+    ArrowTypesTestNestedLogicalUnion
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestNestedLogicalUnion},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestNestedLogicalUnion(row.child)
+end
+
+struct ArrowTypesTestKindCountedUnion
+    value::Union{Int64,String}
+end
+Base.:(==)(a::ArrowTypesTestKindCountedUnion, b::ArrowTypesTestKindCountedUnion) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestKindCountedUnion, b::ArrowTypesTestKindCountedUnion) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_KIND_COUNTED_UNION_NAME =
+    Symbol("JuliaLang.ArrowTests.KindCountedUnion")
+const ARROWTYPES_TEST_KIND_COUNTED_UNION_CALLS = Ref(0)
+function ArrowTypes.ArrowKind(::Type{ArrowTypesTestKindCountedUnion})
+    ARROWTYPES_TEST_KIND_COUNTED_UNION_CALLS[] += 1
+    return ArrowTypes.StructKind()
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestKindCountedUnion}) = Union{Int64,String}
+ArrowTypes.toarrow(x::ArrowTypesTestKindCountedUnion) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestKindCountedUnion}) =
+    ARROWTYPES_TEST_KIND_COUNTED_UNION_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_KIND_COUNTED_UNION_NAME}, S, metadata) =
+    ArrowTypesTestKindCountedUnion
+ArrowTypes.fromarrow(::Type{ArrowTypesTestKindCountedUnion}, x::Int64) =
+    ArrowTypesTestKindCountedUnion(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestKindCountedUnion}, x::AbstractString) =
+    ArrowTypesTestKindCountedUnion(String(x))
+
+struct ArrowTypesTestRelabeledUnionWrite <: ArrowTypesTestAbstractUnionRead
+    value::Union{Int64,String}
+end
+Base.:(==)(a::ArrowTypesTestRelabeledUnionWrite, b::ArrowTypesTestRelabeledUnionWrite) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestRelabeledUnionWrite, b::ArrowTypesTestRelabeledUnionWrite) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_RELABELED_UNION_WRITE_NAME =
+    Symbol("JuliaLang.ArrowTests.RelabeledUnionWrite")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestRelabeledUnionWrite}) = Union{Int64,String}
+ArrowTypes.toarrow(x::ArrowTypesTestRelabeledUnionWrite) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestRelabeledUnionWrite}) =
+    ARROWTYPES_TEST_RELABELED_UNION_WRITE_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_RELABELED_UNION_WRITE_NAME}, S, metadata) =
+    ArrowTypesTestRelabeledUnionWrite
+ArrowTypes.fromarrow(::Type{ArrowTypesTestRelabeledUnionWrite}, x::Int64) =
+    ArrowTypesTestRelabeledUnionWrite(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestRelabeledUnionWrite}, x::AbstractString) =
+    ArrowTypesTestRelabeledUnionWrite(String(x))
+
+struct ArrowTypesTestMillisecondDuration
+    value::Dates.Millisecond
+end
+Base.:(==)(a::ArrowTypesTestMillisecondDuration, b::ArrowTypesTestMillisecondDuration) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestMillisecondDuration, b::ArrowTypesTestMillisecondDuration) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_MILLISECOND_DURATION_NAME =
+    Symbol("JuliaLang.ArrowTests.MillisecondDuration")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestMillisecondDuration}) = Dates.Millisecond
+ArrowTypes.toarrow(x::ArrowTypesTestMillisecondDuration) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestMillisecondDuration}) =
+    ARROWTYPES_TEST_MILLISECOND_DURATION_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_MILLISECOND_DURATION_NAME}, S, metadata) =
+    ArrowTypesTestMillisecondDuration
+ArrowTypes.fromarrow(::Type{ArrowTypesTestMillisecondDuration}, x::Dates.Period) =
+    ArrowTypesTestMillisecondDuration(convert(Dates.Millisecond, x))
+
+struct ArrowTypesTestDateLikeAlias
+    value::DateTime
+end
+Base.:(==)(a::ArrowTypesTestDateLikeAlias, b::ArrowTypesTestDateLikeAlias) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestDateLikeAlias, b::ArrowTypesTestDateLikeAlias) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_DATE_LIKE_ALIAS_NAME = Symbol("JuliaLang.ArrowTests.DateLikeAlias")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestDateLikeAlias}) = DateTime
+ArrowTypes.toarrow(x::ArrowTypesTestDateLikeAlias) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestDateLikeAlias}) =
+    ARROWTYPES_TEST_DATE_LIKE_ALIAS_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_DATE_LIKE_ALIAS_NAME}, S, metadata) =
+    ArrowTypesTestDateLikeAlias
+ArrowTypes.fromarrow(::Type{ArrowTypesTestDateLikeAlias}, x::Date) =
+    ArrowTypesTestDateLikeAlias(DateTime(x))
+ArrowTypes.fromarrow(::Type{ArrowTypesTestDateLikeAlias}, x::DateTime) =
+    ArrowTypesTestDateLikeAlias(x)
+
+struct ArrowTypesTestSortedMap
+    value::Dict{Int32,Int32}
+end
+Base.:(==)(a::ArrowTypesTestSortedMap, b::ArrowTypesTestSortedMap) = a.value == b.value
+Base.isequal(a::ArrowTypesTestSortedMap, b::ArrowTypesTestSortedMap) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_SORTED_MAP_NAME = Symbol("JuliaLang.ArrowTests.SortedMap")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestSortedMap}) = Dict{Int32,Int32}
+ArrowTypes.toarrow(x::ArrowTypesTestSortedMap) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestSortedMap}) = ARROWTYPES_TEST_SORTED_MAP_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_SORTED_MAP_NAME}, S, metadata) =
+    ArrowTypesTestSortedMap
+ArrowTypes.fromarrow(::Type{ArrowTypesTestSortedMap}, x::AbstractDict) =
+    ArrowTypesTestSortedMap(Dict{Int32,Int32}(x))
+
+struct ArrowTypesTestBytesAlias
+    value::Vector{UInt8}
+end
+Base.:(==)(a::ArrowTypesTestBytesAlias, b::ArrowTypesTestBytesAlias) = a.value == b.value
+Base.isequal(a::ArrowTypesTestBytesAlias, b::ArrowTypesTestBytesAlias) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_BYTES_ALIAS_NAME = Symbol("JuliaLang.ArrowTests.BytesAlias")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestBytesAlias}) = Vector{UInt8}
+ArrowTypes.toarrow(x::ArrowTypesTestBytesAlias) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestBytesAlias}) = ARROWTYPES_TEST_BYTES_ALIAS_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_BYTES_ALIAS_NAME}, S, metadata) =
+    ArrowTypesTestBytesAlias
+ArrowTypes.fromarrow(::Type{ArrowTypesTestBytesAlias}, x::AbstractVector{UInt8}) =
+    ArrowTypesTestBytesAlias(collect(UInt8, x))
+# FixedSizeBinary storage reaches ArrowTypes hooks as NTuple{N,UInt8}.
+ArrowTypes.fromarrow(::Type{ArrowTypesTestBytesAlias}, x::NTuple{N,UInt8}) where {N} =
+    ArrowTypesTestBytesAlias(collect(UInt8, x))
+
+struct ArrowTypesTestIntListAlias
+    value::Vector{Int32}
+end
+Base.:(==)(a::ArrowTypesTestIntListAlias, b::ArrowTypesTestIntListAlias) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestIntListAlias, b::ArrowTypesTestIntListAlias) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_INT_LIST_ALIAS_NAME = Symbol("JuliaLang.ArrowTests.IntListAlias")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestIntListAlias}) = Vector{Int32}
+ArrowTypes.toarrow(x::ArrowTypesTestIntListAlias) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestIntListAlias}) =
+    ARROWTYPES_TEST_INT_LIST_ALIAS_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_INT_LIST_ALIAS_NAME}, S, metadata) =
+    ArrowTypesTestIntListAlias
+ArrowTypes.fromarrow(::Type{ArrowTypesTestIntListAlias}, x) =
+    ArrowTypesTestIntListAlias(collect(Int32, x))
+
+struct ArrowTypesTestFixedList3
+    value::NTuple{3,Int32}
+end
+
+const ARROWTYPES_TEST_FIXED_LIST3_NAME = Symbol("JuliaLang.ArrowTests.FixedList3")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestFixedList3}) = NTuple{3,Int32}
+ArrowTypes.toarrow(x::ArrowTypesTestFixedList3) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestFixedList3}) = ARROWTYPES_TEST_FIXED_LIST3_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_FIXED_LIST3_NAME}, S, metadata) =
+    ArrowTypesTestFixedList3
+ArrowTypes.fromarrow(::Type{ArrowTypesTestFixedList3}, x) =
+    ArrowTypesTestFixedList3(Tuple(Int32[y for y in x]))
+
+struct ArrowTypesTestWrongStorage
+    value::String
+end
+
+const ARROWTYPES_TEST_WRONG_STORAGE_NAME = Symbol("JuliaLang.ArrowTests.WrongStorage")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestWrongStorage}) = String
+ArrowTypes.toarrow(x::ArrowTypesTestWrongStorage) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestWrongStorage}) =
+    ARROWTYPES_TEST_WRONG_STORAGE_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_WRONG_STORAGE_NAME}, S, metadata) =
+    ArrowTypesTestWrongStorage
+ArrowTypes.fromarrow(::Type{ArrowTypesTestWrongStorage}, x::AbstractString) =
+    ArrowTypesTestWrongStorage(String(x))
+
+struct ArrowTypesTestPlanCounted
+    value::Int32
+end
+
+const ARROWTYPES_TEST_PLAN_COUNTED_NAME = Symbol("JuliaLang.ArrowTests.PlanCounted")
+const ARROWTYPES_TEST_PLAN_COUNTED_KIND_CALLS = Ref(0)
+const ARROWTYPES_TEST_PLAN_COUNTED_NAME_CALLS = Ref(0)
+const ARROWTYPES_TEST_PLAN_COUNTED_LOWER_CALLS = Ref(0)
+function ArrowTypes.ArrowKind(::Type{ArrowTypesTestPlanCounted})
+    ARROWTYPES_TEST_PLAN_COUNTED_KIND_CALLS[] += 1
+    return ArrowTypes.PrimitiveKind()
+end
+ArrowTypes.ArrowType(::Type{ArrowTypesTestPlanCounted}) = Int32
+function ArrowTypes.toarrow(x::ArrowTypesTestPlanCounted)
+    ARROWTYPES_TEST_PLAN_COUNTED_LOWER_CALLS[] += 1
+    return x.value
+end
+function ArrowTypes.hasarrowname(::Type{ArrowTypesTestPlanCounted})
+    ARROWTYPES_TEST_PLAN_COUNTED_NAME_CALLS[] += 1
+    return true
+end
+ArrowTypes.arrowname(::Type{ArrowTypesTestPlanCounted}) = ARROWTYPES_TEST_PLAN_COUNTED_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_PLAN_COUNTED_NAME}, S, metadata) =
+    ArrowTypesTestPlanCounted
+ArrowTypes.fromarrow(::Type{ArrowTypesTestPlanCounted}, x::Int32) =
+    ArrowTypesTestPlanCounted(x)
+
+abstract type ArrowTypesTestAbstractStringStorage end
+const ARROWTYPES_TEST_ABSTRACT_STRING_STORAGE_NAME =
+    Symbol("JuliaLang.ArrowTests.AbstractStringStorage")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAbstractStringStorage}) = String
+ArrowTypes.arrowname(::Type{ArrowTypesTestAbstractStringStorage}) =
+    ARROWTYPES_TEST_ABSTRACT_STRING_STORAGE_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ABSTRACT_STRING_STORAGE_NAME}, S, metadata) =
+    ArrowTypesTestAbstractStringStorage
+
+abstract type ArrowTypesTestAbstractIdentityStorage end
+const ARROWTYPES_TEST_ABSTRACT_IDENTITY_STORAGE_NAME =
+    Symbol("JuliaLang.ArrowTests.AbstractIdentityStorage")
+ArrowTypes.arrowname(::Type{ArrowTypesTestAbstractIdentityStorage}) =
+    ARROWTYPES_TEST_ABSTRACT_IDENTITY_STORAGE_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ABSTRACT_IDENTITY_STORAGE_NAME}, S, metadata) =
+    ArrowTypesTestAbstractIdentityStorage
+
+const ARROWTYPES_TEST_MALFORMED_JULIATYPE_NAME =
+    Symbol("JuliaLang.ArrowTests.MalformedJuliaType")
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_MALFORMED_JULIATYPE_NAME}, S, metadata) = 42
+
+struct ArrowTypesTestBadLower
+    value::Int8
+end
+
+const ARROWTYPES_TEST_BAD_LOWER_NAME = Symbol("JuliaLang.ArrowTests.BadLower")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestBadLower}) = Int8
+ArrowTypes.toarrow(::ArrowTypesTestBadLower) = Int16(1_000)
+ArrowTypes.arrowname(::Type{ArrowTypesTestBadLower}) = ARROWTYPES_TEST_BAD_LOWER_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_BAD_LOWER_NAME}, S, metadata) =
+    ArrowTypesTestBadLower
+ArrowTypes.fromarrow(::Type{ArrowTypesTestBadLower}, x::Int8) = ArrowTypesTestBadLower(x)
+
+struct ArrowTypesTestBadUnionLower
+    value::Union{Int8,String}
+end
+
+const ARROWTYPES_TEST_BAD_UNION_LOWER_NAME = Symbol("JuliaLang.ArrowTests.BadUnionLower")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestBadUnionLower}) = Union{Int8,String}
+ArrowTypes.toarrow(::ArrowTypesTestBadUnionLower) = Float64(1.5)
+ArrowTypes.arrowname(::Type{ArrowTypesTestBadUnionLower}) =
+    ARROWTYPES_TEST_BAD_UNION_LOWER_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_BAD_UNION_LOWER_NAME}, S, metadata) =
+    ArrowTypesTestBadUnionLower
+ArrowTypes.fromarrow(::Type{ArrowTypesTestBadUnionLower}, x::Int8) =
+    ArrowTypesTestBadUnionLower(x)
+ArrowTypes.fromarrow(::Type{ArrowTypesTestBadUnionLower}, x::AbstractString) =
+    ArrowTypesTestBadUnionLower(String(x))
+
+struct ArrowTypesTestBadStructLower
+    value::Int8
+end
+
+const ArrowTypesTestBadStructStorage = @NamedTuple{a::Int8, b::Int8}
+const ARROWTYPES_TEST_BAD_STRUCT_LOWER_NAME = Symbol("JuliaLang.ArrowTests.BadStructLower")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestBadStructLower}) = ArrowTypesTestBadStructStorage
+ArrowTypes.toarrow(x::ArrowTypesTestBadStructLower) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestBadStructLower}) =
+    ARROWTYPES_TEST_BAD_STRUCT_LOWER_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_BAD_STRUCT_LOWER_NAME}, S, metadata) =
+    ArrowTypesTestBadStructLower
+ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestBadStructLower},
+    ::Val{names},
+    values...,
+) where {names} = ArrowTypesTestBadStructLower(first(values))
+
+struct ArrowTypesTestNullableBytesAlias
+    value::Vector{Union{Missing,UInt8}}
+end
+
+const ARROWTYPES_TEST_NULLABLE_BYTES_ALIAS_NAME =
+    Symbol("JuliaLang.ArrowTests.NullableBytesAlias")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNullableBytesAlias}) =
+    Vector{Union{Missing,UInt8}}
+ArrowTypes.toarrow(x::ArrowTypesTestNullableBytesAlias) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestNullableBytesAlias}) =
+    ARROWTYPES_TEST_NULLABLE_BYTES_ALIAS_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NULLABLE_BYTES_ALIAS_NAME}, S, metadata) =
+    ArrowTypesTestNullableBytesAlias
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNullableBytesAlias}, x) =
+    ArrowTypesTestNullableBytesAlias(collect(Union{Missing,UInt8}, x))
+
+const ArrowTypesTestDayTimeStorage = NamedTuple{(:days, :millis),Tuple{Int32,Int32}}
+struct ArrowTypesTestDayTimeInterval
+    value::ArrowTypesTestDayTimeStorage
+end
+Base.:(==)(a::ArrowTypesTestDayTimeInterval, b::ArrowTypesTestDayTimeInterval) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestDayTimeInterval, b::ArrowTypesTestDayTimeInterval) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_DAY_TIME_INTERVAL_NAME =
+    Symbol("JuliaLang.ArrowTests.DayTimeInterval")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestDayTimeInterval}) = ArrowTypesTestDayTimeStorage
+ArrowTypes.toarrow(x::ArrowTypesTestDayTimeInterval) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestDayTimeInterval}) =
+    ARROWTYPES_TEST_DAY_TIME_INTERVAL_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_DAY_TIME_INTERVAL_NAME}, S, metadata) =
+    ArrowTypesTestDayTimeInterval
+ArrowTypes.fromarrow(
+    ::Type{ArrowTypesTestDayTimeInterval},
+    x::ArrowTypesTestDayTimeStorage,
+) = ArrowTypesTestDayTimeInterval(ArrowTypesTestDayTimeStorage(x))
+
+const ArrowTypesTestMonthDayNanoStorage =
+    NamedTuple{(:months, :days, :nanos),Tuple{Int32,Int32,Int64}}
+struct ArrowTypesTestMonthDayNanoInterval
+    value::ArrowTypesTestMonthDayNanoStorage
+end
+Base.:(==)(a::ArrowTypesTestMonthDayNanoInterval, b::ArrowTypesTestMonthDayNanoInterval) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestMonthDayNanoInterval, b::ArrowTypesTestMonthDayNanoInterval) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_MONTH_DAY_NANO_INTERVAL_NAME =
+    Symbol("JuliaLang.ArrowTests.MonthDayNanoInterval")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestMonthDayNanoInterval}) =
+    ArrowTypesTestMonthDayNanoStorage
+ArrowTypes.toarrow(x::ArrowTypesTestMonthDayNanoInterval) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestMonthDayNanoInterval}) =
+    ARROWTYPES_TEST_MONTH_DAY_NANO_INTERVAL_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_MONTH_DAY_NANO_INTERVAL_NAME}, S, metadata) =
+    ArrowTypesTestMonthDayNanoInterval
+ArrowTypes.fromarrow(
+    ::Type{ArrowTypesTestMonthDayNanoInterval},
+    x::ArrowTypesTestMonthDayNanoStorage,
+) = ArrowTypesTestMonthDayNanoInterval(ArrowTypesTestMonthDayNanoStorage(x))
+
+struct ArrowTypesTestParityID
+    value::Int64
+end
+Base.:(==)(a::ArrowTypesTestParityID, b::ArrowTypesTestParityID) =
+    iseven(a.value) == iseven(b.value)
+Base.isequal(a::ArrowTypesTestParityID, b::ArrowTypesTestParityID) = a == b
+Base.hash(x::ArrowTypesTestParityID, h::UInt) = hash(iseven(x.value), h)
+
+const ARROWTYPES_TEST_PARITY_ID_NAME = Symbol("JuliaLang.ArrowTests.ParityID")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestParityID}) = Int64
+ArrowTypes.toarrow(x::ArrowTypesTestParityID) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestParityID}) = ARROWTYPES_TEST_PARITY_ID_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_PARITY_ID_NAME}, S, metadata) =
+    ArrowTypesTestParityID
+ArrowTypes.fromarrow(::Type{ArrowTypesTestParityID}, x::Int64) = ArrowTypesTestParityID(x)
+
+mutable struct ArrowTypesTestMutableID
+    value::Int64
+end
+Base.:(==)(a::ArrowTypesTestMutableID, b::ArrowTypesTestMutableID) = a.value == b.value
+Base.isequal(a::ArrowTypesTestMutableID, b::ArrowTypesTestMutableID) =
+    isequal(a.value, b.value)
+Base.hash(x::ArrowTypesTestMutableID, h::UInt) = hash(x.value, h)
+
+const ARROWTYPES_TEST_MUTABLE_ID_NAME = Symbol("JuliaLang.ArrowTests.MutableID")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestMutableID}) = Int64
+ArrowTypes.toarrow(x::ArrowTypesTestMutableID) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestMutableID}) = ARROWTYPES_TEST_MUTABLE_ID_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_MUTABLE_ID_NAME}, S, metadata) =
+    ArrowTypesTestMutableID
+ArrowTypes.fromarrow(::Type{ArrowTypesTestMutableID}, x::Int64) = ArrowTypesTestMutableID(x)
+
+struct ArrowTypesTestReverseID
+    value::Int64
+end
+Base.:(==)(a::ArrowTypesTestReverseID, b::ArrowTypesTestReverseID) = a.value == b.value
+Base.isequal(a::ArrowTypesTestReverseID, b::ArrowTypesTestReverseID) =
+    isequal(a.value, b.value)
+Base.hash(x::ArrowTypesTestReverseID, h::UInt) = hash(x.value, h)
+Base.isless(a::ArrowTypesTestReverseID, b::ArrowTypesTestReverseID) =
+    isless(b.value, a.value)
+
+const ARROWTYPES_TEST_REVERSE_ID_NAME = Symbol("JuliaLang.ArrowTests.ReverseID")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestReverseID}) = Int64
+ArrowTypes.toarrow(x::ArrowTypesTestReverseID) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestReverseID}) = ARROWTYPES_TEST_REVERSE_ID_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_REVERSE_ID_NAME}, S, metadata) =
+    ArrowTypesTestReverseID
+ArrowTypes.fromarrow(::Type{ArrowTypesTestReverseID}, x::Int64) = ArrowTypesTestReverseID(x)
+
+struct ArrowTypesTestCollidingMapKey
+    value::Int64
+end
+Base.:(==)(a::ArrowTypesTestCollidingMapKey, b::ArrowTypesTestCollidingMapKey) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestCollidingMapKey, b::ArrowTypesTestCollidingMapKey) =
+    isequal(a.value, b.value)
+Base.hash(x::ArrowTypesTestCollidingMapKey, h::UInt) = hash(x.value, h)
+
+const ARROWTYPES_TEST_COLLIDING_MAP_KEY_NAME =
+    Symbol("JuliaLang.ArrowTests.CollidingMapKey")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestCollidingMapKey}) = Int64
+ArrowTypes.toarrow(::ArrowTypesTestCollidingMapKey) = Int64(0)
+ArrowTypes.arrowname(::Type{ArrowTypesTestCollidingMapKey}) =
+    ARROWTYPES_TEST_COLLIDING_MAP_KEY_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_COLLIDING_MAP_KEY_NAME}, S, metadata) =
+    ArrowTypesTestCollidingMapKey
+ArrowTypes.fromarrow(::Type{ArrowTypesTestCollidingMapKey}, x::Int64) =
+    ArrowTypesTestCollidingMapKey(x)
+
+struct ArrowTypesTestAlternateID
+    value::Int64
+end
+Base.:(==)(a::ArrowTypesTestAlternateID, b::ArrowTypesTestAlternateID) = a.value == b.value
+Base.isequal(a::ArrowTypesTestAlternateID, b::ArrowTypesTestAlternateID) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_ALTERNATE_ID_NAME = Symbol("JuliaLang.ArrowTests.AlternateID")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAlternateID}) = Int64
+ArrowTypes.toarrow(x::ArrowTypesTestAlternateID) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestAlternateID}) = ARROWTYPES_TEST_ALTERNATE_ID_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ALTERNATE_ID_NAME}, S, metadata) =
+    ArrowTypesTestAlternateID
+ArrowTypes.fromarrow(::Type{ArrowTypesTestAlternateID}, x::Int64) =
+    ArrowTypesTestAlternateID(x)
+
+struct ArrowTypesTestLabel
+    value::String
+end
+Base.:(==)(a::ArrowTypesTestLabel, b::ArrowTypesTestLabel) = a.value == b.value
+Base.isequal(a::ArrowTypesTestLabel, b::ArrowTypesTestLabel) = isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_LABEL_NAME = Symbol("JuliaLang.ArrowTests.Label")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestLabel}) = String
+ArrowTypes.toarrow(x::ArrowTypesTestLabel) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestLabel}) = ARROWTYPES_TEST_LABEL_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_LABEL_NAME}, S, metadata) = ArrowTypesTestLabel
+ArrowTypes.fromarrow(::Type{ArrowTypesTestLabel}, x::AbstractString) =
+    ArrowTypesTestLabel(String(x))
+
+struct ArrowTypesTestLabelRow
+    text::ArrowTypesTestLabel
+end
+Base.:(==)(a::ArrowTypesTestLabelRow, b::ArrowTypesTestLabelRow) = a.text == b.text
+Base.isequal(a::ArrowTypesTestLabelRow, b::ArrowTypesTestLabelRow) = isequal(a.text, b.text)
+
+const ARROWTYPES_TEST_LABEL_ROW_NAME = Symbol("JuliaLang.ArrowTests.LabelRow")
+const ArrowTypesTestLabelRowStorage = @NamedTuple{text::ArrowTypesTestLabel}
+const ARROWTYPES_TEST_LABEL_ROW_CALLS = Ref(0)
+ArrowTypes.ArrowType(::Type{ArrowTypesTestLabelRow}) = ArrowTypesTestLabelRowStorage
+function ArrowTypes.toarrow(x::ArrowTypesTestLabelRow)
+    ARROWTYPES_TEST_LABEL_ROW_CALLS[] += 1
+    return (text=x.text,)
+end
+ArrowTypes.arrowname(::Type{ArrowTypesTestLabelRow}) = ARROWTYPES_TEST_LABEL_ROW_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_LABEL_ROW_NAME}, S, metadata) =
+    ArrowTypesTestLabelRow
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestLabelRow},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestLabelRow(row.text)
+end
+
+struct ArrowTypesTestPointerString <: AbstractString
+    value::String
+    ArrowTypesTestPointerString(value::String, ::Val{:decoded}) = new(value)
+end
+
+arrowtypes_test_pointer_string(value::String) =
+    ArrowTypesTestPointerString(value, Val(:decoded))
+Base.ncodeunits(x::ArrowTypesTestPointerString) = ncodeunits(x.value)
+Base.codeunit(::Type{ArrowTypesTestPointerString}) = UInt8
+Base.codeunit(x::ArrowTypesTestPointerString, i::Integer) = codeunit(x.value, i)
+Base.isvalid(x::ArrowTypesTestPointerString, i::Integer) = isvalid(x.value, i)
+Base.iterate(x::ArrowTypesTestPointerString) = iterate(x.value)
+Base.iterate(x::ArrowTypesTestPointerString, state::Integer) = iterate(x.value, state)
+Base.length(x::ArrowTypesTestPointerString) = length(x.value)
+Base.getindex(x::ArrowTypesTestPointerString, i::Int) = x.value[i]
+Base.:(==)(a::ArrowTypesTestPointerString, b::ArrowTypesTestPointerString) =
+    a.value == b.value
+Base.isequal(a::ArrowTypesTestPointerString, b::ArrowTypesTestPointerString) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_POINTER_STRING_NAME = Symbol("JuliaLang.ArrowTests.PointerString")
+const ARROWTYPES_TEST_POINTER_STRING_CALLS = Ref(0)
+const ARROWTYPES_TEST_POINTER_STRING_PREFIX = "physical:"
+ArrowTypes.ArrowType(::Type{ArrowTypesTestPointerString}) = String
+ArrowTypes.toarrow(x::ArrowTypesTestPointerString) =
+    ARROWTYPES_TEST_POINTER_STRING_PREFIX * x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestPointerString}) =
+    ARROWTYPES_TEST_POINTER_STRING_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_POINTER_STRING_NAME}, S, metadata) =
+    ArrowTypesTestPointerString
+function ArrowTypes.fromarrow(
+    ::Type{ArrowTypesTestPointerString},
+    ptr::Ptr{UInt8},
+    len::Int,
+)
+    ARROWTYPES_TEST_POINTER_STRING_CALLS[] += 1
+    storage = unsafe_string(ptr, len)
+    startswith(storage, ARROWTYPES_TEST_POINTER_STRING_PREFIX) ||
+        throw(ArgumentError("PointerString storage does not have its physical prefix"))
+    start = ncodeunits(ARROWTYPES_TEST_POINTER_STRING_PREFIX) + 1
+    return ArrowTypesTestPointerString(String(SubString(storage, start)), Val(:decoded))
+end
+
+struct ArrowTypesTestDay
+    value::Date
+end
+Base.:(==)(a::ArrowTypesTestDay, b::ArrowTypesTestDay) = a.value == b.value
+Base.isequal(a::ArrowTypesTestDay, b::ArrowTypesTestDay) = isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_DAY_NAME = Symbol("JuliaLang.ArrowTests.Day")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestDay}) = Date
+ArrowTypes.toarrow(x::ArrowTypesTestDay) = x.value
+ArrowTypes.arrowname(::Type{ArrowTypesTestDay}) = ARROWTYPES_TEST_DAY_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_DAY_NAME}, S, metadata) = ArrowTypesTestDay
+ArrowTypes.fromarrow(::Type{ArrowTypesTestDay}, x::Date) = ArrowTypesTestDay(x)
+
+struct ArrowTypesTestDated
+    day::Date
+    count::Int32
+end
+Base.:(==)(a::ArrowTypesTestDated, b::ArrowTypesTestDated) =
+    a.day == b.day && a.count == b.count
+Base.isequal(a::ArrowTypesTestDated, b::ArrowTypesTestDated) =
+    isequal(a.day, b.day) && isequal(a.count, b.count)
+
+const ARROWTYPES_TEST_DATED_NAME = Symbol("JuliaLang.ArrowTests.Dated")
+const ArrowTypesTestDatedStorage = @NamedTuple{day::Date, count::Int32}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestDated}) = ArrowTypesTestDatedStorage
+ArrowTypes.toarrow(x::ArrowTypesTestDated) = (day=x.day, count=x.count)
+ArrowTypes.arrowname(::Type{ArrowTypesTestDated}) = ARROWTYPES_TEST_DATED_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_DATED_NAME}, S, metadata) = ArrowTypesTestDated
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestDated},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestDated(row.day, row.count)
+end
+
+struct ArrowTypesTestTemporalPack
+    pair::NTuple{2,ArrowTypesTestDay}
+    stamp::DateTime
+end
+Base.:(==)(a::ArrowTypesTestTemporalPack, b::ArrowTypesTestTemporalPack) =
+    a.pair == b.pair && a.stamp == b.stamp
+Base.isequal(a::ArrowTypesTestTemporalPack, b::ArrowTypesTestTemporalPack) =
+    isequal(a.pair, b.pair) && isequal(a.stamp, b.stamp)
+
+const ARROWTYPES_TEST_TEMPORAL_PACK_NAME = Symbol("JuliaLang.ArrowTests.TemporalPack")
+const ArrowTypesTestTemporalPackStorage =
+    @NamedTuple{pair::NTuple{2,ArrowTypesTestDay}, stamp::DateTime}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestTemporalPack}) = ArrowTypesTestTemporalPackStorage
+ArrowTypes.toarrow(x::ArrowTypesTestTemporalPack) = (pair=x.pair, stamp=x.stamp)
+ArrowTypes.arrowname(::Type{ArrowTypesTestTemporalPack}) =
+    ARROWTYPES_TEST_TEMPORAL_PACK_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_TEMPORAL_PACK_NAME}, S, metadata) =
+    ArrowTypesTestTemporalPack
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestTemporalPack},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestTemporalPack(row.pair, row.stamp)
+end
+
+struct ArrowTypesTestExactStruct
+    value::Int32
+end
+Base.:(==)(a::ArrowTypesTestExactStruct, b::ArrowTypesTestExactStruct) = a.value == b.value
+Base.isequal(a::ArrowTypesTestExactStruct, b::ArrowTypesTestExactStruct) =
+    isequal(a.value, b.value)
+
+const ARROWTYPES_TEST_EXACT_STRUCT_NAME = Symbol("JuliaLang.ArrowTests.ExactStruct")
+const ArrowTypesTestExactStructStorage = @NamedTuple{value::Int32}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestExactStruct}) = ArrowTypesTestExactStructStorage
+ArrowTypes.toarrow(x::ArrowTypesTestExactStruct) = (value=x.value,)
+ArrowTypes.arrowname(::Type{ArrowTypesTestExactStruct}) = ARROWTYPES_TEST_EXACT_STRUCT_NAME
+ArrowTypes.JuliaType(
+    ::Val{ARROWTYPES_TEST_EXACT_STRUCT_NAME},
+    ::Type{ArrowTypesTestExactStructStorage},
+    metadata,
+) = ArrowTypesTestExactStruct
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestExactStruct},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestExactStruct(row.value)
+end
+
+struct ArrowTypesTestNullLogical end
+Base.:(==)(::ArrowTypesTestNullLogical, ::ArrowTypesTestNullLogical) = true
+Base.isequal(::ArrowTypesTestNullLogical, ::ArrowTypesTestNullLogical) = true
+
+const ARROWTYPES_TEST_NULL_LOGICAL_NAME = Symbol("JuliaLang.ArrowTests.NullLogical")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestNullLogical}) = Nothing
+ArrowTypes.toarrow(::ArrowTypesTestNullLogical) = nothing
+ArrowTypes.arrowname(::Type{ArrowTypesTestNullLogical}) = ARROWTYPES_TEST_NULL_LOGICAL_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_NULL_LOGICAL_NAME}, ::Type{Missing}, metadata) =
+    ArrowTypesTestNullLogical
+ArrowTypes.fromarrow(::Type{ArrowTypesTestNullLogical}, ::Missing) =
+    ArrowTypesTestNullLogical()
+
+struct ArrowTypesTestAllNull
+    none::Missing
+end
+Base.:(==)(::ArrowTypesTestAllNull, ::ArrowTypesTestAllNull) = true
+Base.isequal(::ArrowTypesTestAllNull, ::ArrowTypesTestAllNull) = true
+
+const ARROWTYPES_TEST_ALL_NULL_NAME = Symbol("JuliaLang.ArrowTests.AllNull")
+const ArrowTypesTestAllNullStorage = @NamedTuple{none::Missing}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestAllNull}) = ArrowTypesTestAllNullStorage
+ArrowTypes.toarrow(x::ArrowTypesTestAllNull) = (none=x.none,)
+ArrowTypes.arrowname(::Type{ArrowTypesTestAllNull}) = ARROWTYPES_TEST_ALL_NULL_NAME
+ArrowTypes.JuliaType(
+    ::Val{ARROWTYPES_TEST_ALL_NULL_NAME},
+    ::Type{ArrowTypesTestAllNullStorage},
+    metadata,
+) = ArrowTypesTestAllNull
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestAllNull},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestAllNull(row.none)
+end
+
+const ArrowTypesTestMember = @NamedTuple{id::ArrowTypesTestID, plain::Int32}
+
+struct ArrowTypesTestEnvelope
+    member::ArrowTypesTestMember
+end
+Base.:(==)(a::ArrowTypesTestEnvelope, b::ArrowTypesTestEnvelope) = a.member == b.member
+Base.isequal(a::ArrowTypesTestEnvelope, b::ArrowTypesTestEnvelope) =
+    isequal(a.member, b.member)
+
+const ARROWTYPES_TEST_ENVELOPE_NAME = Symbol("JuliaLang.ArrowTests.Envelope")
+const ArrowTypesTestEnvelopeStorage = @NamedTuple{member::ArrowTypesTestMember}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestEnvelope}) = ArrowTypesTestEnvelopeStorage
+ArrowTypes.toarrow(x::ArrowTypesTestEnvelope) = (member=x.member,)
+ArrowTypes.arrowname(::Type{ArrowTypesTestEnvelope}) = ARROWTYPES_TEST_ENVELOPE_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_ENVELOPE_NAME}, S, metadata) =
+    ArrowTypesTestEnvelope
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestEnvelope},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestEnvelope(row.member)
+end
+
+struct ArrowTypesTestGroup
+    members::Vector{ArrowTypesTestMember}
+end
+Base.:(==)(a::ArrowTypesTestGroup, b::ArrowTypesTestGroup) = a.members == b.members
+Base.isequal(a::ArrowTypesTestGroup, b::ArrowTypesTestGroup) = isequal(a.members, b.members)
+
+const ARROWTYPES_TEST_GROUP_NAME = Symbol("JuliaLang.ArrowTests.Group")
+ArrowTypes.ArrowType(::Type{ArrowTypesTestGroup}) = Vector{ArrowTypesTestMember}
+ArrowTypes.toarrow(x::ArrowTypesTestGroup) = x.members
+ArrowTypes.arrowname(::Type{ArrowTypesTestGroup}) = ARROWTYPES_TEST_GROUP_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_GROUP_NAME}, S, metadata) = ArrowTypesTestGroup
+ArrowTypes.fromarrow(::Type{ArrowTypesTestGroup}, members::Vector{ArrowTypesTestMember}) =
+    ArrowTypesTestGroup(members)
+
+struct ArrowTypesTestStampedID
+    id::ArrowTypesTestID
+    day::Date
+end
+Base.:(==)(a::ArrowTypesTestStampedID, b::ArrowTypesTestStampedID) =
+    a.id == b.id && a.day == b.day
+Base.isequal(a::ArrowTypesTestStampedID, b::ArrowTypesTestStampedID) =
+    isequal(a.id, b.id) && isequal(a.day, b.day)
+
+const ARROWTYPES_TEST_STAMPED_ID_NAME = Symbol("JuliaLang.ArrowTests.StampedID")
+const ArrowTypesTestStampedIDStorage = @NamedTuple{id::ArrowTypesTestID, day::Date}
+ArrowTypes.ArrowType(::Type{ArrowTypesTestStampedID}) = ArrowTypesTestStampedIDStorage
+ArrowTypes.toarrow(x::ArrowTypesTestStampedID) = (id=x.id, day=x.day)
+ArrowTypes.arrowname(::Type{ArrowTypesTestStampedID}) = ARROWTYPES_TEST_STAMPED_ID_NAME
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_STAMPED_ID_NAME}, S, metadata) =
+    ArrowTypesTestStampedID
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestStampedID},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestStampedID(row.id, row.day)
+end
+
+struct ArrowTypesTestPoint{Tag}
+    x::Int32
+    y::Int32
+end
+Base.:(==)(a::ArrowTypesTestPoint, b::ArrowTypesTestPoint) = a.x == b.x && a.y == b.y
+Base.isequal(a::ArrowTypesTestPoint, b::ArrowTypesTestPoint) =
+    isequal(a.x, b.x) && isequal(a.y, b.y)
+
+const ARROWTYPES_TEST_POINT_NAME = Symbol("JuliaLang.ArrowTests.Point")
+const ArrowTypesTestPointStorage = @NamedTuple{y::Int32, x::Int32}
+ArrowTypes.ArrowType(::Type{<:ArrowTypesTestPoint}) = ArrowTypesTestPointStorage
+ArrowTypes.toarrow(x::ArrowTypesTestPoint) = (y=x.y, x=x.x)
+ArrowTypes.arrowname(::Type{<:ArrowTypesTestPoint}) = ARROWTYPES_TEST_POINT_NAME
+ArrowTypes.arrowmetadata(::Type{ArrowTypesTestPoint{Tag}}) where {Tag} = String(Tag)
+ArrowTypes.JuliaType(::Val{ARROWTYPES_TEST_POINT_NAME}, S, metadata) =
+    ArrowTypesTestPoint{Symbol(metadata)}
+function ArrowTypes.fromarrowstruct(
+    ::Type{ArrowTypesTestPoint{Tag}},
+    ::Val{names},
+    values...,
+) where {Tag,names}
+    row = NamedTuple{names}(values)
+    return ArrowTypesTestPoint{Tag}(row.x, row.y)
+end
+
+function arrowtypes_test_bytes(table; file::Bool, kwargs...)
+    io = IOBuffer()
+    Arrow.write(io, table; file=file, kwargs...)
+    return take!(io)
+end
+
+arrowtypes_test_table(table; file::Bool, kwargs...) =
+    Arrow.Table(arrowtypes_test_bytes(table; file=file, kwargs...))
+
+function arrowtypes_test_rowdict(row)
+    return Dict(String(first(pair)) => last(pair) for pair in row)
+end
+function arrowtypes_test_rowdict(row::NamedTuple)
+    return Dict(String(name) => value for (name, value) in pairs(row))
+end
+
+const ARROWTYPES_TEST_AC = Arrow.ArrowCore
+
+arrowtypes_test_extension_metadata(name) = Pair{String,String}[
+    "ARROW:extension:name" => String(name),
+    "ARROW:extension:metadata" => "",
+]
+
+function arrowtypes_test_marked_id_field(name; nullable::Bool=false)
+    return ARROWTYPES_TEST_AC.Field(
+        name,
+        ARROWTYPES_TEST_AC.IntType(64, true);
+        nullable=nullable,
+        metadata=[
+            "ARROW:extension:name" => String(ARROWTYPES_TEST_ID_NAME),
+            "ARROW:extension:metadata" => "",
+        ],
+    )
+end
+
+function arrowtypes_test_extension_name(field)
+    field.metadata === nothing && return nothing
+    for kv in field.metadata
+        first(kv) == "ARROW:extension:name" && return last(kv)
+    end
+    return nothing
+end
+
+function arrowtypes_test_field_contract_equal(a, b)
+    a.name == b.name || return false
+    ARROWTYPES_TEST_AC.typeequal(a.type, b.type) || return false
+    a.nullable == b.nullable || return false
+    something(a.metadata, Pair{String,String}[]) ==
+    something(b.metadata, Pair{String,String}[]) || return false
+    length(a.children) == length(b.children) || return false
+    return all(
+        arrowtypes_test_field_contract_equal(a.children[i], b.children[i]) for
+        i in eachindex(a.children)
+    )
+end
+
+function arrowtypes_test_retained_rewrites(field, data, expected)
+    schema = ARROWTYPES_TEST_AC.Schema([field])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], length(expected))
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(schema, [batch]) :
+            Arrow.writestream(schema, [batch])
+        @test Arrow.Table(inputbytes).value == expected
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            @test Arrow.Table(outputbytes).value == expected
+            outputfield, _ = arrowtypes_test_core_parts(outputbytes)
+            @test arrowtypes_test_field_contract_equal(outputfield, field)
+        end
+    end
+    return nothing
+end
+
+function arrowtypes_test_retained_replacement_error(field, data, replacement, messages)
+    schema = ARROWTYPES_TEST_AC.Schema([field])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], length(replacement))
+    for inputfile in (false, true),
+        sourcekind in (:table, :stream),
+        outputfile in (false, true)
+
+        inputbytes =
+            inputfile ? Arrow.writefile(schema, [batch]) :
+            Arrow.writestream(schema, [batch])
+        source = if sourcekind === :table
+            table = Arrow.Table(inputbytes)
+            getfield(table, :columns)[1] = replacement
+            table
+        else
+            parts = collect(Arrow.Stream(inputbytes))
+            getfield(only(parts), :columns)[1] = replacement
+            ArrowTypesTestRetainedPartitions(schema, Tuple(parts))
+        end
+        err = try
+            arrowtypes_test_bytes(source; file=outputfile)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        rendered = sprint(showerror, err)
+        for message in (messages isa AbstractString ? (messages,) : messages)
+            @test occursin(message, rendered)
+        end
+    end
+    return nothing
+end
+
+# The Core fields and decoded record batches of IPC bytes of either format.
+function arrowtypes_test_batches(bytes)
+    if view(bytes, 1:6) == b"ARROW1"
+        file = Arrow.readfile(bytes)
+        return file.fields, [file[i] for i = 1:length(file)]
+    end
+    stream = Arrow.readstream(bytes)
+    return stream.corefields, stream.batches
+end
+
+function arrowtypes_test_core_parts(bytes)
+    fields, batches = arrowtypes_test_batches(bytes)
+    return fields[1], batches
+end
+
+@testset "module boundary" begin
+    @test Arrow.ArrowTypes === ArrowTypes
+    # The one Arrow 2.x export kept for compatibility: `using Arrow` provides
+    # the bare `ArrowTypes` binding.
+    @test Base.isexported(Arrow, :ArrowTypes)
+end
+
+@testset "automatic scalar and struct mappings" begin
+    ids = ArrowTypesTestID.(Int64[1, 2, 3])
+    nullable_ids = Union{Missing,ArrowTypesTestID}[ids[1], missing, ids[3]]
+    any_ids = Any[ids...]
+    nullable_any_ids = Any[ids[1], missing, ids[3]]
+    labels = ArrowTypesTestLabel.(["one", "two", "three"])
+    days = ArrowTypesTestDay.([Date(2024, 1, 1), Date(2024, 2, 29), Date(2025, 1, 1)])
+    dated = [
+        ArrowTypesTestDated(Date(2024, 1, 1), Int32(1)),
+        ArrowTypesTestDated(Date(2024, 2, 29), Int32(2)),
+    ]
+    points = ArrowTypesTestPoint{:north}.(Int32[1, 3, 5], Int32[2, 4, 6])
+
+    for file in (false, true)
+        format = file ? "file" : "stream"
+        @testset "Int64 storage ($format)" begin
+            table = arrowtypes_test_table((id=ids,); file=file)
+            @test table.id == ids
+            @test eltype(table.id) === ArrowTypesTestID
+            @test DataAPI.colmetadata(table, :id, "ARROW:extension:name") ==
+                  String(ARROWTYPES_TEST_ID_NAME)
+        end
+        @testset "nullable storage ($format)" begin
+            table = arrowtypes_test_table((id=nullable_ids,); file=file)
+            @test isequal(table.id, nullable_ids)
+            @test eltype(table.id) === Union{Missing,ArrowTypesTestID}
+        end
+        @testset "homogeneous Any storage ($format)" begin
+            table = arrowtypes_test_table((id=any_ids,); file=file)
+            @test table.id == ids
+            @test eltype(table.id) === ArrowTypesTestID
+            @test DataAPI.colmetadata(table, :id, "ARROW:extension:name") ==
+                  String(ARROWTYPES_TEST_ID_NAME)
+
+            nullable = arrowtypes_test_table((id=nullable_any_ids,); file=file)
+            @test isequal(nullable.id, nullable_ids)
+            @test eltype(nullable.id) === Union{Missing,ArrowTypesTestID}
+        end
+        @testset "String storage ($format)" begin
+            table = arrowtypes_test_table((label=labels,); file=file)
+            @test table.label == labels
+            @test eltype(table.label) === ArrowTypesTestLabel
+        end
+        @testset "Date storage ($format)" begin
+            table = arrowtypes_test_table((day=days,); file=file)
+            @test table.day == days
+            @test eltype(table.day) === ArrowTypesTestDay
+        end
+        @testset "NamedTuple storage with Date child ($format)" begin
+            table = arrowtypes_test_table((dated=dated,); file=file)
+            @test table.dated == dated
+            @test eltype(table.dated) === ArrowTypesTestDated
+        end
+        @testset "NamedTuple storage ($format)" begin
+            table = arrowtypes_test_table((point=points,); file=file)
+            @test table.point == points
+            @test eltype(table.point) === ArrowTypesTestPoint{:north}
+            @test DataAPI.colmetadata(table, :point, "ARROW:extension:name") ==
+                  String(ARROWTYPES_TEST_POINT_NAME)
+            @test DataAPI.colmetadata(table, :point, "ARROW:extension:metadata") == "north"
+        end
+    end
+end
+
+@testset "AbstractString pointer lifting" begin
+    strings = arrowtypes_test_pointer_string.(["plain", "naïve", "箭头"])
+    for file in (false, true)
+        ARROWTYPES_TEST_POINTER_STRING_CALLS[] = 0
+        table = arrowtypes_test_table((string=strings,); file=file)
+        @test table.string == strings
+        @test eltype(table.string) === ArrowTypesTestPointerString
+        @test ARROWTYPES_TEST_POINTER_STRING_CALLS[] == length(strings)
+    end
+end
+
+@testset "JuliaType resolves once per field" begin
+    ids = ArrowTypesTestID.(Int64.(1:1_000))
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes((id=ids,); file=file)
+        ARROWTYPES_TEST_ID_JULIATYPE_CALLS[] = 0
+        table = Arrow.Table(bytes)
+        @test table.id == ids
+        @test ARROWTYPES_TEST_ID_JULIATYPE_CALLS[] == 1
+    end
+
+    partitioned = Tables.partitioner(((id=ids[1:1],), (id=ids[2:2],), (id=ids[3:3],)))
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes(partitioned; file)
+        ARROWTYPES_TEST_ID_JULIATYPE_CALLS[] = 0
+        batches = collect(Arrow.Stream(bytes))
+        @test only.(getproperty.(batches, :id)) == ids[1:3]
+        @test ARROWTYPES_TEST_ID_JULIATYPE_CALLS[] == 1
+    end
+
+    # A retained rewrite of a stream lowers each value once per batch.
+    counted = [ArrowTypesTestCountedID(Int32(i)) for i = 1:48]
+    unionvalues = ArrowTypesTestLogicalUnion[
+        ArrowTypesTestLogicalUnion(Int64(1)),
+        ArrowTypesTestLogicalUnion("two"),
+    ]
+    for partitioncount in (1, 4, 16)
+        parts = Tables.partitioner((
+            (id=counted[(2p - 1):(2p)], value=copy(unionvalues)) for p = 1:partitioncount
+        ))
+        bytes = arrowtypes_test_bytes(parts; file=false)
+        inputfields, inputbatches = arrowtypes_test_batches(bytes)
+        @test length(inputbatches) == partitioncount
+        ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] = 0
+        ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] = 0
+        rewritten = arrowtypes_test_bytes(Arrow.Stream(bytes); file=false)
+        @test ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] == 2 * partitioncount
+        @test ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] == 2 * partitioncount
+        outputfields, outputbatches = arrowtypes_test_batches(rewritten)
+        @test length(outputbatches) == partitioncount
+        @test all(
+            arrowtypes_test_field_contract_equal(a, b) for
+            (a, b) in zip(inputfields, outputfields)
+        )
+        table = Arrow.Table(rewritten)
+        @test table.id == counted[1:(2partitioncount)]
+        @test table.value == repeat(unionvalues, partitioncount)
+    end
+end
+
+@testset "fresh ArrowTypes traits are column-scoped" begin
+    for n in (1, 4, 16), encoded in (false, true)
+        values = ArrowTypesTestCountedID.(Int32.(1:n))
+        input = encoded ? Arrow.DictEncode(values) : values
+        ARROWTYPES_TEST_COUNTED_ID_TYPE_CALLS[] = 0
+        ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] = 0
+        bytes = arrowtypes_test_bytes((value=input,); file=false)
+        @test ARROWTYPES_TEST_COUNTED_ID_TYPE_CALLS[] == 1
+        @test ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] == n
+        @test Arrow.Table(bytes).value == values
+    end
+end
+
+@testset "fresh partition traits are planned once per partition" begin
+    # Partitions stream: each is planned as it arrives, not once per value.
+    parts = Tables.partitioner(
+        Tuple(
+            (value=ArrowTypesTestPlanCounted[ArrowTypesTestPlanCounted(Int32(i))],) for
+            i = 1:16
+        ),
+    )
+    ARROWTYPES_TEST_PLAN_COUNTED_KIND_CALLS[] = 0
+    ARROWTYPES_TEST_PLAN_COUNTED_NAME_CALLS[] = 0
+    ARROWTYPES_TEST_PLAN_COUNTED_LOWER_CALLS[] = 0
+    bytes = arrowtypes_test_bytes(parts; file=false)
+    @test ARROWTYPES_TEST_PLAN_COUNTED_KIND_CALLS[] <= 16
+    @test ARROWTYPES_TEST_PLAN_COUNTED_NAME_CALLS[] == 16
+    @test ARROWTYPES_TEST_PLAN_COUNTED_LOWER_CALLS[] == 16
+    @test Arrow.Table(bytes).value == ArrowTypesTestPlanCounted.(Int32.(1:16))
+end
+
+@testset "retained Union ArrowKind is column-scoped" begin
+    values = ArrowTypesTestKindCountedUnion[
+        isodd(i) ? ArrowTypesTestKindCountedUnion(Int64(i)) :
+        ArrowTypesTestKindCountedUnion("value-$i") for i = 1:100
+    ]
+    inputbytes = arrowtypes_test_bytes((value=values,); file=false)
+    inputfield, _ = arrowtypes_test_core_parts(inputbytes)
+    source = Arrow.Table(inputbytes)
+    ARROWTYPES_TEST_KIND_COUNTED_UNION_CALLS[] = 0
+    outputbytes = arrowtypes_test_bytes(source; file=false)
+    @test ARROWTYPES_TEST_KIND_COUNTED_UNION_CALLS[] <= 1
+    @test Arrow.Table(outputbytes).value == values
+    outputfield, _ = arrowtypes_test_core_parts(outputbytes)
+    @test arrowtypes_test_field_contract_equal(outputfield, inputfield)
+end
+
+@testset "nullable writer Union planning is column-scoped" begin
+    values = Union{Missing,ArrowTypesTestLogicalUnion}[
+        i % 3 == 0 ? missing :
+        isodd(i) ? ArrowTypesTestLogicalUnion(Int64(i)) :
+        ArrowTypesTestLogicalUnion("value-$i") for i = 1:100
+    ]
+    inputbytes = arrowtypes_test_bytes((value=values,); file=false)
+    retainedfield, _ = arrowtypes_test_core_parts(inputbytes)
+    context = Arrow._WriterContext()
+    rebuiltfield, rebuiltdata = Arrow._constructpart(retainedfield, values; context)
+    @test arrowtypes_test_field_contract_equal(rebuiltfield, retainedfield)
+    @test length(rebuiltdata) == length(values)
+
+    @test isequal(
+        Arrow.AC.materialize(rebuiltfield, rebuiltdata),
+        Arrow.AC.materialize(
+            retainedfield,
+            arrowtypes_test_core_parts(inputbytes)[2][1].columns[1],
+        ),
+    )
+end
+
+@testset "nullable marked composite" begin
+    points = Union{Missing,ArrowTypesTestPoint{:nullable}}[
+        ArrowTypesTestPoint{:nullable}(Int32(1), Int32(2)),
+        missing,
+        ArrowTypesTestPoint{:nullable}(Int32(3), Int32(4)),
+    ]
+    for file in (false, true)
+        table = arrowtypes_test_table((point=points,); file=file)
+        @test isequal(table.point, points)
+        @test eltype(table.point) === Union{Missing,ArrowTypesTestPoint{:nullable}}
+        @test DataAPI.colmetadata(table, :point, "ARROW:extension:metadata") == "nullable"
+    end
+end
+
+@testset "nullable fresh composites use bounded hidden child values" begin
+    IDRow = NTuple{2,ArrowTypesTestID}
+    ID = Union{Missing,IDRow}
+    idcases = (
+        ID[missing, (ArrowTypesTestID(1), ArrowTypesTestID(2))],
+        ID[(ArrowTypesTestID(1), ArrowTypesTestID(2)), missing],
+        ID[missing, missing],
+    )
+    for values in idcases, file in (false, true)
+        expected =
+            Any[row === missing ? missing : ArrowTypesTestID[row...] for row in values]
+        table = arrowtypes_test_table((value=values,); file=file)
+        @test isequal(table.value, expected)
+        field = getfield(table, :schema).fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.FixedSizeListType
+        @test field.nullable
+        @test arrowtypes_test_extension_name(only(field.children)) ==
+              String(ARROWTYPES_TEST_ID_NAME)
+    end
+
+    payload = repeat("x", 64 * 1024)
+    LabelRow = NTuple{2,ArrowTypesTestLabel}
+    labels = Union{Missing,LabelRow}[
+        fill(missing, 16)...,
+        (ArrowTypesTestLabel(payload), ArrowTypesTestLabel("tail")),
+    ]
+    expectedlabels = Any[
+        fill(missing, 16)...,
+        ArrowTypesTestLabel[ArrowTypesTestLabel(payload), ArrowTypesTestLabel("tail")],
+    ]
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes((value=labels,); file=file)
+        @test length(bytes) < 3 * length(payload)
+        @test isequal(Arrow.Table(bytes).value, expectedlabels)
+    end
+    alllabels = Union{Missing,LabelRow}[missing, missing]
+    for file in (false, true)
+        @test isequal(
+            arrowtypes_test_table((value=alllabels,); file=file).value,
+            Missing[missing, missing],
+        )
+    end
+
+    structs = Union{Missing,ArrowTypesTestLabelRow}[
+        fill(missing, 16)...,
+        ArrowTypesTestLabelRow(ArrowTypesTestLabel(payload)),
+    ]
+    for file in (false, true)
+        ARROWTYPES_TEST_LABEL_ROW_CALLS[] = 0
+        bytes = arrowtypes_test_bytes((value=structs,); file=file)
+        @test ARROWTYPES_TEST_LABEL_ROW_CALLS[] == 1
+        @test length(bytes) < 3 * length(payload)
+        @test isequal(Arrow.Table(bytes).value, structs)
+    end
+
+    Inner = NTuple{2,ArrowTypesTestLabel}
+    Outer = @NamedTuple{inner::Inner}
+    nested = Union{Missing,Outer}[
+        missing,
+        (inner=(ArrowTypesTestLabel(payload), ArrowTypesTestLabel("tail")),),
+    ]
+    expectednested = Any[
+        missing,
+        Pair{String,Any}["inner" => ArrowTypesTestLabel[
+            ArrowTypesTestLabel(payload),
+            ArrowTypesTestLabel("tail"),
+        ],],
+    ]
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes((value=nested,); file=file)
+        @test length(bytes) < 3 * length(payload)
+        @test isequal(Arrow.Table(bytes).value, expectednested)
+    end
+end
+
+@testset "nullable fresh Struct preserves declared Union routes" begin
+    U = Union{Int64,String}
+    Row = @NamedTuple{u::U}
+    cases = (
+        Union{Missing,Row}[missing, (u="text",), (u=Int64(7),)],
+        Union{Missing,Row}[(u=Int64(7),), missing, (u="text",)],
+        Union{Missing,Row}[missing, missing],
+    )
+    for values in cases, file in (false, true)
+        expected = Any[row === missing ? missing : (u=row.u,) for row in values]
+        bytes = arrowtypes_test_bytes((value=values,); file=file)
+        table = Arrow.Table(bytes)
+        @test isequal(table.value, expected)
+        field, batches = arrowtypes_test_core_parts(bytes)
+        unionfield = only(field.children)
+        @test unionfield.type isa ARROWTYPES_TEST_AC.UnionType
+        @test unionfield.type.typeids == Int8[0, 1]
+        @test length(unionfield.children) == 2
+        @test all(
+            batch -> length(only(batch.columns[1].children)) == length(values),
+            batches,
+        )
+    end
+
+    Inner = @NamedTuple{u::U}
+    Outer = @NamedTuple{inner::Inner}
+    nestedcases = (
+        Union{Missing,Outer}[missing, (inner=(u=Int64(7),),), (inner=(u="text",),)],
+        Union{Missing,Outer}[missing, missing],
+    )
+    for values in nestedcases, file in (false, true)
+        expected =
+            Any[row === missing ? missing : (inner=(u=row.inner.u,),) for row in values]
+        bytes = arrowtypes_test_bytes((value=values,); file=file)
+        @test isequal(Arrow.Table(bytes).value, expected)
+        field, _ = arrowtypes_test_core_parts(bytes)
+        unionfield = only(only(field.children).children)
+        @test unionfield.type isa ARROWTYPES_TEST_AC.UnionType
+        @test length(unionfield.children) == 2
+    end
+
+    NullableChild = Union{Missing,Inner}
+    NullableOuter = @NamedTuple{child::NullableChild}
+    nullablechildren = Union{Missing,NullableOuter}[
+        missing,
+        (child=missing,),
+        (child=(u="text",),),
+        (child=(u=Int64(7),),),
+    ]
+    expectednullablechildren = nullablechildren
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes((value=nullablechildren,); file=file)
+        @test isequal(Arrow.Table(bytes).value, expectednullablechildren)
+        field, _ = arrowtypes_test_core_parts(bytes)
+        unionfield = only(only(field.children).children)
+        @test unionfield.type isa ARROWTYPES_TEST_AC.UnionType
+        @test length(unionfield.children) == 2
+    end
+    allmissingchildren = Union{Missing,NullableOuter}[(child=missing,), (child=missing,)]
+    for file in (false, true)
+        table = arrowtypes_test_table((value=allmissingchildren,); file=file)
+        @test isequal(table.value, allmissingchildren)
+        field = getfield(table, :schema).fields[1]
+        @test only(only(field.children).children).type isa ARROWTYPES_TEST_AC.UnionType
+    end
+
+    FixedInner = NTuple{2,U}
+    FixedOuter = @NamedTuple{inner::FixedInner}
+    fixedcases = (
+        Union{Missing,FixedOuter}[missing, (inner=("text", Int64(7)),)],
+        Union{Missing,FixedOuter}[missing, missing],
+    )
+    for values in fixedcases, file in (false, true)
+        # Fixed-size lists of union values read as `ListValue`s.
+        expected = Any[v === missing ? missing : (inner=collect(v.inner),) for v in values]
+        bytes = arrowtypes_test_bytes((value=values,); file=file)
+        @test isequal(Arrow.Table(bytes).value, expected)
+        field, _ = arrowtypes_test_core_parts(bytes)
+        unionfield = only(only(field.children).children)
+        @test unionfield.type isa ARROWTYPES_TEST_AC.UnionType
+        @test length(unionfield.children) == 2
+    end
+
+    Wide = NTuple{256,UInt8}
+    WideUnion = Union{Wide,String}
+    WideRow = @NamedTuple{u::WideUnion}
+    WideNullable = Union{Missing,WideRow}
+    visible = WideNullable[(u="x",)]
+    hidden = WideNullable[(u="x",), fill(missing, 32)...]
+    for file in (false, true)
+        visiblebytes = arrowtypes_test_bytes((value=visible,); file=file)
+        hiddenbytes = arrowtypes_test_bytes((value=hidden,); file=file)
+        @test length(hiddenbytes) - length(visiblebytes) < 2 * 1024
+        @test isequal(Arrow.Table(hiddenbytes).value, hidden)
+    end
+end
+
+@testset "nullable marked composite keeps exact storage type" begin
+    values = Union{Missing,ArrowTypesTestExactStruct}[
+        ArrowTypesTestExactStruct(Int32(1)),
+        missing,
+        ArrowTypesTestExactStruct(Int32(2)),
+    ]
+    for file in (false, true)
+        table = arrowtypes_test_table((value=values,); file=file)
+        @test isequal(table.value, values)
+        @test eltype(table.value) === Union{Missing,ArrowTypesTestExactStruct}
+        field = getfield(table, :schema).fields[1]
+        @test field.nullable
+        @test !field.children[1].nullable
+    end
+end
+
+@testset "custom Nothing storage uses NullType" begin
+    values = [ArrowTypesTestNullLogical(), ArrowTypesTestNullLogical()]
+    for file in (false, true)
+        table = arrowtypes_test_table((value=values,); file=file)
+        @test table.value == values
+        @test eltype(table.value) === ArrowTypesTestNullLogical
+        field = getfield(table, :schema).fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.NullType
+        @test !field.nullable
+    end
+end
+
+@testset "marked Struct keeps an all-null Missing child" begin
+    values = [ArrowTypesTestAllNull(missing), ArrowTypesTestAllNull(missing)]
+    for file in (false, true)
+        table = arrowtypes_test_table((value=values,); file=file)
+        @test table.value == values
+        @test eltype(table.value) === ArrowTypesTestAllNull
+        field = getfield(table, :schema).fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.StructType
+        @test field.children[1].type isa ARROWTYPES_TEST_AC.NullType
+    end
+end
+
+@testset "all-missing unmarked List keeps its marked child type" begin
+    T = Union{Missing,Vector{ArrowTypesTestID}}
+    values = T[missing, missing]
+    for file in (false, true)
+        table = arrowtypes_test_table((value=values,); file=file)
+        @test isequal(table.value, values)
+        @test eltype(table.value) === T
+    end
+end
+
+@testset "dense Union schema and logical child routing" begin
+    SameStorage = Union{ArrowTypesTestID,ArrowTypesTestAlternateID}
+    Mixed = Union{Missing,ArrowTypesTestID,String}
+    same =
+        SameStorage[ArrowTypesTestID(1), ArrowTypesTestAlternateID(2), ArrowTypesTestID(3)]
+    mixed = Mixed[missing, ArrowTypesTestID(4), "five"]
+    nothingmixed = Union{Nothing,String}[nothing, "six", nothing]
+    nested =
+        [Mixed[missing, ArrowTypesTestID(7), "eight"], Mixed[ArrowTypesTestID(9)], Mixed[]]
+
+    for file in (false, true)
+        table = arrowtypes_test_table((; same, mixed, nothingmixed, nested); file=file)
+        @test table.same == same
+        @test typeof.(table.same) == typeof.(same)
+        @test isequal(table.mixed, mixed)
+        @test typeof.(table.mixed) == typeof.(mixed)
+        @test isequal(table.nothingmixed, nothingmixed)
+        @test typeof.(table.nothingmixed) == typeof.(nothingmixed)
+        @test isequal(table.nested, nested)
+        @test [typeof.(row) for row in table.nested] == [typeof.(row) for row in nested]
+
+        fields = getfield(table, :schema).fields
+        for field in fields[1:3]
+            @test field.type isa ARROWTYPES_TEST_AC.UnionType
+            @test field.type.mode == ARROWTYPES_TEST_AC.DenseMode
+            @test field.type.typeids == Int8.(0:(length(field.children) - 1))
+            @test getfield.(field.children, :name) ==
+                  string.(0:(length(field.children) - 1))
+        end
+        @test !fields[1].nullable
+        @test fields[2].nullable
+        @test !fields[3].nullable
+        @test Set(arrowtypes_test_extension_name.(fields[1].children)) == Set([
+            String(ARROWTYPES_TEST_ID_NAME),
+            String(ARROWTYPES_TEST_ALTERNATE_ID_NAME),
+        ])
+        @test String(ARROWTYPES_TEST_ID_NAME) in
+              arrowtypes_test_extension_name.(fields[2].children)
+        @test "JuliaLang.Nothing" in arrowtypes_test_extension_name.(fields[3].children)
+
+        nestedfield = fields[4]
+        @test nestedfield.type isa ARROWTYPES_TEST_AC.ListType
+        unionchild = only(nestedfield.children)
+        @test unionchild.type isa ARROWTYPES_TEST_AC.UnionType
+        @test unionchild.type.mode == ARROWTYPES_TEST_AC.DenseMode
+        @test getfield.(unionchild.children, :name) ==
+              string.(0:(length(unionchild.children) - 1))
+        @test String(ARROWTYPES_TEST_ID_NAME) in
+              arrowtypes_test_extension_name.(unionchild.children)
+    end
+end
+
+@testset "one logical type owns its whole Union storage Field" begin
+    logical = ArrowTypesTestLogicalUnion[
+        ArrowTypesTestLogicalUnion(Int64(1)),
+        ArrowTypesTestLogicalUnion("two"),
+    ]
+    nullable = Union{Missing,ArrowTypesTestLogicalUnion}[
+        missing,
+        ArrowTypesTestLogicalUnion("three"),
+        ArrowTypesTestLogicalUnion(Int64(4)),
+    ]
+    for values in (logical, nullable), inputfile in (false, true)
+        ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] = 0
+        bytes = arrowtypes_test_bytes((value=values,); file=inputfile)
+        @test ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] == count(!ismissing, values)
+        @test isequal(Arrow.Table(bytes).value, values)
+        field, _ = arrowtypes_test_core_parts(bytes)
+        @test field.type isa ARROWTYPES_TEST_AC.UnionType
+        @test arrowtypes_test_extension_name(field) ==
+              String(ARROWTYPES_TEST_LOGICAL_UNION_NAME)
+
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+            ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] = 0
+            rewritten = arrowtypes_test_bytes(source; file=outputfile)
+            @test ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] == count(!ismissing, values)
+            @test isequal(Arrow.Table(rewritten).value, values)
+            rewrittenfield, _ = arrowtypes_test_core_parts(rewritten)
+            @test arrowtypes_test_field_contract_equal(field, rewrittenfield)
+        end
+    end
+
+    Row = @NamedTuple{u::ArrowTypesTestLogicalUnion}
+    structcases = (
+        Union{Missing,Row}[
+            missing,
+            (u=ArrowTypesTestLogicalUnion("five"),),
+            (u=ArrowTypesTestLogicalUnion(Int64(6)),),
+        ],
+        Union{Missing,Row}[missing, missing],
+    )
+    for values in structcases, inputfile in (false, true)
+        bytes = arrowtypes_test_bytes((value=values,); file=inputfile)
+        # A struct with an ArrowTypes-labelled child keeps `Pair` rows.
+        expected = Any[
+            row === missing ? missing : Pair{String,Any}["u" => row.u] for row in values
+        ]
+        @test isequal(Arrow.Table(bytes).value, expected)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+            @test isequal(
+                Arrow.Table(arrowtypes_test_bytes(source; file=outputfile)).value,
+                expected,
+            )
+        end
+    end
+
+    fixed = Union{Missing,NTuple{2,ArrowTypesTestLogicalUnion}}[
+        missing,
+        (ArrowTypesTestLogicalUnion("seven"), ArrowTypesTestLogicalUnion(Int64(8))),
+    ]
+    expectedfixed = Any[missing, collect(only(skipmissing(fixed)))]
+    for inputfile in (false, true)
+        bytes = arrowtypes_test_bytes((value=fixed,); file=inputfile)
+        @test isequal(Arrow.Table(bytes).value, expectedfixed)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+            @test isequal(
+                Arrow.Table(arrowtypes_test_bytes(source; file=outputfile)).value,
+                expectedfixed,
+            )
+        end
+    end
+
+    categories = ArrowTypesTestLogicalUnion[
+        ArrowTypesTestLogicalUnion(Int64(9)),
+        ArrowTypesTestLogicalUnion("ten"),
+        ArrowTypesTestLogicalUnion(Int64(9)),
+    ]
+    for inputfile in (false, true)
+        ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] = 0
+        bytes = arrowtypes_test_bytes((value=Arrow.DictEncode(categories),); file=inputfile)
+        @test ARROWTYPES_TEST_LOGICAL_UNION_CALLS[] == 2
+        @test Arrow.Table(bytes).value == categories
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+            @test Arrow.Table(arrowtypes_test_bytes(source; file=outputfile)).value ==
+                  categories
+        end
+    end
+
+    uniontype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[42, 17])
+    stringfield, stringdata = ARROWTYPES_TEST_AC.fromjulia("text", ["legacy"])
+    intfield, intdata = ARROWTYPES_TEST_AC.fromjulia("integer", Int64[17])
+    stringfield = ARROWTYPES_TEST_AC.Field(
+        stringfield.name,
+        stringfield.type;
+        nullable=true,
+        metadata=["note" => "retained"],
+        children=collect(ARROWTYPES_TEST_AC.Field, stringfield.children),
+    )
+    intfield = ARROWTYPES_TEST_AC.Field(
+        intfield.name,
+        intfield.type;
+        nullable=intfield.nullable,
+        metadata=["note" => "also retained"],
+        children=collect(ARROWTYPES_TEST_AC.Field, intfield.children),
+    )
+    legacyfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        uniontype;
+        nullable=false,
+        metadata=[
+            "ARROW:extension:name" => String(ARROWTYPES_TEST_LOGICAL_UNION_NAME),
+            "ARROW:extension:metadata" => "",
+        ],
+        children=[stringfield, intfield],
+    )
+    legacydata = ARROWTYPES_TEST_AC.ArrayData(
+        uniontype,
+        2,
+        [
+            ARROWTYPES_TEST_AC._databuffer(Int8[42, 17]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0, 0]),
+        ];
+        children=[stringdata, intdata],
+        nullcount=0,
+    )
+    legacyschema = ARROWTYPES_TEST_AC.Schema([legacyfield])
+    legacybatch = ARROWTYPES_TEST_AC.RecordBatch(legacyschema, [legacydata], 2)
+    legacyexpected = ArrowTypesTestLogicalUnion[
+        ArrowTypesTestLogicalUnion("legacy"),
+        ArrowTypesTestLogicalUnion(Int64(17)),
+    ]
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(legacyschema, [legacybatch]) :
+            Arrow.writestream(legacyschema, [legacybatch])
+        @test Arrow.Table(inputbytes).value == legacyexpected
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            @test Arrow.Table(outputbytes).value == legacyexpected
+            rewrittenfield, _ = arrowtypes_test_core_parts(outputbytes)
+            @test arrowtypes_test_field_contract_equal(legacyfield, rewrittenfield)
+        end
+    end
+
+    stringfield, stringdata = ARROWTYPES_TEST_AC.fromjulia("text", ["external"])
+    elementfield, elementdata = ARROWTYPES_TEST_AC.fromjulia("element", Int64[1, 2])
+    listtype = ARROWTYPES_TEST_AC.ListType(false)
+    listfield = ARROWTYPES_TEST_AC.Field(
+        "numbers",
+        listtype;
+        nullable=false,
+        children=[elementfield],
+    )
+    listdata = ARROWTYPES_TEST_AC.ArrayData(
+        listtype,
+        1,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 2])];
+        children=[elementdata],
+        nullcount=0,
+    )
+    externaltype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[42, 17])
+    externalfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        externaltype;
+        nullable=false,
+        metadata=[
+            "ARROW:extension:name" => String(ARROWTYPES_TEST_LOGICAL_LIST_UNION_NAME),
+            "ARROW:extension:metadata" => "",
+        ],
+        children=[stringfield, listfield],
+    )
+    externaldata = ARROWTYPES_TEST_AC.ArrayData(
+        externaltype,
+        2,
+        [
+            ARROWTYPES_TEST_AC._databuffer(Int8[17, 42]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0, 0]),
+        ];
+        children=[stringdata, listdata],
+        nullcount=0,
+    )
+    externalschema = ARROWTYPES_TEST_AC.Schema([externalfield])
+    externalbatch = ARROWTYPES_TEST_AC.RecordBatch(externalschema, [externaldata], 2)
+    externalexpected = ArrowTypesTestLogicalListUnion[
+        ArrowTypesTestLogicalListUnion(Int64[1, 2]),
+        ArrowTypesTestLogicalListUnion("external"),
+    ]
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(externalschema, [externalbatch]) :
+            Arrow.writestream(externalschema, [externalbatch])
+        @test Arrow.Table(inputbytes).value == externalexpected
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            @test Arrow.Table(outputbytes).value == externalexpected
+            rewrittenfield, _ = arrowtypes_test_core_parts(outputbytes)
+            @test arrowtypes_test_field_contract_equal(externalfield, rewrittenfield)
+        end
+    end
+end
+
+@testset "declared abstract Union members keep schema authority" begin
+    Declared = Union{ArrowTypesTestDeclaredAbstract,Float64}
+    Textual = Union{Int64,AbstractString}
+    cases = (
+        (
+            Declared[ArrowTypesTestDeclaredConcrete(Int32(1)), Float64(2.5)],
+            Any[Int32(1), Float64(2.5)],
+        ),
+        (Declared[], Any[]),
+        # Union rows read strings as the default string type.
+        (Textual[Int64(3), "four"], Any[Int64(3), Arrow.DataStrings.DataString("four")]),
+        (Textual[], Any[]),
+    )
+    for (values, expected) in cases, encoded in (false, true), file in (false, true)
+        input = encoded ? Arrow.DictEncode(values) : values
+        bytes = arrowtypes_test_bytes((value=input,); file)
+        table = Arrow.Table(bytes)
+        @test table.value == expected
+        @test typeof.(table.value) == typeof.(expected)
+        field, _ = arrowtypes_test_core_parts(bytes)
+        valuefield = encoded ? ARROWTYPES_TEST_AC.dictvaluefield(field, field.type) : field
+        @test valuefield.type isa ARROWTYPES_TEST_AC.UnionType
+        @test length(valuefield.children) == 2
+    end
+end
+
+@testset "abstract read target keeps concrete Union writer evidence" begin
+    Concrete = ArrowTypesTestConcreteUnionWrite
+    Abstract = ArrowTypesTestAbstractUnionRead
+    cases = (
+        Concrete[Concrete(Int64(1)), Concrete("two")],
+        Union{Missing,Concrete}[missing, Concrete("three"), Concrete(Int64(4))],
+        Union{Missing,Concrete}[missing, missing],
+        Concrete[],
+    )
+    for values in cases, encoded in (false, true), inputfile in (false, true)
+        input = encoded ? Arrow.DictEncode(values) : values
+        inputbytes = arrowtypes_test_bytes((value=input,); file=inputfile)
+        inputtable = Arrow.Table(inputbytes)
+        @test isequal(inputtable.value, values)
+        expectedtype = Missing <: eltype(values) ? Union{Missing,Abstract} : Abstract
+        @test eltype(inputtable.value) === expectedtype
+        inputfield, _ = arrowtypes_test_core_parts(inputbytes)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            outputtable = Arrow.Table(outputbytes)
+            @test isequal(outputtable.value, values)
+            @test eltype(outputtable.value) === expectedtype
+            outputfield, _ = arrowtypes_test_core_parts(outputbytes)
+            @test arrowtypes_test_field_contract_equal(inputfield, outputfield)
+        end
+    end
+end
+
+@testset "registered abstract target routes concrete storage children" begin
+    Abstract = ArrowTypesTestRoutedRead
+    values = Abstract[ArrowTypesTestRoutedInt(Int32(1)), ArrowTypesTestRoutedString("two")]
+    for encoded in (false, true), inputfile in (false, true)
+        input = encoded ? Arrow.DictEncode(values) : values
+        inputbytes = arrowtypes_test_bytes((value=input,); file=inputfile)
+        inputfield, _ = arrowtypes_test_core_parts(inputbytes)
+        inputtable = Arrow.Table(inputbytes)
+        @test inputtable.value == values
+        @test typeof.(inputtable.value) == typeof.(values)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            outputtable = Arrow.Table(outputbytes)
+            @test outputtable.value == values
+            @test typeof.(outputtable.value) == typeof.(values)
+            outputfield, _ = arrowtypes_test_core_parts(outputbytes)
+            @test arrowtypes_test_field_contract_equal(inputfield, outputfield)
+        end
+    end
+end
+
+@testset "unresolved abstract declarations keep concrete writer evidence" begin
+    Abstract = ArrowTypesTestAbstractReadID
+    Concrete = ArrowTypesTestConcreteWriteID
+    layouts = (
+        ((value=Abstract[Concrete(Int32(1)), Concrete(Int32(2))],), 2),
+        ((value=Union{Missing,Abstract}[missing, Concrete(Int32(3))],), 1),
+        (
+            Tables.partitioner((
+                (value=Abstract[Concrete(Int32(4))],),
+                (value=Abstract[Concrete(Int32(5))],),
+            )),
+            2,
+        ),
+    )
+    for (layout, expectedcalls) in layouts, file in (false, true)
+        ARROWTYPES_TEST_CONCRETE_WRITE_CALLS[] = 0
+        bytes = arrowtypes_test_bytes(layout; file)
+        @test ARROWTYPES_TEST_CONCRETE_WRITE_CALLS[] == expectedcalls
+        table = Arrow.Table(bytes)
+        @test all(x -> x === missing || x isa Concrete, table.value)
+        @test DataAPI.colmetadata(table, :value, "ARROW:extension:name") ==
+              String(ARROWTYPES_TEST_ABSTRACT_READ_ID)
+    end
+
+    mixed = ArrowTypesTestAbstractWriteOnly[
+        ArrowTypesTestAbstractWriteA(Int32(6)),
+        ArrowTypesTestAbstractWriteB(Int32(7)),
+    ]
+    mixedbytes = arrowtypes_test_bytes((value=mixed,); file=false)
+    mixedfield, _ = arrowtypes_test_core_parts(mixedbytes)
+    # Two runtime types that share one storage and no label write as one column.
+    @test mixedfield.type == ARROWTYPES_TEST_AC.IntType(32, true)
+    @test Arrow.Table(mixedbytes).value == Int32[6, 7]
+end
+
+@testset "recursive custom writer schemas fail closed" begin
+    values = ArrowTypesTestRecursiveSchema[ArrowTypesTestRecursiveSchema(Int32(1))]
+    for file in (false, true)
+        err = try
+            arrowtypes_test_bytes((value=values,); file)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("recursive ArrowTypes storage schema", sprint(showerror, err))
+    end
+end
+
+@testset "recursive value containers fail closed" begin
+    selfcycle = Any[]
+    push!(selfcycle, selfcycle)
+    left = Any[]
+    right = Any[left]
+    push!(left, right)
+    for (label, values) in
+        (("self cycle", Any[selfcycle]), ("two-container cycle", Any[left]))
+        @testset "$label ($(file ? "file" : "stream"))" for file in (false, true)
+            err = try
+                arrowtypes_test_bytes((value=values,); file)
+                nothing
+            catch e
+                e
+            end
+            @test err isa ArgumentError
+            @test occursin("recursive ArrowTypes value container", sprint(showerror, err))
+        end
+    end
+
+    deep = Int32(1)
+    for _ = 1:63
+        deep = Any[deep]
+    end
+    @test Arrow._preflightwritercontainers(Any[deep]) === nothing
+    toodeep = Any[deep]
+    err = try
+        Arrow._preflightwritercontainers(Any[toodeep])
+        nothing
+    catch e
+        e
+    end
+    @test err isa ArgumentError
+    @test occursin("value nesting exceeds the supported depth 64", sprint(showerror, err))
+end
+
+@testset "abstract retained target rejects subtype relabeling" begin
+    source = arrowtypes_test_table(
+        (id=ArrowTypesTestConcreteWriteID[ArrowTypesTestConcreteWriteID(Int32(1))],);
+        file=true,
+    )
+    @test eltype(source.id) === ArrowTypesTestAbstractReadID
+    getfield(source, :columns)[1] =
+        ArrowTypesTestRelabeledWriteID[ArrowTypesTestRelabeledWriteID(Int32(1))]
+    for file in (false, true)
+        err = try
+            arrowtypes_test_bytes(source; file)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("cannot replace abstract retained target", sprint(showerror, err))
+    end
+end
+
+@testset "abstract retained Union rejects subtype relabeling" begin
+    values = ArrowTypesTestConcreteUnionWrite[
+        ArrowTypesTestConcreteUnionWrite(Int64(1)),
+        ArrowTypesTestConcreteUnionWrite("two"),
+    ]
+    source = arrowtypes_test_table((value=values,); file=true)
+    @test eltype(source.value) === ArrowTypesTestAbstractUnionRead
+    getfield(source, :columns)[1] = ArrowTypesTestRelabeledUnionWrite[
+        ArrowTypesTestRelabeledUnionWrite(Int64(1)),
+        ArrowTypesTestRelabeledUnionWrite("two"),
+    ]
+    for file in (false, true)
+        err = try
+            arrowtypes_test_bytes(source; file)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("cannot replace abstract retained target", sprint(showerror, err))
+    end
+end
+
+@testset "retained Union rejects ambiguous storage-only routes" begin
+    leftfield, leftdata = ARROWTYPES_TEST_AC.fromjulia("left", Int32[1])
+    rightfield, rightdata = ARROWTYPES_TEST_AC.fromjulia("right", Int32[-2])
+    uniontype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[42, 17])
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        uniontype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_AMBIGUOUS_ROUTE_NAME),
+        children=[leftfield, rightfield],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        uniontype,
+        2,
+        [
+            ARROWTYPES_TEST_AC._databuffer(Int8[42, 17]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0, 0]),
+        ];
+        children=[leftdata, rightdata],
+        nullcount=0,
+    )
+    schema = ARROWTYPES_TEST_AC.Schema([field])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 2)
+    expected = ArrowTypesTestAmbiguousRouteRead[
+        ArrowTypesTestAmbiguousRouteLeft(Int32(1)),
+        ArrowTypesTestAmbiguousRouteRight(Int32(2)),
+    ]
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(schema, [batch]) :
+            Arrow.writestream(schema, [batch])
+        @test Arrow.Table(inputbytes).value == expected
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            err = try
+                arrowtypes_test_bytes(source; file=outputfile)
+                nothing
+            catch e
+                e
+            end
+            # The storage Union's members are logical types, which
+            # ArrowTypes.toarrow lowers past: no member takes the values.
+            @test err isa ArgumentError
+            @test occursin("cannot be represented as", sprint(showerror, err))
+        end
+    end
+end
+
+@testset "writer planning has bounded type surfaces" begin
+    @test Arrow._boundedfixedliststoragetype(1024, Int16) === NTuple{1024,Int16}
+    @test Arrow._boundedfixedliststoragetype(1025, Int16) === Tuple{Vararg{Int16}}
+    guardchild = joinpath(@__DIR__, "arrowtypes_storage_guard_child.jl")
+    guardoutput = read(
+        `$(Base.julia_cmd()) --startup-file=no --history-file=no --project=$(Base.active_project()) $guardchild`,
+        String,
+    )
+    @test occursin("oversized ArrowType storage rejected", guardoutput)
+    symbolguardchild = joinpath(@__DIR__, "arrowtypes_symbol_guard_child.jl")
+    symbolguardoutput = read(
+        `$(Base.julia_cmd()) --startup-file=no --history-file=no --project=$(Base.active_project()) $symbolguardchild`,
+        String,
+    )
+    @test occursin("ArrowTypes symbol guard passed", symbolguardoutput)
+
+    tuplevalues = ArrowTypesTestAbstractTupleStorage[
+        arrowtypes_test_tuple_storage_value(1, 11),
+        arrowtypes_test_tuple_storage_value(2, 22),
+    ]
+    tuplebytes = arrowtypes_test_bytes((value=tuplevalues,); file=false)
+    tuplefield, tuplebatches = arrowtypes_test_core_parts(tuplebytes)
+    @test tuplefield.type isa ARROWTYPES_TEST_AC.UnionType
+    @test tuplefield.type.mode == ARROWTYPES_TEST_AC.DenseMode
+    @test all(
+        child -> child.type isa ARROWTYPES_TEST_AC.FixedSizeListType,
+        tuplefield.children,
+    )
+    @test sort([child.type.listsize for child in tuplefield.children]) == [1, 2]
+    @test only(tuplebatches).columns[1].type == tuplefield.type
+    @test collect.(Arrow.Table(tuplebytes).value) == [[Int16(11)], [Int16(22), Int16(22)]]
+
+    excessstorage = ArrowTypesTestAbstractTupleStorage[
+        arrowtypes_test_tuple_storage_value(n) for n = 1:9
+    ]
+    push!(excessstorage, arrowtypes_test_tuple_storage_value(1, 10))
+    ARROWTYPES_TEST_TUPLE_STORAGE_LOWER_CALLS[] = 0
+    err = try
+        arrowtypes_test_bytes((value=excessstorage,); file=false)
+        nothing
+    catch e
+        e
+    end
+    @test err isa ArgumentError
+    @test occursin("column value holds values of more than 8 types", sprint(showerror, err))
+    @test ARROWTYPES_TEST_TUPLE_STORAGE_LOWER_CALLS[] == 9
+
+    nullabletuplevalues = Union{Missing,ArrowTypesTestAbstractTupleStorage}[missing]
+    for n = 1:8
+        push!(nullabletuplevalues, arrowtypes_test_tuple_storage_value(n))
+    end
+    ARROWTYPES_TEST_TUPLE_STORAGE_LOWER_CALLS[] = 0
+    nullabletuplebytes = arrowtypes_test_bytes((value=nullabletuplevalues,); file=false)
+    @test ARROWTYPES_TEST_TUPLE_STORAGE_LOWER_CALLS[] == 8
+    nullabletuplefield, _ = arrowtypes_test_core_parts(nullabletuplebytes)
+    @test nullabletuplefield.type isa ARROWTYPES_TEST_AC.UnionType
+    @test length(nullabletuplefield.children) == 9
+    @test count(
+        child -> child.type isa ARROWTYPES_TEST_AC.NullType,
+        nullabletuplefield.children,
+    ) == 1
+    nullabletupleresult = Arrow.Table(nullabletuplebytes).value
+    @test first(nullabletupleresult) === missing
+    @test collect.(nullabletupleresult[2:end]) == [fill(Int16(n), n) for n = 1:8]
+
+    emptyouter =
+        ArrowTypesTestNestedOuter[ArrowTypesTestNestedOuter(ArrowTypesTestNestedUnion[])]
+    emptyouterbytes = arrowtypes_test_bytes((value=emptyouter,); file=false)
+    @test Arrow.Table(emptyouterbytes).value == emptyouter
+    emptyouterfield, _ = arrowtypes_test_core_parts(emptyouterbytes)
+    @test emptyouterfield.type isa ARROWTYPES_TEST_AC.ListType
+    nestedunionfield = only(emptyouterfield.children)
+    @test nestedunionfield.type isa ARROWTYPES_TEST_AC.UnionType
+    nestedchildnames = arrowtypes_test_extension_name.(nestedunionfield.children)
+    fixedchild = findfirst(==(String(ARROWTYPES_TEST_NESTED_FIXED_NAME)), nestedchildnames)
+    @test fixedchild !== nothing
+    fixedfield = nestedunionfield.children[fixedchild]
+    @test fixedfield.type isa ARROWTYPES_TEST_AC.FixedSizeListType
+    @test fixedfield.type.listsize == 2
+
+    visibleouter = ArrowTypesTestNestedOuter[ArrowTypesTestNestedOuter(
+        ArrowTypesTestNestedUnion[
+            ArrowTypesTestNestedUnion(
+                ArrowTypesTestNestedFixed((
+                    ArrowTypesTestNestedLeaf(Int16(1)),
+                    ArrowTypesTestNestedLeaf(Int16(2)),
+                )),
+            ),
+            ArrowTypesTestNestedUnion(
+                ArrowTypesTestNestedList(
+                    ArrowTypesTestNestedLeaf[
+                        ArrowTypesTestNestedLeaf(Int16(3)),
+                        ArrowTypesTestNestedLeaf(Int16(4)),
+                        ArrowTypesTestNestedLeaf(Int16(5)),
+                    ],
+                ),
+            ),
+        ],
+    )]
+    emptyouterschema = ARROWTYPES_TEST_AC.Schema([emptyouterfield])
+    visibleoutersource =
+        ArrowTypesTestRetainedPartitions(emptyouterschema, ((value=visibleouter,),))
+    visibleouterbytes = arrowtypes_test_bytes(visibleoutersource; file=false)
+    @test Arrow.Table(visibleouterbytes).value == visibleouter
+    visibleouterfield, _ = arrowtypes_test_core_parts(visibleouterbytes)
+    @test arrowtypes_test_field_contract_equal(emptyouterfield, visibleouterfield)
+
+    emptyabstractouter =
+        ArrowTypesTestNestedAbstractOuter[ArrowTypesTestNestedAbstractOuter(
+            ArrowTypesTestNestedAbstractUnion[],
+        ),]
+    emptyabstractbytes = arrowtypes_test_bytes((value=emptyabstractouter,); file=false)
+    emptyabstractfield, _ = arrowtypes_test_core_parts(emptyabstractbytes)
+    @test emptyabstractfield.type isa ARROWTYPES_TEST_AC.ListType
+    abstractunionfield = only(emptyabstractfield.children)
+    @test abstractunionfield.type isa ARROWTYPES_TEST_AC.UnionType
+    abstractchildnames = arrowtypes_test_extension_name.(abstractunionfield.children)
+    abstractfixedindex = findfirst(
+        ==(String(ARROWTYPES_TEST_NESTED_ABSTRACT_FIXED_NAME)),
+        abstractchildnames,
+    )
+    abstractlistindex =
+        findfirst(==(String(ARROWTYPES_TEST_NESTED_ABSTRACT_LIST_NAME)), abstractchildnames)
+    @test abstractfixedindex !== nothing
+    @test abstractlistindex !== nothing
+    abstractfixedfield = abstractunionfield.children[abstractfixedindex]
+    abstractlistfield = abstractunionfield.children[abstractlistindex]
+    @test abstractfixedfield.type isa ARROWTYPES_TEST_AC.FixedSizeListType
+    @test abstractfixedfield.type.listsize == 2
+    @test only(abstractfixedfield.children).type == ARROWTYPES_TEST_AC.IntType(32, true)
+    @test abstractlistfield.type isa ARROWTYPES_TEST_AC.ListType
+    @test only(abstractlistfield.children).type == ARROWTYPES_TEST_AC.IntType(32, true)
+
+    values128 = arrowtypes_test_many_dict_values(128)
+    # The runtime types are counted once each: the 9th refuses, before any
+    # of the rest is lowered.
+    ARROWTYPES_TEST_MANY_DICT_TYPE_CALLS[] = 0
+    directerror = try
+        arrowtypes_test_bytes((value=Arrow.DictEncode(values128),); file=false)
+        nothing
+    catch e
+        e
+    end
+    @test directerror isa ArgumentError
+    @test occursin("more than 8 types", sprint(showerror, directerror))
+    @test ARROWTYPES_TEST_MANY_DICT_TYPE_CALLS[] <= 9
+
+    declaredtypes = Type[typeof(value) for value in values128[1:32]]
+    declared32 = Arrow._writeruniontype(declaredtypes)
+    @test length(Arrow._checkedwritervariants("declared writer", declared32)) == 32
+
+    declaredtypes33 = copy(declaredtypes)
+    push!(declaredtypes33, Core.apply_type(ArrowTypesTestManyDictValue, 33))
+    declared33 = Arrow._writeruniontype(declaredtypes33)
+    err = try
+        Arrow._checkedwritervariants("declared writer", declared33)
+        nothing
+    catch e
+        e
+    end
+    @test err isa ArgumentError
+    @test occursin(
+        "declared writer has more than 32 Union branches",
+        sprint(showerror, err),
+    )
+
+    values8 = values128[1:8]
+    input = (value=Arrow.DictEncode(values8),)
+    warmbytes = arrowtypes_test_bytes(input; file=false)
+    @test Arrow.Table(warmbytes).value == Int16.(1:8)
+    GC.gc()
+    @test (@allocated arrowtypes_test_bytes(input; file=false)) < 5_000_000
+
+    err = try
+        arrowtypes_test_bytes((value=Arrow.DictEncode(values128[1:9]),); file=false)
+        nothing
+    catch e
+        e
+    end
+    @test err isa ArgumentError
+    @test occursin("column value holds values of more than 8 types", sprint(showerror, err))
+
+    nineerror = function ()
+        try
+            arrowtypes_test_bytes((value=Arrow.DictEncode(values128[1:9]),); file=false)
+            return nothing
+        catch e
+            return e
+        end
+    end
+    ARROWTYPES_TEST_MANY_DICT_TYPE_CALLS[] = 0
+    err = nineerror()
+    @test err isa ArgumentError
+    @test ARROWTYPES_TEST_MANY_DICT_TYPE_CALLS[] == 0
+    GC.gc()
+    @test (@allocated nineerror()) < 5_000_000
+
+    # Partitions stream: each plans its own values, and later categories
+    # (other runtime types that lower the same way) extend the pool.
+    split8 = Tables.partitioner((
+        (value=Arrow.DictEncode(values128[1:4]),),
+        (value=Arrow.DictEncode(values128[5:8]),),
+    ))
+    @test Arrow.Table(arrowtypes_test_bytes(split8; file=false)).value == Int16.(1:8)
+    split9 = Tables.partitioner((
+        (value=Arrow.DictEncode(values128[1:4]),),
+        (value=Arrow.DictEncode(values128[5:9]),),
+    ))
+    @test Arrow.Table(arrowtypes_test_bytes(split9; file=false)).value == Int16.(1:9)
+
+    seedbytes = arrowtypes_test_bytes(
+        (
+            value=ArrowTypesTestManyRegisteredRuntime[ArrowTypesTestManyRegisteredValue{0}(
+                Int16(0),
+            ),],
+        );
+        file=false,
+    )
+    seedfield, _ = arrowtypes_test_core_parts(seedbytes)
+    seedschema = ARROWTYPES_TEST_AC.Schema([seedfield])
+    registered8 = arrowtypes_test_many_registered_values(8)
+    source8 = ArrowTypesTestRetainedPartitions(seedschema, ((value=registered8,),))
+    registeredbytes = arrowtypes_test_bytes(source8; file=false)
+    @test map(x -> x.value, Arrow.Table(registeredbytes).value) == Int16.(1:8)
+
+    source9 = ArrowTypesTestRetainedPartitions(
+        seedschema,
+        ((value=arrowtypes_test_many_registered_values(9),),),
+    )
+    @test map(
+        x -> x.value,
+        Arrow.Table(arrowtypes_test_bytes(source9; file=false)).value,
+    ) == Int16.(1:9)
+
+    SeedRow = @NamedTuple{child::ArrowTypesTestManyRegisteredRuntime}
+    StorageRow = Vector{Pair{String,Any}}
+    torows = values -> StorageRow[Pair{String,Any}["child" => value] for value in values]
+    seedrows = SeedRow[(child=ArrowTypesTestManyRegisteredValue{0}(Int16(0)),),]
+    nestedseedbytes = arrowtypes_test_bytes((value=seedrows,); file=false)
+    nestedfield, _ = arrowtypes_test_core_parts(nestedseedbytes)
+    nestedschema = ARROWTYPES_TEST_AC.Schema([nestedfield])
+    registered9 = arrowtypes_test_many_registered_values(9)
+
+    nested8 =
+        ArrowTypesTestRetainedPartitions(nestedschema, ((value=torows(registered9[1:8]),),))
+    nestedbytes = arrowtypes_test_bytes(nested8; file=false)
+    @test [
+        arrowtypes_test_rowdict(row)["child"].value for
+        row in Arrow.Table(nestedbytes).value
+    ] == Int16.(1:8)
+
+    # The target's storage is one concrete type, so any number of runtime
+    # types lower into it; the 8-type limit is for storage inferred from values.
+    source = ArrowTypesTestRetainedPartitions(nestedschema, ((value=torows(registered9),),))
+    @test [
+        arrowtypes_test_rowdict(row)["child"].value for
+        row in Arrow.Table(arrowtypes_test_bytes(source; file=false)).value
+    ] == Int16.(1:9)
+    # Each streamed partition is planned on its own, within the cap.
+    split = ArrowTypesTestRetainedPartitions(
+        nestedschema,
+        ((value=torows(registered9[1:4]),), (value=torows(registered9[5:9]),)),
+    )
+    @test [
+        arrowtypes_test_rowdict(row)["child"].value for
+        row in Arrow.Table(arrowtypes_test_bytes(split; file=false)).value
+    ] == Int16.(1:9)
+
+    @testset "retained registered inference is column-wide across children" begin
+        WideSeedRow = @NamedTuple{
+            left::ArrowTypesTestManyRegisteredRuntime,
+            right::ArrowTypesTestManyRegisteredRuntime,
+        }
+        seedvalue = ArrowTypesTestManyRegisteredValue{0}(Int16(0))
+        wideseed = WideSeedRow[(left=seedvalue, right=seedvalue)]
+        wideseedbytes = arrowtypes_test_bytes((value=wideseed,); file=false)
+        widefield, _ = arrowtypes_test_core_parts(wideseedbytes)
+        wideschema = ARROWTYPES_TEST_AC.Schema([widefield])
+
+        function widerange(range)
+            values = ArrowTypesTestManyRegisteredRuntime[]
+            for i in range
+                T = Core.apply_type(ArrowTypesTestManyRegisteredValue, i)
+                push!(values, T(Int16(i)))
+            end
+            return values
+        end
+        function widerows(left, right)
+            return Vector{Pair{String,Any}}[
+                Pair{String,Any}["left" => l, "right" => r] for (l, r) in zip(left, right)
+            ]
+        end
+
+        acceptedrows = widerows(widerange(1:4), widerange(5:8))
+        acceptedsource =
+            ArrowTypesTestRetainedPartitions(wideschema, ((value=acceptedrows,),))
+        acceptedbytes = arrowtypes_test_bytes(acceptedsource; file=false)
+        @test [
+            (
+                arrowtypes_test_rowdict(row)["left"].value,
+                arrowtypes_test_rowdict(row)["right"].value,
+            ) for row in Arrow.Table(acceptedbytes).value
+        ] == collect(zip(Int16.(1:4), Int16.(5:8)))
+
+        widerows10 = widerows(widerange(1:5), widerange(6:10))
+        widesource10 = ArrowTypesTestRetainedPartitions(wideschema, ((value=widerows10,),))
+        @test [
+            (
+                arrowtypes_test_rowdict(row)["left"].value,
+                arrowtypes_test_rowdict(row)["right"].value,
+            ) for row in Arrow.Table(arrowtypes_test_bytes(widesource10; file=false)).value
+        ] == collect(zip(Int16.(1:5), Int16.(6:10)))
+    end
+
+    @testset "fresh abstract storage across partitions follows the first" begin
+        first4 = arrowtypes_test_same_field_values(1:4)
+        again4 = arrowtypes_test_same_field_values(1:4)
+        ARROWTYPES_TEST_SAME_FIELD_LOWER_CALLS[] = 0
+        bytes = arrowtypes_test_bytes(
+            Tables.partitioner(((value=first4,), (value=again4,)));
+            file=false,
+        )
+        @test ARROWTYPES_TEST_SAME_FIELD_LOWER_CALLS[] == 8
+        field, batches = arrowtypes_test_core_parts(bytes)
+        @test field.type isa ARROWTYPES_TEST_AC.UnionType
+        @test all(
+            batch -> ARROWTYPES_TEST_AC.typeequal(batch.columns[1].type, field.type),
+            batches,
+        )
+        @test map(x -> x.value, Arrow.Table(bytes).value) == Int16[1:4; 1:4]
+
+        # Other runtime types with the same storage and label plan the same
+        # union, so they conform too.
+        second4 = arrowtypes_test_same_field_values(5:8)
+        bytes8 = arrowtypes_test_bytes(
+            Tables.partitioner(((value=first4,), (value=second4,)));
+            file=false,
+        )
+        field8, _ = arrowtypes_test_core_parts(bytes8)
+        @test ARROWTYPES_TEST_AC.typeequal(field8.type, field.type)
+        @test map(x -> x.value, Arrow.Table(bytes8).value) == Int16.(1:8)
+    end
+
+    @testset "declared registered Union bypasses the inference cap" begin
+        values = ArrowTypesTestDeclaredRegisteredUnion[
+            ArrowTypesTestDeclaredRegisteredUnionValue{n}(Int16(n)) for n = 1:9
+        ]
+
+        directbytes = arrowtypes_test_bytes((value=values,); file=false)
+        directfield, _ = arrowtypes_test_core_parts(directbytes)
+        @test directfield.type isa ARROWTYPES_TEST_AC.UnionType
+        @test length(directfield.children) == 9
+        @test Arrow.Table(directbytes).value == values
+
+        nestedvalues = Vector{ArrowTypesTestDeclaredRegisteredUnion}[values]
+        nestedbytes = arrowtypes_test_bytes((value=nestedvalues,); file=false)
+        nestedfield, _ = arrowtypes_test_core_parts(nestedbytes)
+        @test nestedfield.type isa ARROWTYPES_TEST_AC.ListType
+        nestedunionfield = only(nestedfield.children)
+        @test nestedunionfield.type isa ARROWTYPES_TEST_AC.UnionType
+        @test length(nestedunionfield.children) == 9
+        @test Arrow.Table(nestedbytes).value == nestedvalues
+    end
+
+    @testset "inference-only storage keeps an honest Null fallback" begin
+        allmissing = Union{Missing,ArrowTypesTestAbstractTupleStorage}[missing, missing]
+        allmissingbytes = arrowtypes_test_bytes((value=allmissing,); file=false)
+        allmissingfield, allmissingbatches = arrowtypes_test_core_parts(allmissingbytes)
+        @test allmissingfield.type isa ARROWTYPES_TEST_AC.NullType
+        @test allmissingfield.nullable
+        @test only(allmissingbatches).nrows == length(allmissing)
+        @test Tables.rowcount(Arrow.Table(allmissingbytes)) == length(allmissing)
+
+        empty = ArrowTypesTestAbstractTupleStorage[]
+        emptybytes = arrowtypes_test_bytes((value=empty,); file=false)
+        emptyfield, emptybatches = arrowtypes_test_core_parts(emptybytes)
+        @test emptyfield.type isa ARROWTYPES_TEST_AC.NullType
+        # A table with no rows writes no record batch.
+        @test isempty(emptybatches)
+        @test Tables.rowcount(Arrow.Table(emptybytes)) == 0
+    end
+end
+
+@testset "abstract Tuple narrowing terminates at its canonical type" begin
+    T = Tuple{Union{Missing,Int64}}
+    firstpart = T[(Int64(1),)]
+    secondpart = T[(missing,)]
+    layouts = (
+        ("one partition", (value=T[firstpart; secondpart],)),
+        ("mixed partition", Tables.partitioner(((value=T[firstpart; secondpart],),))),
+        ("split partitions", Tables.partitioner(((value=firstpart,), (value=secondpart,)))),
+    )
+    for (label, layout) in layouts, file in (false, true)
+        @testset "$label ($(file ? "file" : "stream"))" begin
+            bytes = arrowtypes_test_bytes(layout; file)
+            table = Arrow.Table(bytes)
+            @test isequal(collect.(table.value), Any[[Int64(1)], [missing]])
+            field, batches = arrowtypes_test_core_parts(bytes)
+            @test field.type isa ARROWTYPES_TEST_AC.FixedSizeListType
+            @test field.type.listsize == 1
+            foreach(
+                batch -> ARROWTYPES_TEST_AC.validate_full(field, batch.columns[1]),
+                batches,
+            )
+        end
+    end
+
+    StructT = Tuple{Union{Missing,Int64},String}
+    structvalues = StructT[(Int64(1), "one"), (missing, "missing")]
+    structlayouts = (
+        ("one partition", (value=structvalues,)),
+        ("mixed partition", Tables.partitioner(((value=structvalues,),))),
+        (
+            "split partitions",
+            Tables.partitioner(((value=structvalues[1:1],), (value=structvalues[2:2],))),
+        ),
+    )
+    for (label, layout) in structlayouts, file in (false, true)
+        @testset "heterogeneous $label ($(file ? "file" : "stream"))" begin
+            bytes = arrowtypes_test_bytes(layout; file)
+            table = Arrow.Table(bytes)
+            @test isequal(table.value, structvalues)
+            # Several partitions declare every field nullable.
+            @test eltype(table.value) === (
+                label == "split partitions" ?
+                Union{Missing,Tuple{Union{Missing,Int64},Union{Missing,String}}} : StructT
+            )
+            field, batches = arrowtypes_test_core_parts(bytes)
+            @test field.type isa ARROWTYPES_TEST_AC.StructType
+            @test occursin("Tuple", something(arrowtypes_test_extension_name(field), ""))
+            foreach(
+                batch -> ARROWTYPES_TEST_AC.validate_full(field, batch.columns[1]),
+                batches,
+            )
+        end
+    end
+end
+
+@testset "inference-only tuple storage is planned once per complete column" begin
+    Flex = ArrowTypesTestFlexTuple
+    values = Flex[Flex(Int16[1]), Flex(Int16[2, 3])]
+    for file in (false, true)
+        ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] = 0
+        bytes = arrowtypes_test_bytes((value=values,); file)
+        @test ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] == length(values)
+        @test Arrow.Table(bytes).value == values
+        field, _ = arrowtypes_test_core_parts(bytes)
+        @test field.type isa ARROWTYPES_TEST_AC.UnionType
+        @test sort([child.type.listsize for child in field.children]) == [1, 2]
+        @test arrowtypes_test_extension_name(field) ==
+              String(ARROWTYPES_TEST_FLEX_TUPLE_NAME)
+
+        # Streamed partitions take the schema from the first: an empty one
+        # plans null and one shape plans one fixed-size list, so later rows
+        # that need another type are refused, naming the difference.
+        for (parts, message) in (
+            ((value=Flex[],), (value=values,)) => "declared it null",
+            ((value=values[1:1],), (value=values[2:2],)) => "writes as fixed_size_list[2]",
+        )
+            err = try
+                arrowtypes_test_bytes(Tables.partitioner(parts); file)
+                nothing
+            catch e
+                e
+            end
+            @test err isa ArgumentError
+            @test occursin(message, sprint(showerror, err))
+        end
+    end
+
+    seedbytes = arrowtypes_test_bytes((value=values,); file=false)
+    seedfield, _ = arrowtypes_test_core_parts(seedbytes)
+    seedschema = ARROWTYPES_TEST_AC.Schema([seedfield])
+    emptysource = ArrowTypesTestRetainedPartitions(seedschema, ((value=Flex[],),))
+    for file in (false, true)
+        ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] = 0
+        emptybytes = arrowtypes_test_bytes(emptysource; file)
+        @test ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] == 0
+        @test Tables.rowcount(Arrow.Table(emptybytes)) == 0
+        emptyfield, emptybatches = arrowtypes_test_core_parts(emptybytes)
+        @test arrowtypes_test_field_contract_equal(seedfield, emptyfield)
+        @test isempty(emptybatches)
+    end
+
+    Row = @NamedTuple{child::Flex}
+    rows = Row[(child=values[1],), (child=values[2],)]
+    nestedbytes = arrowtypes_test_bytes((value=rows,); file=false)
+    nestedfield, _ = arrowtypes_test_core_parts(nestedbytes)
+    nestedschema = ARROWTYPES_TEST_AC.Schema([nestedfield])
+    emptyrows = Vector{Pair{String,Any}}[]
+    nestedsource = ArrowTypesTestRetainedPartitions(nestedschema, ((value=emptyrows,),))
+    for file in (false, true)
+        ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] = 0
+        rewritten = arrowtypes_test_bytes(nestedsource; file)
+        @test ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] == 0
+        rewrittenfield, _ = arrowtypes_test_core_parts(rewritten)
+        @test arrowtypes_test_field_contract_equal(nestedfield, rewrittenfield)
+        @test Tables.rowcount(Arrow.Table(rewritten)) == 0
+    end
+
+    categories = Flex[values[1], values[2], values[1]]
+    for file in (false, true)
+        ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] = 0
+        dictbytes = arrowtypes_test_bytes((value=Arrow.DictEncode(categories),); file)
+        @test ARROWTYPES_TEST_FLEX_TUPLE_CALLS[] == 2
+        @test Arrow.Table(dictbytes).value == categories
+        dictfield, dictbatches = arrowtypes_test_core_parts(dictbytes)
+        @test dictfield.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test dictfield.type.valuetype isa ARROWTYPES_TEST_AC.UnionType
+        @test length(only(dictbatches).columns[1].dictionary) == 2
+    end
+end
+
+@testset "retained hidden fixed lists avoid placeholder amplification" begin
+    emptyunion = function (listsize)
+        itemfield, itemdata = ARROWTYPES_TEST_AC.fromjulia("item", Int64[])
+        fixedtype = ARROWTYPES_TEST_AC.FixedSizeListType(listsize)
+        fixedfield = ARROWTYPES_TEST_AC.Field(
+            "huge",
+            fixedtype;
+            nullable=false,
+            children=[itemfield],
+        )
+        fixeddata = ARROWTYPES_TEST_AC.ArrayData(
+            fixedtype,
+            0,
+            [ARROWTYPES_TEST_AC.BufferSlice()];
+            children=[itemdata],
+            nullcount=0,
+        )
+        textfield, textdata = ARROWTYPES_TEST_AC.fromjulia("text", String[])
+        uniontype =
+            ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.SparseMode, Int8[42, 17])
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            uniontype;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(
+                ARROWTYPES_TEST_LOGICAL_LIST_UNION_NAME,
+            ),
+            children=[fixedfield, textfield],
+        )
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            uniontype,
+            0,
+            [ARROWTYPES_TEST_AC._databuffer(Int8[])];
+            children=[fixeddata, textdata],
+            nullcount=0,
+        )
+        return field, data
+    end
+    readempty = function (listsize)
+        field, data = emptyunion(listsize)
+        schema = ARROWTYPES_TEST_AC.Schema([field])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 0)
+        table = Arrow.Table(Arrow.writestream(schema, [batch]))
+        isempty(table.value) || error("empty Union materialized a row")
+        return nothing
+    end
+
+    readempty(2)
+    readempty(1_000)
+    readempty(100_000)
+
+    field, data = emptyunion(typemax(Int32))
+    arrowtypes_test_retained_rewrites(field, data, ArrowTypesTestLogicalListUnion[])
+
+    directmissing = function (listsize)
+        child = ARROWTYPES_TEST_AC.Field("item", ARROWTYPES_TEST_AC.NullType(); nullable=true)
+        t = ARROWTYPES_TEST_AC.FixedSizeListType(listsize)
+        field = ARROWTYPES_TEST_AC.Field("value", t; nullable=true, children=[child])
+        values = Union{Missing,Vector{Missing}}[missing]
+        rebuiltfield, rebuiltdata =
+            Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        return nothing
+    end
+    directmissing(2)
+    directmissing(1_000)
+    directmissing(100_000)
+
+    directmixed = function (listsize)
+        child = ARROWTYPES_TEST_AC.Field("item", ARROWTYPES_TEST_AC.NullType(); nullable=true)
+        t = ARROWTYPES_TEST_AC.FixedSizeListType(listsize)
+        field = ARROWTYPES_TEST_AC.Field("value", t; nullable=true, children=[child])
+        T = Union{Missing,Vector{Missing}}
+        values = T[fill(missing, listsize)]
+        append!(values, fill(missing, 49))
+        rebuiltfield, rebuiltdata =
+            Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        return nothing
+    end
+    directmixed(2)
+    directmixed(1_000)
+    directmixed(20_000)
+
+    freshmixed = function (listsize)
+        T = Union{Missing,Vector{Missing}}
+        values = T[fill(missing, listsize)]
+        append!(values, fill(missing, 49))
+        kind = ArrowTypes.FixedSizeListKind{listsize,Missing}()
+        rebuiltfield, rebuiltdata = Arrow._fixedlistpart(
+            "value",
+            values,
+            Arrow._WriterContext("value"),
+            ArrowTypes.getsize(kind),
+        )
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        return nothing
+    end
+    freshmixed(2)
+    freshmixed(1_000)
+    freshmixed(20_000)
+
+    nullsparsefield = function (listsize)
+        child = ARROWTYPES_TEST_AC.Field("item", ARROWTYPES_TEST_AC.NullType(); nullable=true)
+        fixed = ARROWTYPES_TEST_AC.Field(
+            "fixed",
+            ARROWTYPES_TEST_AC.FixedSizeListType(listsize);
+            nullable=false,
+            children=[child],
+        )
+        text = ARROWTYPES_TEST_AC.Field(
+            "text",
+            ARROWTYPES_TEST_AC.Utf8Type(false);
+            nullable=false,
+        )
+        uniontype =
+            ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.SparseMode, Int8[42, 17])
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            uniontype;
+            nullable=false,
+            children=[fixed, text],
+        )
+        return field
+    end
+    inactivesparse = function (listsize)
+        field = nullsparsefield(listsize)
+        rebuiltfield, rebuiltdata = Arrow._constructpart(
+            field,
+            Any["text"];
+            context=Arrow._WriterContext("value"),
+        )
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        schema = ARROWTYPES_TEST_AC.Schema([rebuiltfield])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [rebuiltdata], 1)
+        bytes = Arrow.writestream(schema, [batch])
+        Arrow.Table(bytes).value == ["text"] ||
+            error("inactive sparse fixed-list child changed the visible value")
+        return length(bytes)
+    end
+    inactivebytes = inactivesparse(2)
+    @test inactivesparse(1_000) == inactivebytes
+    @test inactivesparse(100_000) == inactivebytes
+
+    mixedsparse = function (listsize)
+        field = nullsparsefield(listsize)
+        values = Any[fill(missing, listsize)]
+        append!(values, ("text" for _ = 1:49))
+        rebuiltfield, rebuiltdata =
+            Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        return nothing
+    end
+    mixedsparse(2)
+    mixedsparse(1_000)
+    mixedsparse(20_000)
+    @test_throws ArgumentError Arrow._constructpart(
+        nullsparsefield(1),
+        Any[Any[nothing]];
+        context=Arrow._WriterContext("value"),
+    )
+
+    generalhidden = function (listsize)
+        child = ARROWTYPES_TEST_AC.Field(
+            "item",
+            ARROWTYPES_TEST_AC.IntType(64, true);
+            nullable=false,
+        )
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            ARROWTYPES_TEST_AC.FixedSizeListType(listsize);
+            nullable=true,
+            children=[child],
+        )
+        values = Any[collect(Int64, 1:listsize)]
+        append!(values, fill(missing, 49))
+        rebuiltfield, rebuiltdata =
+            Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        childdata = only(rebuiltdata.children)
+        @test length(childdata) == 50 * listsize
+        @test ARROWTYPES_TEST_AC.getvalue(child, childdata, Int64(1)) == 1
+        @test !ARROWTYPES_TEST_AC.isvalid_at(rebuiltdata, Int64(2))
+        return nothing
+    end
+    generalhidden(2)
+    generalhidden(1_000)
+    generalhidden(50_000)
+
+    freshnative = function (listsize)
+        T = Union{Missing,Vector{Int64}}
+        values = T[collect(Int64, 1:listsize)]
+        append!(values, fill(missing, 49))
+        kind = ArrowTypes.FixedSizeListKind{listsize,Int64}()
+        rebuiltfield, rebuiltdata = Arrow._fixedlistpart(
+            "value",
+            values,
+            Arrow._WriterContext("value"),
+            ArrowTypes.getsize(kind),
+        )
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        @test length(only(rebuiltdata.children)) == 50 * listsize
+        @test ARROWTYPES_TEST_AC.getvalue(
+            only(rebuiltfield.children),
+            only(rebuiltdata.children),
+            Int64(1),
+        ) == 1
+        return nothing
+    end
+    freshnative(2)
+    freshnative(1_000)
+    freshnative(50_000)
+
+    freshbool = function (listsize)
+        T = Union{Missing,Vector{Bool}}
+        values = T[Bool[isodd(index) for index = 1:listsize]]
+        append!(values, fill(missing, 49))
+        kind = ArrowTypes.FixedSizeListKind{listsize,Bool}()
+        rebuiltfield, rebuiltdata = Arrow._fixedlistpart(
+            "value",
+            values,
+            Arrow._WriterContext("value"),
+            ArrowTypes.getsize(kind),
+        )
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        childfield = only(rebuiltfield.children)
+        childdata = only(rebuiltdata.children)
+        @test length(childdata) == 50 * listsize
+        @test ARROWTYPES_TEST_AC.getvalue(childfield, childdata, Int64(1))
+        @test !ARROWTYPES_TEST_AC.getvalue(childfield, childdata, Int64(2))
+        return nothing
+    end
+    freshbool(2)
+    freshbool(1_000)
+    freshbool(100_000)
+
+    registeredhidden = function (listsize, missingrows=49)
+        child = ARROWTYPES_TEST_AC.Field(
+            "item",
+            ARROWTYPES_TEST_AC.IntType(32, true);
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_COUNTED_ID_NAME),
+        )
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            ARROWTYPES_TEST_AC.FixedSizeListType(listsize);
+            nullable=true,
+            children=[child],
+        )
+        T = Union{Missing,Vector{ArrowTypesTestCountedID}}
+        values = T[ArrowTypesTestCountedID.(Int32.(1:listsize))]
+        append!(values, fill(missing, missingrows))
+        ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] = 0
+        rebuiltfield, rebuiltdata =
+            Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        @test ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] == listsize
+        @test length(only(rebuiltdata.children)) == (missingrows + 1) * listsize
+        return nothing
+    end
+    registeredhidden(2)
+    registeredhidden(1_000)
+    # `@allocated` counts a big block's usable size, and macOS malloc can hand
+    # a request a cached region of up to twice its size; the allocation
+    # children run with that cache off so their readings track the requests.
+    allocchild(file) = addenv(
+        `$(Base.julia_cmd()) --startup-file=no --history-file=no --project=$(Base.active_project()) $(joinpath(@__DIR__, file))`,
+        "MallocLargeCache" => "0",
+    )
+    fixedlistallocoutput = read(allocchild("arrowtypes_fixedlist_alloc_child.jl"), String)
+    @test occursin("ArrowTypes fixed-list allocation guard passed", fixedlistallocoutput)
+
+    structallocoutput = read(allocchild("arrowtypes_struct_alloc_child.jl"), String)
+    @test occursin("ArrowTypes Struct allocation guard passed", structallocoutput)
+
+    countedchild = ARROWTYPES_TEST_AC.Field(
+        "item",
+        ARROWTYPES_TEST_AC.IntType(32, true);
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_COUNTED_ID_NAME),
+    )
+    allhiddenfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        ARROWTYPES_TEST_AC.FixedSizeListType(1_024);
+        nullable=true,
+        children=[countedchild],
+    )
+    ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] = 0
+    allhiddenvalues = Union{Missing,Vector{ArrowTypesTestCountedID}}[missing]
+    allhiddenrebuiltfield, allhiddenrebuiltdata = Arrow._constructpart(
+        allhiddenfield,
+        allhiddenvalues;
+        context=Arrow._WriterContext("value"),
+    )
+    ARROWTYPES_TEST_AC.validate_full(allhiddenrebuiltfield, allhiddenrebuiltdata)
+    @test ARROWTYPES_TEST_COUNTED_ID_LOWER_CALLS[] == 0
+    @test length(only(allhiddenrebuiltdata.children)) == 1_024
+
+    # Hidden parts hold the slots of null parent rows: whatever the child's
+    # layout, a struct of only null rows validates and reads as missing.
+    runfield = ARROWTYPES_TEST_AC.Field(
+        "run_ends",
+        ARROWTYPES_TEST_AC.IntType(32, true);
+        nullable=false,
+    )
+    reetype = ARROWTYPES_TEST_AC.RunEndEncodedType()
+    reefield = ARROWTYPES_TEST_AC.Field(
+        "ree",
+        reetype;
+        nullable=false,
+        children=[
+            runfield,
+            ARROWTYPES_TEST_AC.Field(
+                "values",
+                ARROWTYPES_TEST_AC.IntType(16, true);
+                nullable=false,
+            ),
+        ],
+    )
+    textfield =
+        ARROWTYPES_TEST_AC.Field("text", ARROWTYPES_TEST_AC.Utf8Type(false); nullable=false)
+    integerfield = ARROWTYPES_TEST_AC.Field(
+        "integer",
+        ARROWTYPES_TEST_AC.IntType(32, true);
+        nullable=false,
+    )
+    hiddenchildren = [reefield]
+    for mode in (ARROWTYPES_TEST_AC.DenseMode, ARROWTYPES_TEST_AC.SparseMode)
+        uniontype = ARROWTYPES_TEST_AC.UnionType(mode, Int8[3, 8])
+        push!(
+            hiddenchildren,
+            ARROWTYPES_TEST_AC.Field(
+                "union",
+                uniontype;
+                nullable=false,
+                children=[textfield, integerfield],
+            ),
+        )
+    end
+    dictionarytype = ARROWTYPES_TEST_AC.DictionaryType(
+        ARROWTYPES_TEST_AC.IntType(32, true),
+        ARROWTYPES_TEST_AC.NullType(),
+        false,
+    )
+    push!(
+        hiddenchildren,
+        ARROWTYPES_TEST_AC.Field("dictionary_null", dictionarytype; nullable=false),
+    )
+    for child in hiddenchildren, n in (0, 3)
+        parent = ARROWTYPES_TEST_AC.Field(
+            "parent",
+            ARROWTYPES_TEST_AC.StructType();
+            nullable=true,
+            children=[child],
+        )
+        rebuiltfield, rebuiltdata =
+            Arrow._constructhiddenpart(parent, n, Arrow._WriterContext("parent"))
+        ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+        @test all(ismissing, ARROWTYPES_TEST_AC.materialize(rebuiltfield, rebuiltdata))
+        @test length(only(rebuiltdata.children)) == n
+    end
+end
+
+@testset "nested nullable fixed lists preserve Null-only validity" begin
+    nullfield =
+        ARROWTYPES_TEST_AC.Field("null", ARROWTYPES_TEST_AC.NullType(); nullable=true)
+    innertype = ARROWTYPES_TEST_AC.FixedSizeListType(2)
+    innerfield =
+        ARROWTYPES_TEST_AC.Field("inner", innertype; nullable=true, children=[nullfield])
+    outertype = ARROWTYPES_TEST_AC.FixedSizeListType(2)
+    outerfield =
+        ARROWTYPES_TEST_AC.Field("value", outertype; nullable=true, children=[innerfield])
+
+    for innervalid in (Bool[true, true], Bool[true, false])
+        nulldata = ARROWTYPES_TEST_AC.ArrayData(
+            nullfield.type,
+            4,
+            ARROWTYPES_TEST_AC.BufferSlice[];
+            nullcount=4,
+        )
+        innerdata = ARROWTYPES_TEST_AC.ArrayData(
+            innertype,
+            2,
+            [ARROWTYPES_TEST_AC._bitmapbuffer(innervalid)];
+            children=[nulldata],
+            nullcount=count(!, innervalid),
+        )
+        outerdata = ARROWTYPES_TEST_AC.ArrayData(
+            outertype,
+            1,
+            [ARROWTYPES_TEST_AC.BufferSlice()];
+            children=[innerdata],
+            nullcount=0,
+        )
+        # The outer list's values are nullable, so its rows are `ListValue`s.
+        expectedrow =
+            Any[innervalid[i] ? (missing, missing) : missing for i in eachindex(innervalid)]
+        expected = Any[expectedrow]
+        schema = ARROWTYPES_TEST_AC.Schema([outerfield])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [outerdata], 1)
+        for inputfile in (false, true)
+            inputbytes =
+                inputfile ? Arrow.writefile(schema, [batch]) :
+                Arrow.writestream(schema, [batch])
+            @test isequal(Arrow.Table(inputbytes).value, expected)
+            for sourcekind in (:table, :stream), outputfile in (false, true)
+                source =
+                    sourcekind === :table ? Arrow.Table(inputbytes) :
+                    Arrow.Stream(inputbytes)
+                outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+                @test isequal(Arrow.Table(outputbytes).value, expected)
+                outputfield, outputbatches = arrowtypes_test_core_parts(outputbytes)
+                @test arrowtypes_test_field_contract_equal(outputfield, outerfield)
+                outputinner = only(only(outputbatches).columns[1].children)
+                @test [
+                    ARROWTYPES_TEST_AC.isvalid_at(outputinner, Int64(i)) for
+                    i in eachindex(innervalid)
+                ] == innervalid
+            end
+        end
+    end
+
+    values = Any[Any[fill(missing, 2), missing], missing, Any[missing, fill(missing, 2)]]
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(outerfield, values; context=Arrow._WriterContext("value"))
+    ARROWTYPES_TEST_AC.validate_full(rebuiltfield, rebuiltdata)
+    @test isequal(ARROWTYPES_TEST_AC.materialize(rebuiltfield, rebuiltdata), values)
+    @test [
+        ARROWTYPES_TEST_AC.isvalid_at(rebuiltdata, Int64(i)) for i in eachindex(values)
+    ] == Bool[true, false, true]
+    rebuiltinner = only(rebuiltdata.children)
+    @test [ARROWTYPES_TEST_AC.isvalid_at(rebuiltinner, Int64(i)) for i = 1:6] == Bool[true, false, false, false, false, true]
+
+    nonnullableinner =
+        ARROWTYPES_TEST_AC.Field("inner", innertype; nullable=false, children=[nullfield])
+    invalidfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        outertype;
+        nullable=true,
+        children=[nonnullableinner],
+    )
+    @test_throws ArgumentError Arrow._constructpart(
+        invalidfield,
+        Any[Any[fill(missing, 2), missing]];
+        context=Arrow._WriterContext("value"),
+    )
+
+    advisorynull =
+        ARROWTYPES_TEST_AC.Field("null", ARROWTYPES_TEST_AC.NullType(); nullable=false)
+    advisoryinner =
+        ARROWTYPES_TEST_AC.Field("inner", innertype; nullable=true, children=[advisorynull])
+    advisoryouter = ARROWTYPES_TEST_AC.Field(
+        "value",
+        outertype;
+        nullable=true,
+        children=[advisoryinner],
+    )
+    advisoryvalues = Any[Any[fill(missing, 2), missing]]
+    advisoryfield, advisorydata = Arrow._constructpart(
+        advisoryouter,
+        advisoryvalues;
+        context=Arrow._WriterContext("value"),
+    )
+    @test isequal(
+        ARROWTYPES_TEST_AC.materialize(advisoryfield, advisorydata),
+        advisoryvalues,
+    )
+end
+
+@testset "retained registered descriptor aliases" begin
+    @testset "LargeUtf8" begin
+        values = ["one", "arrows"]
+        bytes = collect(codeunits(join(values)))
+        t = ARROWTYPES_TEST_AC.Utf8Type(true)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_LABEL_NAME),
+        )
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            2,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int64[0, 3, 9]),
+                ARROWTYPES_TEST_AC._databuffer(bytes),
+            ];
+            nullcount=0,
+        )
+        arrowtypes_test_retained_rewrites(field, data, ArrowTypesTestLabel.(values))
+    end
+
+    @testset "Timestamp(SECOND)" begin
+        t = ARROWTYPES_TEST_AC.TimestampType(ARROWTYPES_TEST_AC.SECOND, nothing)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(
+                ARROWTYPES_TEST_SECOND_TIMESTAMP_NAME,
+            ),
+        )
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            2,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int64[1, 61]),
+            ];
+            nullcount=0,
+        )
+        expected = ArrowTypesTestSecondTimestamp[
+            ArrowTypesTestSecondTimestamp(DateTime(1970, 1, 1, 0, 0, 1)),
+            ArrowTypesTestSecondTimestamp(DateTime(1970, 1, 1, 0, 1, 1)),
+        ]
+        arrowtypes_test_retained_rewrites(field, data, expected)
+    end
+end
+
+@testset "retained binary storage aliases" begin
+    @testset "LargeBinary" begin
+        t = ARROWTYPES_TEST_AC.BinaryType(true)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_BYTES_ALIAS_NAME),
+        )
+        values = [UInt8[0x01, 0x02, 0x03], UInt8[0xff]]
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            2,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int64[0, 3, 4]),
+                ARROWTYPES_TEST_AC._databuffer(vcat(values...)),
+            ];
+            nullcount=0,
+        )
+        arrowtypes_test_retained_rewrites(field, data, ArrowTypesTestBytesAlias.(values))
+    end
+
+    @testset "BinaryView" begin
+        inlineentry = function (payload)
+            entry = zeros(UInt8, 16)
+            lengthbytes = collect(reinterpret(UInt8, Int32[Int32(length(payload))]))
+            copyto!(entry, 1, lengthbytes, 1, 4)
+            copyto!(entry, 5, payload, 1, length(payload))
+            return entry
+        end
+        t = ARROWTYPES_TEST_AC.ViewType(false)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_BYTES_ALIAS_NAME),
+        )
+        values = [UInt8[0x00, 0xff], UInt8[0x01, 0x02, 0x03]]
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            2,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(vcat(inlineentry.(values)...)),
+            ];
+            nullcount=0,
+        )
+        arrowtypes_test_retained_rewrites(field, data, ArrowTypesTestBytesAlias.(values))
+    end
+
+    @testset "FixedSizeBinary" begin
+        t = ARROWTYPES_TEST_AC.FixedSizeBinaryType(3)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_BYTES_ALIAS_NAME),
+        )
+        values = [UInt8[0x01, 0x02, 0x03], UInt8[0x04, 0x05, 0x06]]
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            2,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(vcat(values...)),
+            ];
+            nullcount=0,
+        )
+        arrowtypes_test_retained_rewrites(field, data, ArrowTypesTestBytesAlias.(values))
+        wrong = ArrowTypesTestBytesAlias[
+            ArrowTypesTestBytesAlias(UInt8[0x01, 0x02]),
+            ArrowTypesTestBytesAlias(UInt8[0x03, 0x04]),
+        ]
+        arrowtypes_test_retained_replacement_error(field, data, wrong, "expected 3")
+    end
+
+    @testset "opaque aliases reject nullable child storage" begin
+        t = ARROWTYPES_TEST_AC.BinaryType(true)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(
+                ARROWTYPES_TEST_NULLABLE_BYTES_ALIAS_NAME,
+            ),
+        )
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            0,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int64[0]),
+                ARROWTYPES_TEST_AC._databuffer(UInt8[]),
+            ];
+            nullcount=0,
+        )
+        # Nothing to check in an empty column: it writes under the retained field.
+        arrowtypes_test_retained_rewrites(field, data, ArrowTypesTestNullableBytesAlias[])
+        onerow = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            1,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int64[0, 1]),
+                ARROWTYPES_TEST_AC._databuffer(UInt8[0x01]),
+            ];
+            nullcount=0,
+        )
+        arrowtypes_test_retained_replacement_error(
+            field,
+            onerow,
+            [ArrowTypesTestNullableBytesAlias(Union{Missing,UInt8}[0x01, missing])],
+            "must contain byte-vector",
+        )
+    end
+end
+
+@testset "retained wide Decimal storage aliases" begin
+    for (bits, width) in ((128, 16), (256, 32))
+        @testset "Decimal$bits" begin
+            t = ARROWTYPES_TEST_AC.DecimalType(bits == 128 ? 30 : 60, 4, bits)
+            field = ARROWTYPES_TEST_AC.Field(
+                "value",
+                t;
+                nullable=false,
+                metadata=arrowtypes_test_extension_metadata(
+                    ARROWTYPES_TEST_BYTES_ALIAS_NAME,
+                ),
+            )
+            values = [UInt8.(1:width), reverse(UInt8.(1:width))]
+            data = ARROWTYPES_TEST_AC.ArrayData(
+                t,
+                2,
+                [
+                    ARROWTYPES_TEST_AC.BufferSlice(),
+                    ARROWTYPES_TEST_AC._databuffer(vcat(values...)),
+                ];
+                nullcount=0,
+            )
+            expected = ArrowTypesTestBytesAlias.(values)
+            arrowtypes_test_retained_rewrites(field, data, expected)
+            wrong = ArrowTypesTestBytesAlias[
+                ArrowTypesTestBytesAlias(zeros(UInt8, width - 1)),
+                ArrowTypesTestBytesAlias(zeros(UInt8, width - 1)),
+            ]
+            arrowtypes_test_retained_replacement_error(
+                field,
+                data,
+                wrong,
+                "expected $width",
+            )
+        end
+    end
+end
+
+@testset "retained sequence storage aliases" begin
+    childfield, childdata = ARROWTYPES_TEST_AC.fromjulia("item", Int32[1, 2, 3, 4])
+    metadata = arrowtypes_test_extension_metadata(ARROWTYPES_TEST_INT_LIST_ALIAS_NAME)
+    cases = (
+        (
+            "LargeList",
+            ARROWTYPES_TEST_AC.ListType(true),
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int64[0, 2, 4]),
+            ],
+            [Int32[1, 2], Int32[3, 4]],
+        ),
+        (
+            "ListView",
+            ARROWTYPES_TEST_AC.ListViewType(false),
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int32[1, 0]),
+                ARROWTYPES_TEST_AC._databuffer(Int32[2, 1]),
+            ],
+            [Int32[2, 3], Int32[1]],
+        ),
+        (
+            "FixedSizeList",
+            ARROWTYPES_TEST_AC.FixedSizeListType(2),
+            [ARROWTYPES_TEST_AC.BufferSlice()],
+            [Int32[1, 2], Int32[3, 4]],
+        ),
+    )
+    for (label, t, buffers, values) in cases
+        @testset "$label" begin
+            field = ARROWTYPES_TEST_AC.Field(
+                "value",
+                t;
+                nullable=false,
+                metadata,
+                children=[childfield],
+            )
+            data = ARROWTYPES_TEST_AC.ArrayData(
+                t,
+                2,
+                buffers;
+                children=[childdata],
+                nullcount=0,
+            )
+            arrowtypes_test_retained_rewrites(
+                field,
+                data,
+                ArrowTypesTestIntListAlias.(values),
+            )
+            if t isa ARROWTYPES_TEST_AC.FixedSizeListType
+                wrong = ArrowTypesTestIntListAlias[
+                    ArrowTypesTestIntListAlias(Int32[1]),
+                    ArrowTypesTestIntListAlias(Int32[2, 3, 4]),
+                ]
+                arrowtypes_test_retained_replacement_error(field, data, wrong, "expected 2")
+            end
+        end
+    end
+
+    emptychildfield, emptychilddata = ARROWTYPES_TEST_AC.fromjulia("item", Int32[])
+    fixedtype = ARROWTYPES_TEST_AC.FixedSizeListType(2)
+    fixedfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        fixedtype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_FIXED_LIST3_NAME),
+        children=[emptychildfield],
+    )
+    fixeddata = ARROWTYPES_TEST_AC.ArrayData(
+        fixedtype,
+        0,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[emptychilddata],
+        nullcount=0,
+    )
+    # An empty column has no value to refuse: it keeps the retained field.
+    arrowtypes_test_retained_rewrites(fixedfield, fixeddata, ArrowTypesTestFixedList3[])
+end
+
+@testset "retained Interval storage aliases" begin
+    cases = (
+        (
+            "DAY_TIME",
+            ARROWTYPES_TEST_AC.DAY_TIME,
+            ArrowTypesTestDayTimeStorage[
+                (days=Int32(1), millis=Int32(2)),
+                (days=Int32(-3), millis=Int32(4)),
+            ],
+            ArrowTypesTestDayTimeInterval,
+            ARROWTYPES_TEST_DAY_TIME_INTERVAL_NAME,
+        ),
+        (
+            "MONTH_DAY_NANO",
+            ARROWTYPES_TEST_AC.MONTH_DAY_NANO,
+            ArrowTypesTestMonthDayNanoStorage[
+                (months=Int32(1), days=Int32(2), nanos=Int64(3)),
+                (months=Int32(-4), days=Int32(5), nanos=Int64(-6)),
+            ],
+            ArrowTypesTestMonthDayNanoInterval,
+            ARROWTYPES_TEST_MONTH_DAY_NANO_INTERVAL_NAME,
+        ),
+    )
+    for (label, unit, values, Wrapper, name) in cases
+        @testset "$label" begin
+            t = ARROWTYPES_TEST_AC.IntervalType(unit)
+            field = ARROWTYPES_TEST_AC.Field(
+                "value",
+                t;
+                nullable=false,
+                metadata=arrowtypes_test_extension_metadata(name),
+            )
+            data = ARROWTYPES_TEST_AC.ArrayData(
+                t,
+                2,
+                [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(values)];
+                nullcount=0,
+            )
+            arrowtypes_test_retained_rewrites(field, data, Wrapper.(values))
+        end
+    end
+end
+
+@testset "retained temporal aliases convert across descriptors exactly" begin
+    @testset "Duration SECOND from Millisecond" begin
+        t = ARROWTYPES_TEST_AC.DurationType(ARROWTYPES_TEST_AC.SECOND)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(
+                ARROWTYPES_TEST_MILLISECOND_DURATION_NAME,
+            ),
+        )
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            1,
+            [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int64[2])];
+            nullcount=0,
+        )
+        expected = [ArrowTypesTestMillisecondDuration(Dates.Millisecond(2_000))]
+        arrowtypes_test_retained_rewrites(field, data, expected)
+
+        schema = ARROWTYPES_TEST_AC.Schema([field])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 1)
+        source = Arrow.Table(Arrow.writestream(schema, [batch]))
+        getfield(source, :columns)[1] =
+            [ArrowTypesTestMillisecondDuration(Dates.Millisecond(1_500))]
+        for file in (false, true)
+            err = try
+                arrowtypes_test_bytes(source; file)
+                nothing
+            catch e
+                e
+            end
+            @test err isa ArgumentError
+            @test occursin("cannot be represented exactly", sprint(showerror, err))
+        end
+    end
+
+    @testset "Date32 from Timestamp(MILLISECOND)" begin
+        day = Date(2024, 1, 2)
+        t = ARROWTYPES_TEST_AC.DateType(ARROWTYPES_TEST_AC.DAY)
+        field = ARROWTYPES_TEST_AC.Field(
+            "value",
+            t;
+            nullable=false,
+            metadata=arrowtypes_test_extension_metadata(
+                ARROWTYPES_TEST_DATE_LIKE_ALIAS_NAME,
+            ),
+        )
+        data = ARROWTYPES_TEST_AC.ArrayData(
+            t,
+            1,
+            [
+                ARROWTYPES_TEST_AC.BufferSlice(),
+                ARROWTYPES_TEST_AC._databuffer(Int32[Dates.value(day - Date(1970, 1, 1))]),
+            ];
+            nullcount=0,
+        )
+        expected = [ArrowTypesTestDateLikeAlias(DateTime(day))]
+        arrowtypes_test_retained_rewrites(field, data, expected)
+
+        schema = ARROWTYPES_TEST_AC.Schema([field])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 1)
+        source = Arrow.Table(Arrow.writestream(schema, [batch]))
+        getfield(source, :columns)[1] =
+            [ArrowTypesTestDateLikeAlias(DateTime(2024, 1, 2, 12))]
+        for file in (false, true)
+            err = try
+                arrowtypes_test_bytes(source; file)
+                nothing
+            catch e
+                e
+            end
+            @test err isa ArgumentError
+            @test occursin("cannot be represented exactly", sprint(showerror, err))
+        end
+    end
+end
+
+@testset "retained Map rejects keyssorted relabeling" begin
+    keyfield, keydata = ARROWTYPES_TEST_AC.fromjulia("key", Int32[1, 3])
+    valuefield, valuedata = ARROWTYPES_TEST_AC.fromjulia("value", Int32[2, 4])
+    structtype = ARROWTYPES_TEST_AC.StructType()
+    entriesfield = ARROWTYPES_TEST_AC.Field(
+        "entries",
+        structtype;
+        nullable=false,
+        children=[keyfield, valuefield],
+    )
+    entriesdata = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[keydata, valuedata],
+        nullcount=0,
+    )
+    maptype = ARROWTYPES_TEST_AC.MapType(true)
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        maptype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_SORTED_MAP_NAME),
+        children=[entriesfield],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        maptype,
+        1,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 2])];
+        children=[entriesdata],
+        nullcount=0,
+    )
+    schema = ARROWTYPES_TEST_AC.Schema([field])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 1)
+    expected = [ArrowTypesTestSortedMap(Dict(Int32(1) => Int32(2), Int32(3) => Int32(4)))]
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(schema, [batch]) :
+            Arrow.writestream(schema, [batch])
+        @test Arrow.Table(inputbytes).value == expected
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            # A Dict's entries take its hash order: rows that come out sorted
+            # keep the declared order, and others are refused.
+            err = try
+                back = Arrow.Table(arrowtypes_test_bytes(source; file=outputfile))
+                @test back.value == expected
+                nothing
+            catch e
+                e
+            end
+            err === nothing || @test occursin(
+                "not sorted by its physical key storage",
+                sprint(showerror, err),
+            )
+        end
+    end
+
+    ordinaryfield =
+        ARROWTYPES_TEST_AC.Field("value", maptype; nullable=false, children=[entriesfield])
+    unsorted = [Pair{Any,Any}[Int32(3) => Int32(4), Int32(1) => Int32(2)]]
+    arrowtypes_test_retained_replacement_error(
+        ordinaryfield,
+        data,
+        unsorted,
+        "not sorted by its physical key storage",
+    )
+
+    emptykeyfield, emptykeydata = ARROWTYPES_TEST_AC.fromjulia("key", Int32[])
+    emptyvaluefield, emptyvaluedata = ARROWTYPES_TEST_AC.fromjulia("value", Int32[])
+    emptyentriesfield = ARROWTYPES_TEST_AC.Field(
+        "entries",
+        structtype;
+        nullable=false,
+        children=[emptykeyfield, emptyvaluefield],
+    )
+    emptyentriesdata = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        0,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[emptykeydata, emptyvaluedata],
+        nullcount=0,
+    )
+    emptymapfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        maptype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_SORTED_MAP_NAME),
+        children=[emptyentriesfield],
+    )
+    emptymapdata = ARROWTYPES_TEST_AC.ArrayData(
+        maptype,
+        0,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0])];
+        children=[emptyentriesdata],
+        nullcount=0,
+    )
+    arrowtypes_test_retained_rewrites(
+        emptymapfield,
+        emptymapdata,
+        ArrowTypesTestSortedMap[],
+    )
+end
+
+@testset "encoding identity uses physical ArrowTypes values" begin
+    parityvalues = ArrowTypesTestParityID.(Int64[1, 3, 2, 4])
+    layouts = (
+        ("one partition", (value=Arrow.DictEncode(parityvalues),)),
+        (
+            "split partitions",
+            Tables.partitioner((
+                (value=Arrow.DictEncode(parityvalues[1:2]),),
+                (value=Arrow.DictEncode(parityvalues[3:4]),),
+            )),
+        ),
+    )
+    for (label, layout) in layouts, file in (false, true)
+        @testset "dictionary $label ($(file ? "file" : "stream"))" begin
+            bytes = arrowtypes_test_bytes(layout; file)
+            table = Arrow.Table(bytes)
+            @test getproperty.(table.value, :value) == getproperty.(parityvalues, :value)
+            field, batches = arrowtypes_test_core_parts(bytes)
+            # Split partitions extend the first partition's pool.
+            dictionary = last(batches).columns[1].dictionary
+            @test length(dictionary) == 4
+            valuefield = ARROWTYPES_TEST_AC.dictvaluefield(field, field.type)
+            @test ARROWTYPES_TEST_AC.materialize(valuefield, dictionary) ==
+                  Int64[1, 3, 2, 4]
+        end
+    end
+
+    mutablevalues = ArrowTypesTestMutableID.(Int64[1, 2, 1])
+    mutablelayouts = (
+        (value=Arrow.DictEncode(mutablevalues),),
+        Tables.partitioner((
+            (value=Arrow.DictEncode(mutablevalues[1:2]),),
+            (value=Arrow.DictEncode(mutablevalues[3:3]),),
+        )),
+    )
+    physicalpools = function (bytes)
+        field, batches = arrowtypes_test_core_parts(bytes)
+        valuefield = ARROWTYPES_TEST_AC.dictvaluefield(field, field.type)
+        return [
+            ARROWTYPES_TEST_AC.materialize(
+                valuefield,
+                batch.columns[1].dictionary::ARROWTYPES_TEST_AC.ArrayData,
+            ) for batch in batches
+        ]
+    end
+    for layout in mutablelayouts, file in (false, true)
+        bytes = arrowtypes_test_bytes(layout; file)
+        @test all(==([1, 2]), physicalpools(bytes))
+        @test getproperty.(Arrow.Table(bytes).value, :value) == Int64[1, 2, 1]
+    end
+    splitbytes = arrowtypes_test_bytes(last(mutablelayouts); file=false)
+    for sourcekind in (:table, :stream), outputfile in (false, true)
+        rewritten = splitbytes
+        for _ = 1:3
+            source =
+                sourcekind === :table ? Arrow.Table(rewritten) : Arrow.Stream(rewritten)
+            rewritten = arrowtypes_test_bytes(source; file=outputfile)
+            @test all(==([1, 2]), physicalpools(rewritten))
+            @test getproperty.(Arrow.Table(rewritten).value, :value) == Int64[1, 2, 1]
+        end
+    end
+
+    # The first retained pool is part of the encoding contract. Preserve its
+    # positions even when two categories have identical physical storage.
+    duplicatevaluefield, duplicatepool =
+        ARROWTYPES_TEST_AC.fromjulia("value", Int64[1, 1, 2])
+    duplicatedicttype = ARROWTYPES_TEST_AC.DictionaryType(
+        ARROWTYPES_TEST_AC.IntType(32, true),
+        duplicatevaluefield.type,
+        false,
+    )
+    duplicatedictfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        duplicatedicttype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_MUTABLE_ID_NAME),
+    )
+    duplicatedictdata = ARROWTYPES_TEST_AC.ArrayData(
+        duplicatedicttype,
+        3,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 1, 2])];
+        dictionary=duplicatepool,
+        nullcount=0,
+    )
+    duplicateschema = ARROWTYPES_TEST_AC.Schema([duplicatedictfield])
+    duplicatebatch = ARROWTYPES_TEST_AC.RecordBatch(duplicateschema, [duplicatedictdata], 3)
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(duplicateschema, [duplicatebatch]) :
+            Arrow.writestream(duplicateschema, [duplicatebatch])
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            @test getproperty.(Arrow.Table(outputbytes).value, :value) == Int64[1, 1, 2]
+            outputfield, outputbatches = arrowtypes_test_core_parts(outputbytes)
+            outputpool = only(outputbatches).columns[1].dictionary
+            @test outputpool !== nothing
+            outputvaluefield =
+                ARROWTYPES_TEST_AC.dictvaluefield(outputfield, outputfield.type)
+            @test ARROWTYPES_TEST_AC.materialize(outputvaluefield, outputpool) ==
+                  Int64[1, 1, 2]
+        end
+    end
+
+    runfield, runenddata = ARROWTYPES_TEST_AC.fromjulia("run_ends", Int32[1, 2])
+    _, runvaluedata = ARROWTYPES_TEST_AC.fromjulia("values", Int64[1, 3])
+    runvaluefield = arrowtypes_test_marked_id_field("values")
+    runvaluefield = ARROWTYPES_TEST_AC.Field(
+        runvaluefield.name,
+        runvaluefield.type;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_PARITY_ID_NAME),
+    )
+    reetype = ARROWTYPES_TEST_AC.RunEndEncodedType()
+    reefield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        reetype;
+        nullable=false,
+        children=[runfield, runvaluefield],
+    )
+    reedata = ARROWTYPES_TEST_AC.ArrayData(
+        reetype,
+        2,
+        ARROWTYPES_TEST_AC.BufferSlice[];
+        children=[runenddata, runvaluedata],
+        nullcount=0,
+    )
+    reeschema = ARROWTYPES_TEST_AC.Schema([reefield])
+    reebatch = ARROWTYPES_TEST_AC.RecordBatch(reeschema, [reedata], 2)
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(reeschema, [reebatch]) :
+            Arrow.writestream(reeschema, [reebatch])
+        @test getproperty.(Arrow.Table(inputbytes).value, :value) == Int64[1, 3]
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            @test getproperty.(Arrow.Table(outputbytes).value, :value) == Int64[1, 3]
+            outputfield, outputbatches = arrowtypes_test_core_parts(outputbytes)
+            outputvalues = only(outputbatches).columns[1].children[2]
+            @test ARROWTYPES_TEST_AC.materialize(outputfield.children[2], outputvalues) ==
+                  Int64[1, 3]
+        end
+    end
+
+    mutablerunfield, mutablerunenddata = ARROWTYPES_TEST_AC.fromjulia("run_ends", Int32[4])
+    _, mutablerunvaluedata = ARROWTYPES_TEST_AC.fromjulia("values", Int64[1])
+    mutablerunvaluefield = ARROWTYPES_TEST_AC.Field(
+        "values",
+        ARROWTYPES_TEST_AC.IntType(64, true);
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_MUTABLE_ID_NAME),
+    )
+    mutablereefield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        reetype;
+        nullable=false,
+        children=[mutablerunfield, mutablerunvaluefield],
+    )
+    mutablereedata = ARROWTYPES_TEST_AC.ArrayData(
+        reetype,
+        4,
+        ARROWTYPES_TEST_AC.BufferSlice[];
+        children=[mutablerunenddata, mutablerunvaluedata],
+        nullcount=0,
+    )
+    mutablereeschema = ARROWTYPES_TEST_AC.Schema([mutablereefield])
+    mutablereebatch = ARROWTYPES_TEST_AC.RecordBatch(mutablereeschema, [mutablereedata], 4)
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(mutablereeschema, [mutablereebatch]) :
+            Arrow.writestream(mutablereeschema, [mutablereebatch])
+        @test getproperty.(Arrow.Table(inputbytes).value, :value) == fill(Int64(1), 4)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            outputfield, outputbatches = arrowtypes_test_core_parts(outputbytes)
+            outputdata = only(outputbatches).columns[1]
+            @test outputdata.children[2].len == 1
+            @test ARROWTYPES_TEST_AC.materialize(
+                outputfield.children[1],
+                outputdata.children[1],
+            ) == Int32[4]
+            @test ARROWTYPES_TEST_AC.materialize(
+                outputfield.children[2],
+                outputdata.children[2],
+            ) == Int64[1]
+        end
+    end
+
+    reversekeyfield = ARROWTYPES_TEST_AC.Field(
+        "key",
+        ARROWTYPES_TEST_AC.IntType(64, true);
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_REVERSE_ID_NAME),
+    )
+    _, reversekeydata = ARROWTYPES_TEST_AC.fromjulia("key", Int64[1, 2])
+    reversevaluefield, reversevaluedata =
+        ARROWTYPES_TEST_AC.fromjulia("value", Int32[10, 20])
+    reverseentries = ARROWTYPES_TEST_AC.Field(
+        "entries",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        children=[reversekeyfield, reversevaluefield],
+    )
+    reverseentriesdata = ARROWTYPES_TEST_AC.ArrayData(
+        reverseentries.type,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[reversekeydata, reversevaluedata],
+        nullcount=0,
+    )
+    reversemaptype = ARROWTYPES_TEST_AC.MapType(true)
+    reversemapfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        reversemaptype;
+        nullable=false,
+        children=[reverseentries],
+    )
+    reversemapdata = ARROWTYPES_TEST_AC.ArrayData(
+        reversemaptype,
+        1,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 2])];
+        children=[reverseentriesdata],
+        nullcount=0,
+    )
+    reversemapschema = ARROWTYPES_TEST_AC.Schema([reversemapfield])
+    reversemapbatch = ARROWTYPES_TEST_AC.RecordBatch(reversemapschema, [reversemapdata], 1)
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(reversemapschema, [reversemapbatch]) :
+            Arrow.writestream(reversemapschema, [reversemapbatch])
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            outputtable = Arrow.Table(outputbytes)
+            @test getproperty.(first.(only(outputtable.value)), :value) == Int64[1, 2]
+        end
+
+        replacement = Arrow.Table(inputbytes)
+        getfield(replacement, :columns)[1] = Any[Pair{Any,Any}[
+            ArrowTypesTestReverseID(2) => Int32(20),
+            ArrowTypesTestReverseID(1) => Int32(10),
+        ],]
+        for outputfile in (false, true)
+            err = try
+                arrowtypes_test_bytes(replacement; file=outputfile)
+                nothing
+            catch exception
+                exception
+            end
+            @test err isa ArgumentError
+            @test occursin("physical key storage", sprint(showerror, err))
+        end
+    end
+
+    collisionrow = Dict(
+        ArrowTypesTestCollidingMapKey(1) => Int32(10),
+        ArrowTypesTestCollidingMapKey(2) => Int32(20),
+    )
+    for outputfile in (false, true)
+        err = try
+            arrowtypes_test_bytes((value=[collisionrow],); file=outputfile)
+            nothing
+        catch exception
+            exception
+        end
+        @test err isa ArgumentError
+        @test occursin("duplicate physical Map key storage", sprint(showerror, err))
+    end
+
+    collisionkeyfield = ARROWTYPES_TEST_AC.Field(
+        "key",
+        ARROWTYPES_TEST_AC.IntType(64, true);
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_COLLIDING_MAP_KEY_NAME),
+    )
+    collisionentries = ARROWTYPES_TEST_AC.Field(
+        "entries",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        children=[collisionkeyfield, reversevaluefield],
+    )
+    collisionentriesdata = ARROWTYPES_TEST_AC.ArrayData(
+        collisionentries.type,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[reversekeydata, reversevaluedata],
+        nullcount=0,
+    )
+    collisionmaptype = ARROWTYPES_TEST_AC.MapType(false)
+    collisionmapfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        collisionmaptype;
+        nullable=false,
+        children=[collisionentries],
+    )
+    collisionmapdata = ARROWTYPES_TEST_AC.ArrayData(
+        collisionmaptype,
+        1,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 2])];
+        children=[collisionentriesdata],
+        nullcount=0,
+    )
+    collisionmapschema = ARROWTYPES_TEST_AC.Schema([collisionmapfield])
+    collisionmapbatch =
+        ARROWTYPES_TEST_AC.RecordBatch(collisionmapschema, [collisionmapdata], 1)
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(collisionmapschema, [collisionmapbatch]) :
+            Arrow.writestream(collisionmapschema, [collisionmapbatch])
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            err = try
+                arrowtypes_test_bytes(source; file=outputfile)
+                nothing
+            catch exception
+                exception
+            end
+            @test err isa ArgumentError
+            @test occursin("duplicate physical Map key storage", sprint(showerror, err))
+        end
+    end
+end
+
+@testset "empty registered columns keep schema evidence" begin
+    t = ARROWTYPES_TEST_AC.IntType(32, true)
+    emptyfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        t;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_WRONG_STORAGE_NAME),
+    )
+    emptydata = ARROWTYPES_TEST_AC.ArrayData(
+        t,
+        0,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[])];
+        nullcount=0,
+    )
+    arrowtypes_test_retained_rewrites(emptyfield, emptydata, ArrowTypesTestWrongStorage[])
+
+    nullablefield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        t;
+        nullable=true,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_WRONG_STORAGE_NAME),
+    )
+    nullabledata = ARROWTYPES_TEST_AC.ArrayData(
+        t,
+        1,
+        [
+            ARROWTYPES_TEST_AC._bitmapbuffer(Bool[false]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0]),
+        ];
+        nullcount=1,
+    )
+    # A value is refused; a column of only missing has no value to refuse.
+    arrowtypes_test_retained_replacement_error(
+        nullablefield,
+        nullabledata,
+        Union{Missing,ArrowTypesTestWrongStorage}[ArrowTypesTestWrongStorage("x")],
+        "replaced with incompatible data",
+    )
+    logicalmissing = Union{Missing,ArrowTypesTestWrongStorage}[missing]
+
+    schema = ARROWTYPES_TEST_AC.Schema([nullablefield])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [nullabledata], 1)
+    for inputfile in (false, true),
+        sourcekind in (:table, :stream),
+        outputfile in (false, true),
+        replacement in (Missing[missing], logicalmissing)
+
+        inputbytes =
+            inputfile ? Arrow.writefile(schema, [batch]) :
+            Arrow.writestream(schema, [batch])
+        source = if sourcekind === :table
+            table = Arrow.Table(inputbytes)
+            getfield(table, :columns)[1] = replacement
+            table
+        else
+            parts = collect(Arrow.Stream(inputbytes))
+            getfield(only(parts), :columns)[1] = replacement
+            ArrowTypesTestRetainedPartitions(schema, Tuple(parts))
+        end
+        outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+        @test isequal(Arrow.Table(outputbytes).value, Missing[missing])
+        outputfield, _ = arrowtypes_test_core_parts(outputbytes)
+        @test arrowtypes_test_field_contract_equal(outputfield, nullablefield)
+    end
+end
+
+@testset "abstract registered declarations distinguish schema evidence" begin
+    t = ARROWTYPES_TEST_AC.IntType(32, true)
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        t,
+        0,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[])];
+        nullcount=0,
+    )
+
+    explicitfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        t;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(
+            ARROWTYPES_TEST_ABSTRACT_STRING_STORAGE_NAME,
+        ),
+    )
+    arrowtypes_test_retained_rewrites(
+        explicitfield,
+        data,
+        ArrowTypesTestAbstractStringStorage[],
+    )
+
+    identityfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        t;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(
+            ARROWTYPES_TEST_ABSTRACT_IDENTITY_STORAGE_NAME,
+        ),
+    )
+    arrowtypes_test_retained_rewrites(
+        identityfield,
+        data,
+        ArrowTypesTestAbstractIdentityStorage[],
+    )
+end
+
+@testset "malformed JuliaType results fail with field context" begin
+    t = ARROWTYPES_TEST_AC.IntType(32, true)
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        t;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(
+            ARROWTYPES_TEST_MALFORMED_JULIATYPE_NAME,
+        ),
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        t,
+        1,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[1])];
+        nullcount=0,
+    )
+    schema = ARROWTYPES_TEST_AC.Schema([field])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 1)
+    checkerror = function (err)
+        @test err isa ArgumentError
+        message = sprint(showerror, err)
+        @test occursin("ArrowTypes.JuliaType", message)
+        @test occursin("MalformedJuliaType", message)
+        @test occursin("field value", message)
+    end
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(schema, [batch]) :
+            Arrow.writestream(schema, [batch])
+        err = try
+            Arrow.Table(inputbytes)
+            nothing
+        catch e
+            e
+        end
+        checkerror(err)
+    end
+
+    source = Arrow._table(
+        Symbol[:value],
+        AbstractVector[Int32[1]],
+        schema,
+        ARROWTYPES_TEST_AC.OwnerRegion[],
+        1,
+    )
+    for outputfile in (false, true)
+        err = try
+            arrowtypes_test_bytes(source; file=outputfile)
+            nothing
+        catch e
+            e
+        end
+        checkerror(err)
+    end
+end
+
+@testset "invalid toarrow results fail with column context" begin
+    checkerror = function (err, column)
+        @test err isa ArgumentError
+        message = sprint(showerror, err)
+        @test occursin("ArrowTypes.toarrow", message)
+        @test occursin("ArrowTypesTestBadLower", message)
+        @test occursin(column, message)
+    end
+    for outputfile in (false, true)
+        err = try
+            arrowtypes_test_bytes(
+                (broken=ArrowTypesTestBadLower[ArrowTypesTestBadLower(Int8(1))],);
+                file=outputfile,
+            )
+            nothing
+        catch e
+            e
+        end
+        checkerror(err, "broken")
+    end
+
+    intfield, intdata = ARROWTYPES_TEST_AC.fromjulia("integer", Int8[1])
+    textfield, textdata = ARROWTYPES_TEST_AC.fromjulia("text", String[])
+    uniontype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[42, 17])
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        uniontype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_BAD_LOWER_NAME),
+        children=[intfield, textfield],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        uniontype,
+        1,
+        [
+            ARROWTYPES_TEST_AC._databuffer(Int8[42]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0]),
+        ];
+        children=[intdata, textdata],
+        nullcount=0,
+    )
+    arrowtypes_test_retained_replacement_error(
+        field,
+        data,
+        ArrowTypesTestBadLower[ArrowTypesTestBadLower(Int8(1))],
+        ("ArrowTypes.toarrow", "ArrowTypesTestBadLower", "value"),
+    )
+
+    badunionfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        uniontype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_BAD_UNION_LOWER_NAME),
+        children=[intfield, textfield],
+    )
+    arrowtypes_test_retained_replacement_error(
+        badunionfield,
+        data,
+        ArrowTypesTestBadUnionLower[ArrowTypesTestBadUnionLower(Int8(1))],
+        ("ArrowTypes.toarrow", "ArrowTypesTestBadUnionLower", "value"),
+    )
+
+    afield, adata = ARROWTYPES_TEST_AC.fromjulia("a", Int8[1])
+    bfield, bdata = ARROWTYPES_TEST_AC.fromjulia("b", Int8[2])
+    structtype = ARROWTYPES_TEST_AC.StructType()
+    structfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        structtype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_BAD_STRUCT_LOWER_NAME),
+        children=[afield, bfield],
+    )
+    structdata = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        1,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[adata, bdata],
+        nullcount=0,
+    )
+    arrowtypes_test_retained_replacement_error(
+        structfield,
+        structdata,
+        ArrowTypesTestBadStructLower[ArrowTypesTestBadStructLower(Int8(7))],
+        ("ArrowTypes.toarrow", "ArrowTypesTestBadStructLower", "value"),
+    )
+end
+
+@testset "registered sparse Union preserves routing" begin
+    intfield, intdata = ARROWTYPES_TEST_AC.fromjulia("integer", Int64[7, 0, 9])
+    stringfield, stringdata =
+        ARROWTYPES_TEST_AC.fromjulia("text", ["hidden", "two", "hidden"])
+    uniontype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.SparseMode, Int8[42, 17])
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        uniontype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_LOGICAL_UNION_NAME),
+        children=[intfield, stringfield],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        uniontype,
+        3,
+        [ARROWTYPES_TEST_AC._databuffer(Int8[42, 17, 42])];
+        children=[intdata, stringdata],
+        nullcount=0,
+    )
+    expected = ArrowTypesTestLogicalUnion[
+        ArrowTypesTestLogicalUnion(Int64(7)),
+        ArrowTypesTestLogicalUnion("two"),
+        ArrowTypesTestLogicalUnion(Int64(9)),
+    ]
+    arrowtypes_test_retained_rewrites(field, data, expected)
+end
+
+@testset "nested retained Union preserves noncanonical routing" begin
+    stringfield, stringdata = ARROWTYPES_TEST_AC.fromjulia("text", ["two"])
+    intfield, intdata = ARROWTYPES_TEST_AC.fromjulia("integer", Int64[1])
+    uniontype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[9, 5])
+    unionfield = ARROWTYPES_TEST_AC.Field(
+        "child",
+        uniontype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_LOGICAL_UNION_NAME),
+        children=[stringfield, intfield],
+    )
+    uniondata = ARROWTYPES_TEST_AC.ArrayData(
+        uniontype,
+        2,
+        [
+            ARROWTYPES_TEST_AC._databuffer(Int8[5, 9]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0, 0]),
+        ];
+        children=[stringdata, intdata],
+        nullcount=0,
+    )
+    structtype = ARROWTYPES_TEST_AC.StructType()
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        structtype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(
+            ARROWTYPES_TEST_NESTED_LOGICAL_UNION_NAME,
+        ),
+        children=[unionfield],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[uniondata],
+        nullcount=0,
+    )
+    expected = ArrowTypesTestNestedLogicalUnion[
+        ArrowTypesTestNestedLogicalUnion(ArrowTypesTestLogicalUnion(Int64(1))),
+        ArrowTypesTestNestedLogicalUnion(ArrowTypesTestLogicalUnion("two")),
+    ]
+    arrowtypes_test_retained_rewrites(field, data, expected)
+end
+
+@testset "transparent REE<Date32> preserves its registered alias" begin
+    firstday = Date(2024, 1, 1)
+    secondday = Date(2024, 1, 2)
+    runfield, rundata = ARROWTYPES_TEST_AC.fromjulia("run_ends", Int32[2, 3])
+    valuetype = ARROWTYPES_TEST_AC.DateType(ARROWTYPES_TEST_AC.DAY)
+    valuefield = ARROWTYPES_TEST_AC.Field("values", valuetype; nullable=false)
+    epoch = Date(1970, 1, 1)
+    values = Int32[Dates.value(firstday - epoch), Dates.value(secondday - epoch)]
+    valuedata = ARROWTYPES_TEST_AC.ArrayData(
+        valuetype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(values)];
+        nullcount=0,
+    )
+    reetype = ARROWTYPES_TEST_AC.RunEndEncodedType()
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        reetype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_DAY_NAME),
+        children=[runfield, valuefield],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        reetype,
+        3,
+        ARROWTYPES_TEST_AC.BufferSlice[];
+        children=[rundata, valuedata],
+        nullcount=0,
+    )
+    expected = ArrowTypesTestDay[
+        ArrowTypesTestDay(firstday),
+        ArrowTypesTestDay(firstday),
+        ArrowTypesTestDay(secondday),
+    ]
+    arrowtypes_test_retained_rewrites(field, data, expected)
+end
+
+@testset "nested abstract Union rewrites hidden and visible partitions" begin
+    Parent = ArrowTypesTestNestedUnionParent
+    Concrete = ArrowTypesTestConcreteUnionWrite
+    firstpart = Union{Missing,Parent}[missing, missing]
+    secondpart =
+        Parent[Parent(Concrete(Int64(1))), Parent(missing), Parent(Concrete("two"))]
+    expected = Union{Missing,Parent}[firstpart; secondpart]
+    for inputfile in (false, true)
+        parts = Tables.partitioner(((value=firstpart,), (value=secondpart,)))
+        inputbytes = arrowtypes_test_bytes(parts; file=inputfile)
+        inputfield, inputbatches = arrowtypes_test_core_parts(inputbytes)
+        @test length(inputbatches) == 2
+        @test isequal(Arrow.Table(inputbytes).value, expected)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            ARROWTYPES_TEST_NESTED_UNION_PARENT_CALLS[] = 0
+            ARROWTYPES_TEST_CONCRETE_UNION_WRITE_CALLS[] = 0
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            outputtable = Arrow.Table(outputbytes)
+            @test isequal(outputtable.value, expected)
+            @test ARROWTYPES_TEST_NESTED_UNION_PARENT_CALLS[] == 3
+            @test ARROWTYPES_TEST_CONCRETE_UNION_WRITE_CALLS[] == 2
+            outputfield, outputbatches = arrowtypes_test_core_parts(outputbytes)
+            @test arrowtypes_test_field_contract_equal(inputfield, outputfield)
+            @test length(outputbatches) == (sourcekind === :table ? 1 : 2)
+        end
+    end
+end
+
+@testset "logical Null Union distinguishes storage from outer missing" begin
+    values = ArrowTypesTestLogicalNullUnion[
+        ArrowTypesTestLogicalNullUnion(nothing),
+        ArrowTypesTestLogicalNullUnion("value"),
+    ]
+    nullable = Union{Missing,ArrowTypesTestLogicalNullUnion}[
+        missing,
+        ArrowTypesTestLogicalNullUnion(nothing),
+        ArrowTypesTestLogicalNullUnion("value"),
+    ]
+    for input in (values, nullable), inputfile in (false, true)
+        bytes = arrowtypes_test_bytes((value=input,); file=inputfile)
+        @test isequal(Arrow.Table(bytes).value, input)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+            @test isequal(
+                Arrow.Table(arrowtypes_test_bytes(source; file=outputfile)).value,
+                input,
+            )
+        end
+    end
+
+    # Missing as a member of a storage Union could not be told from a null slot.
+    storage_missing = ArrowTypesTestAmbiguousMissingUnion[
+        ArrowTypesTestAmbiguousMissingUnion(missing),
+        ArrowTypesTestAmbiguousMissingUnion("stored"),
+    ]
+    ambiguous = Union{Missing,ArrowTypesTestAmbiguousMissingUnion}[
+        missing,
+        ArrowTypesTestAmbiguousMissingUnion(missing),
+    ]
+    for input in (storage_missing, Arrow.DictEncode(storage_missing), ambiguous),
+        file in (false, true)
+
+        err = try
+            arrowtypes_test_bytes((value=input,); file)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("ArrowTypesTestAmbiguousMissingUnion", sprint(showerror, err))
+        @test occursin("Missing as a Union member", sprint(showerror, err))
+    end
+
+    nulltype = ARROWTYPES_TEST_AC.NullType()
+    storagenullfield = ARROWTYPES_TEST_AC.Field("stored-missing", nulltype; nullable=true)
+    outernullfield = ARROWTYPES_TEST_AC.Field("outer-missing", nulltype; nullable=true)
+    nulldata = ARROWTYPES_TEST_AC.ArrayData(
+        nulltype,
+        1,
+        ARROWTYPES_TEST_AC.BufferSlice[];
+        nullcount=1,
+    )
+    stringfield, stringdata = ARROWTYPES_TEST_AC.fromjulia("string", ["external"])
+    ambiguousunion =
+        ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[9, 5, 1])
+    ambiguousfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        ambiguousunion;
+        nullable=true,
+        metadata=[
+            "ARROW:extension:name" =>
+                String(ARROWTYPES_TEST_AMBIGUOUS_MISSING_UNION_NAME),
+            "ARROW:extension:metadata" => "",
+        ],
+        children=[storagenullfield, stringfield, outernullfield],
+    )
+    ambiguousdata = ARROWTYPES_TEST_AC.ArrayData(
+        ambiguousunion,
+        3,
+        [
+            ARROWTYPES_TEST_AC._databuffer(Int8[9, 5, 1]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0, 0, 0]),
+        ];
+        children=[nulldata, stringdata, nulldata],
+        nullcount=0,
+    )
+    ambiguousschema = ARROWTYPES_TEST_AC.Schema([ambiguousfield])
+    ambiguousbatch = ARROWTYPES_TEST_AC.RecordBatch(ambiguousschema, [ambiguousdata], 3)
+    for file in (false, true)
+        bytes =
+            file ? Arrow.writefile(ambiguousschema, [ambiguousbatch]) :
+            Arrow.writestream(ambiguousschema, [ambiguousbatch])
+        err = try
+            Arrow.Table(bytes)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("indistinguishable outer missing", sprint(showerror, err))
+    end
+end
+
+@testset "Arrow 2 dense Union schema routes identical storage children" begin
+    uniontype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[0, 1])
+    idfield = arrowtypes_test_marked_id_field("")
+    alternatefield = ARROWTYPES_TEST_AC.Field(
+        "",
+        ARROWTYPES_TEST_AC.IntType(64, true);
+        nullable=false,
+        metadata=[
+            "ARROW:extension:name" => String(ARROWTYPES_TEST_ALTERNATE_ID_NAME),
+            "ARROW:extension:metadata" => "",
+        ],
+    )
+    _, iddata = ARROWTYPES_TEST_AC.fromjulia("", Int64[1, 3])
+    _, alternatedata = ARROWTYPES_TEST_AC.fromjulia("", Int64[2])
+    # Arrow 2 wrote empty child names and marked the Union nullable. Value
+    # routing is still defined by the type id, not by either choice.
+    field = ARROWTYPES_TEST_AC.Field(
+        "value",
+        uniontype;
+        nullable=true,
+        children=[idfield, alternatefield],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        uniontype,
+        3,
+        [
+            ARROWTYPES_TEST_AC._databuffer(Int8[0, 1, 0]),
+            ARROWTYPES_TEST_AC._databuffer(Int32[0, 0, 1]),
+        ];
+        children=[iddata, alternatedata],
+        nullcount=0,
+    )
+    schema = ARROWTYPES_TEST_AC.Schema([field])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 3)
+    expected = Union{ArrowTypesTestID,ArrowTypesTestAlternateID}[
+        ArrowTypesTestID(1),
+        ArrowTypesTestAlternateID(2),
+        ArrowTypesTestID(3),
+    ]
+
+    for file in (false, true)
+        bytes = file ? Arrow.writefile(schema, [batch]) : Arrow.writestream(schema, [batch])
+        table = Arrow.Table(bytes)
+        @test table.value == expected
+        @test typeof.(table.value) == typeof.(expected)
+        readfield = getfield(table, :schema).fields[1]
+        @test getfield.(readfield.children, :name) == ["", ""]
+        @test readfield.type.typeids == Int8[0, 1]
+        @test readfield.nullable
+        @test Set(arrowtypes_test_extension_name.(readfield.children)) == Set([
+            String(ARROWTYPES_TEST_ID_NAME),
+            String(ARROWTYPES_TEST_ALTERNATE_ID_NAME),
+        ])
+    end
+
+    # A facade scan must retain the dense-Union child id until ArrowTypes
+    # lifting consumes it. Both children use Int64 storage, so materializing
+    # an ordinary storage column here would erase their logical identity.
+    filebytes = Arrow.writefile(schema, [batch])
+    streambytes = Arrow.writestream(schema, [batch])
+    sources = (
+        () -> copy(filebytes),
+        () ->
+            Arrow.SourceFile(ArrowTypesTestBytesSource(copy(filebytes)); tailbytes=32),
+        () -> ArrowTypesTestBytesSource(copy(streambytes)),
+    )
+    pushed = Tables.Scan(select=(:value => :routed,), offset=1, limit=2)
+    for makesource in sources
+        table = Arrow.Table(makesource(); scan=pushed)
+        wanted = expected[2:3]
+        @test collect(Tables.columnnames(table)) == [:routed]
+        @test table.routed == wanted
+        @test typeof.(table.routed) == typeof.(wanted)
+        outfield = only(getfield(table, :schema).fields)
+        @test outfield.name == "routed"
+        @test outfield.type.typeids == Int8[0, 1]
+        @test getfield.(outfield.children, :name) == ["", ""]
+    end
+
+    # A predicate over a logical child cannot lower to the shared Int64
+    # storage domain. It must execute after the same facade conversion.
+    publicfilter = Tables.Scan(
+        select=(:value,),
+        filter=Tables.colcmp(==, Tables.col(:value), ArrowTypesTestID(3)),
+    )
+    for makesource in sources
+        table = Arrow.Table(makesource(); scan=publicfilter)
+        @test table.value == [ArrowTypesTestID(3)]
+        @test typeof.(table.value) == [ArrowTypesTestID]
+    end
+end
+
+@testset "colmetadata cannot replace a generated extension label" begin
+    points = [ArrowTypesTestPoint{:protected}(Int32(1), Int32(2))]
+    metadata = Dict(
+        :point => [
+            "ARROW:extension:name" => "JuliaLang.ArrowTests.Wrong",
+            "ARROW:extension:metadata" => "wrong",
+            "application:key" => "kept",
+        ],
+    )
+    for file in (false, true)
+        table = arrowtypes_test_table((point=points,); file=file, colmetadata=metadata)
+        @test table.point == points
+        @test DataAPI.colmetadata(table, :point, "ARROW:extension:name") ==
+              String(ARROWTYPES_TEST_POINT_NAME)
+        @test DataAPI.colmetadata(table, :point, "ARROW:extension:metadata") == "protected"
+        @test DataAPI.colmetadata(table, :point, "application:key") == "kept"
+    end
+end
+
+@testset "nested custom values" begin
+    lists = [
+        ArrowTypesTestID[ArrowTypesTestID(1), ArrowTypesTestID(2)],
+        ArrowTypesTestID[],
+        ArrowTypesTestID[ArrowTypesTestID(3)],
+    ]
+    rows = [
+        (id=ArrowTypesTestID(1), label=ArrowTypesTestLabel("one")),
+        (id=ArrowTypesTestID(2), label=ArrowTypesTestLabel("two")),
+        (id=ArrowTypesTestID(3), label=ArrowTypesTestLabel("three")),
+    ]
+
+    for file in (false, true)
+        listtable = arrowtypes_test_table((list=lists,); file=file)
+        @test listtable.list == lists
+        @test all(x -> eltype(x) === ArrowTypesTestID, listtable.list)
+
+        # An unmarked Arrow Struct keeps the facade's ordered Pair-vector
+        # row representation. Its marked children still lift recursively.
+        rowtable = arrowtypes_test_table((row=rows,); file=file)
+        gotrows = arrowtypes_test_rowdict.(rowtable.row)
+        @test getindex.(gotrows, "id") == getproperty.(rows, :id)
+        @test getindex.(gotrows, "label") == getproperty.(rows, :label)
+        @test all(x -> x isa ArrowTypesTestID, getindex.(gotrows, "id"))
+        @test all(x -> x isa ArrowTypesTestLabel, getindex.(gotrows, "label"))
+    end
+end
+
+@testset "two-level nested custom values" begin
+    members = [
+        (id=ArrowTypesTestID(1), plain=Int32(10)),
+        (id=ArrowTypesTestID(2), plain=Int32(20)),
+        (id=ArrowTypesTestID(3), plain=Int32(30)),
+    ]
+    lists = [members[1:2], members[3:3]]
+    envelopes = ArrowTypesTestEnvelope.(members)
+    groups = [ArrowTypesTestGroup(members[1:2]), ArrowTypesTestGroup(members[3:3])]
+
+    for file in (false, true)
+        listtable = arrowtypes_test_table((list=lists,); file=file)
+        gotlists = [arrowtypes_test_rowdict.(row) for row in listtable.list]
+        wantlists = [arrowtypes_test_rowdict.(row) for row in lists]
+        @test gotlists == wantlists
+        @test eltype(listtable.list) === Vector{Vector{Pair{String,Any}}}
+        @test all(row -> eltype(row) === Vector{Pair{String,Any}}, listtable.list)
+        @test all(
+            member -> arrowtypes_test_rowdict(member)["id"] isa ArrowTypesTestID,
+            Iterators.flatten(listtable.list),
+        )
+
+        envelopetable = arrowtypes_test_table((envelope=envelopes,); file=file)
+        @test envelopetable.envelope == envelopes
+        @test eltype(envelopetable.envelope) === ArrowTypesTestEnvelope
+
+        grouptable = arrowtypes_test_table((group=groups,); file=file)
+        @test grouptable.group == groups
+        @test eltype(grouptable.group) === ArrowTypesTestGroup
+    end
+end
+
+@testset "nested temporal conversion follows the parent shape" begin
+    idfield = arrowtypes_test_marked_id_field("id")
+    _, iddata = ARROWTYPES_TEST_AC.fromjulia("id", Int64[1, 2])
+    daytype = ARROWTYPES_TEST_AC.DateType(ARROWTYPES_TEST_AC.DAY)
+    dayfield = ARROWTYPES_TEST_AC.Field("day", daytype; nullable=false)
+    daydata = ARROWTYPES_TEST_AC.ArrayData(
+        daytype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 1])];
+        nullcount=0,
+    )
+    structtype = ARROWTYPES_TEST_AC.StructType()
+    plainfield = ARROWTYPES_TEST_AC.Field(
+        "plain",
+        structtype;
+        nullable=false,
+        children=[idfield, dayfield],
+    )
+    markedidfield = arrowtypes_test_marked_id_field("id")
+    _, markediddata = ARROWTYPES_TEST_AC.fromjulia("id", Int64[1, 2])
+    markeddayfield = ARROWTYPES_TEST_AC.Field("day", daytype; nullable=false)
+    markeddaydata = ARROWTYPES_TEST_AC.ArrayData(
+        daytype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 1])];
+        nullcount=0,
+    )
+    markedfield = ARROWTYPES_TEST_AC.Field(
+        "marked",
+        structtype;
+        nullable=false,
+        metadata=[
+            "ARROW:extension:name" => String(ARROWTYPES_TEST_STAMPED_ID_NAME),
+            "ARROW:extension:metadata" => "",
+        ],
+        children=[markedidfield, markeddayfield],
+    )
+    structdata = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[iddata, daydata],
+        nullcount=0,
+    )
+    markedstructdata = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[markediddata, markeddaydata],
+        nullcount=0,
+    )
+    schema = ARROWTYPES_TEST_AC.Schema([plainfield, markedfield])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [structdata, markedstructdata], 2)
+    markedvalues = [
+        ArrowTypesTestStampedID(ArrowTypesTestID(1), Date(1970, 1, 1)),
+        ArrowTypesTestStampedID(ArrowTypesTestID(2), Date(1970, 1, 2)),
+    ]
+
+    for file in (false, true)
+        bytes = file ? Arrow.writefile(schema, [batch]) : Arrow.writestream(schema, [batch])
+        table = Arrow.Table(bytes)
+        plainrows = arrowtypes_test_rowdict.(table.plain)
+        @test getindex.(plainrows, "id") == ArrowTypesTestID.(Int64[1, 2])
+        # the unmarked temporal sibling converts to the public domain; the
+        # marked struct keeps the ArrowTypes contract for its fromarrow hook
+        @test getindex.(plainrows, "day") == [Date(1970, 1, 1), Date(1970, 1, 2)]
+        @test all(x -> x isa Date, getindex.(plainrows, "day"))
+        @test table.marked == markedvalues
+        @test eltype(table.marked) === ArrowTypesTestStampedID
+    end
+
+    rows = [(id=ArrowTypesTestID(1), day=Date(1970, 1, 1))]
+    for file in (false, true)
+        # a fresh NamedTuple with a registered child and a Date child writes
+        # and round-trips in the public domain
+        freshtable = Arrow.Table(arrowtypes_test_bytes((row=rows,); file=file))
+        freshrows = arrowtypes_test_rowdict.(freshtable.row)
+        @test getindex.(freshrows, "id") == [ArrowTypesTestID(1)]
+        @test getindex.(freshrows, "day") == [Date(1970, 1, 1)]
+    end
+end
+
+@testset "built-in ArrowTypes mappings" begin
+    symbols = [:alpha, :beta]
+    uuids = [
+        UUID("00112233-4455-6677-8899-aabbccddeeff"),
+        UUID("ffeeddcc-bbaa-9988-7766-554433221100"),
+    ]
+    versions = [v"1.2.3", v"2.0.0-rc1+build"]
+    sets = [Set([1, 2]), Set([3])]
+    nothings = Nothing[nothing, nothing]
+
+    for file in (false, true)
+        format = file ? "file" : "stream"
+        for (name, values, expected) in (
+            (:symbol, symbols, Symbol),
+            (:uuid, uuids, UUID),
+            (:version, versions, VersionNumber),
+            (:set, sets, Set),
+            (:nothing, nothings, Nothing),
+        )
+            @testset "$name ($format)" begin
+                table = arrowtypes_test_table(NamedTuple{(name,)}((values,)); file=file)
+                column = Tables.getcolumn(table, name)
+                @test column == values
+                if expected === Nothing
+                    @test eltype(column) === Nothing
+                else
+                    @test eltype(column) <: expected
+                end
+            end
+        end
+    end
+end
+
+@testset "Arrow.Stream and partitions" begin
+    parts = Tables.partitioner((
+        (id=Union{Missing,ArrowTypesTestID}[ArrowTypesTestID(1), missing],),
+        (id=Union{Missing,ArrowTypesTestID}[ArrowTypesTestID(2), ArrowTypesTestID(3)],),
+    ))
+    bytes = arrowtypes_test_bytes(parts; file=false)
+    batches = collect(Arrow.Stream(bytes))
+    @test length(batches) == 2
+    @test isequal(
+        collect(batches[1].id),
+        Union{Missing,ArrowTypesTestID}[ArrowTypesTestID(1), missing],
+    )
+    @test collect(batches[2].id) == ArrowTypesTestID.(Int64[2, 3])
+    @test all(batch -> eltype(batch.id) === Union{Missing,ArrowTypesTestID}, batches)
+end
+
+@testset "all-missing then populated partitions" begin
+    T = Union{Missing,ArrowTypesTestID}
+    parts = Tables.partitioner(((id=T[missing, missing],), (id=T[ArrowTypesTestID(7)],)))
+    expected = T[missing, missing, ArrowTypesTestID(7)]
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes(parts; file=file)
+        table = Arrow.Table(bytes)
+        @test isequal(table.id, expected)
+        @test eltype(table.id) === T
+        @test DataAPI.colmetadata(table, :id, "ARROW:extension:name") ==
+              String(ARROWTYPES_TEST_ID_NAME)
+        if !file
+            batches = collect(Arrow.Stream(bytes))
+            @test length(batches) == 2
+            @test isequal(collect(batches[1].id), T[missing, missing])
+            @test collect(batches[2].id) == T[ArrowTypesTestID(7)]
+            @test all(batch -> eltype(batch.id) === T, batches)
+        end
+    end
+end
+
+@testset "partitioned DictEncode uses declared nullability" begin
+    T = Union{Missing,Int64}
+    parts = Tables.partitioner((
+        (value=Arrow.DictEncode(T[1, 2]),),
+        (value=Arrow.DictEncode(T[missing, 3]),),
+    ))
+    expected = T[1, 2, missing, 3]
+    for file in (false, true)
+        table = Arrow.Table(arrowtypes_test_bytes(parts; file=file))
+        @test isequal(table.value, expected)
+        field = getfield(table, :schema).fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test field.nullable
+    end
+end
+
+@testset "fresh DictEncode preserves declared Union value fields" begin
+    T = Union{Int64,String}
+    N = Union{Missing,Int64,String}
+    cases = (
+        ("integer branch", T[1, 2], (2, 0)),
+        ("string branch", T["one", "two"], (0, 2)),
+        ("both branches", T[1, "two"], (1, 1)),
+        ("nullable indices", N[missing, 1, "two"], (1, 1)),
+        ("all-null indices", N[missing, missing], (0, 0)),
+    )
+    for file in (false, true), (label, values, childlengths) in cases
+        @testset "$label ($(file ? "file" : "stream"))" begin
+            bytes = arrowtypes_test_bytes((value=Arrow.DictEncode(values),); file=file)
+            table = Arrow.Table(bytes)
+            @test isequal(table.value, values)
+            # Union rows read strings as the default string type.
+            readtype(x) = x isa String ? Arrow.DataStrings.DataString : typeof(x)
+            @test typeof.(table.value) == readtype.(values)
+
+            field, batches = arrowtypes_test_core_parts(bytes)
+            @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+            @test field.nullable == (Missing <: eltype(values))
+            valuefield = ARROWTYPES_TEST_AC.dictvaluefield(field, field.type)
+            @test valuefield.type isa ARROWTYPES_TEST_AC.UnionType
+            @test length(valuefield.children) == 2
+            @test all(
+                child -> !(child.type isa ARROWTYPES_TEST_AC.NullType),
+                valuefield.children,
+            )
+            intchild = findfirst(
+                child -> child.type isa ARROWTYPES_TEST_AC.IntType,
+                valuefield.children,
+            )
+            stringchild = findfirst(
+                child -> child.type isa ARROWTYPES_TEST_AC.Utf8Type,
+                valuefield.children,
+            )
+            @test intchild !== nothing
+            @test stringchild !== nothing
+            pool = only(batches).columns[1].dictionary
+            @test pool !== nothing
+            @test length(pool.children[intchild]) == childlengths[1]
+            @test length(pool.children[stringchild]) == childlengths[2]
+        end
+    end
+
+    expected = T[1, "two", 3, "four"]
+    parts = Tables.partitioner((
+        (value=Arrow.DictEncode(T[1, "two"]),),
+        (value=Arrow.DictEncode(T[3, "four"]),),
+    ))
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes(parts; file=file)
+        table = Arrow.Table(bytes)
+        @test table.value == expected
+        @test typeof.(table.value) ==
+              [x isa String ? Arrow.DataStrings.DataString : typeof(x) for x in expected]
+        field, batches = arrowtypes_test_core_parts(bytes)
+        @test (field.type::ARROWTYPES_TEST_AC.DictionaryType).valuetype isa
+              ARROWTYPES_TEST_AC.UnionType
+        @test length(batches) == 2
+        # The second partition's categories extend the first's pool (a file
+        # reader applies every dictionary batch before the record batches).
+        @test length(batches[1].columns[1].dictionary) == (file ? 4 : 2)
+        @test length(batches[2].columns[1].dictionary) == 4
+    end
+
+    # The schema comes from the first partition, which has no value to type.
+    later = Tables.partitioner((
+        (value=Arrow.DictEncode(Missing[missing]),),
+        (value=Arrow.DictEncode(N[1, "two", missing]),),
+    ))
+    for file in (false, true)
+        @test_throws ArgumentError arrowtypes_test_bytes(later; file=file)
+    end
+end
+
+@testset "DictEncode Union category identity includes runtime type" begin
+    values = Union{Int64,Float64}[1, 1.0]
+    snapshots = Any[Int64[1], Float64[1.0]]
+    typed = Arrow._mergecategorypools(snapshots; widen=true)
+    @test typed == Real[1, 1.0]
+    @test typeof.(typed) == typeof.(values)
+    @test Arrow._mergecategorypools([[1, 1], [1, 2]]) == [1, 1, 2]
+
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes((value=Arrow.DictEncode(values),); file=file)
+        table = Arrow.Table(bytes)
+        @test table.value == values
+        @test typeof.(table.value) == typeof.(values)
+        field, batches = arrowtypes_test_core_parts(bytes)
+        @test (field.type::ARROWTYPES_TEST_AC.DictionaryType).valuetype isa
+              ARROWTYPES_TEST_AC.UnionType
+        @test length(only(batches).columns[1].dictionary) == 2
+    end
+end
+
+@testset "DictEncode preserves registered same-storage Union branches" begin
+    T = Union{ArrowTypesTestID,ArrowTypesTestAlternateID}
+    cases = (
+        ("ID branch", T[ArrowTypesTestID(1)], (1, 0)),
+        ("alternate branch", T[ArrowTypesTestAlternateID(1)], (0, 1)),
+        ("both branches", T[ArrowTypesTestID(1), ArrowTypesTestAlternateID(1)], (1, 1)),
+    )
+    for file in (false, true), (label, values, childlengths) in cases
+        @testset "$label ($(file ? "file" : "stream"))" begin
+            bytes = arrowtypes_test_bytes((value=Arrow.DictEncode(values),); file=file)
+            table = Arrow.Table(bytes)
+            @test table.value == values
+            @test typeof.(table.value) == typeof.(values)
+            field, batches = arrowtypes_test_core_parts(bytes)
+            valuefield = ARROWTYPES_TEST_AC.dictvaluefield(field, field.type)
+            @test valuefield.type isa ARROWTYPES_TEST_AC.UnionType
+            names = arrowtypes_test_extension_name.(valuefield.children)
+            idchild = findfirst(==(String(ARROWTYPES_TEST_ID_NAME)), names)
+            alternatechild = findfirst(==(String(ARROWTYPES_TEST_ALTERNATE_ID_NAME)), names)
+            @test idchild !== nothing
+            @test alternatechild !== nothing
+            pool = only(batches).columns[1].dictionary
+            @test length(pool.children[idchild]) == childlengths[1]
+            @test length(pool.children[alternatechild]) == childlengths[2]
+        end
+    end
+
+    parts = Tables.partitioner((
+        (value=Arrow.DictEncode(T[ArrowTypesTestID(1)]),),
+        (value=Arrow.DictEncode(T[ArrowTypesTestAlternateID(1)]),),
+    ))
+    expected = T[ArrowTypesTestID(1), ArrowTypesTestAlternateID(1)]
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes(parts; file=file)
+        table = Arrow.Table(bytes)
+        @test table.value == expected
+        @test typeof.(table.value) == typeof.(expected)
+        field, batches = arrowtypes_test_core_parts(bytes)
+        @test (field.type::ARROWTYPES_TEST_AC.DictionaryType).valuetype isa
+              ARROWTYPES_TEST_AC.UnionType
+        # The second partition's category extends the first's pool.
+        @test length(batches[1].columns[1].dictionary) == (file ? 2 : 1)
+        @test length(batches[2].columns[1].dictionary) == 2
+    end
+end
+
+@testset "fresh DictEncode uses the ordinary recursive value builder" begin
+    rows = [(id=Int32(1), label="one"), (id=Int32(2), label="two")]
+    maps = [Dict("one" => Int32(1)), Dict("two" => Int32(2))]
+    tuples = [(Int16(1), Int16(2)), (Int16(3), Int16(4))]
+    # each temporal input with the eltype its column reads back as (a
+    # written DateTime column reads back as Timestamp{Millisecond})
+    temporals = (
+        (Date[Date(2024, 1, 1), Date(2024, 2, 29)], Date),
+        (
+            DateTime[DateTime(2024, 1, 1, 1, 2, 3), DateTime(2024, 2, 29, 4, 5, 6)],
+            Durations.Timestamp{Millisecond},
+        ),
+        (Time[Time(1, 2, 3), Time(4, 5, 6)], Time),
+        (Millisecond[Millisecond(7), Millisecond(11)], Millisecond),
+    )
+    ids = ArrowTypesTestID.(Int64[1, 2])
+    writeonly = ArrowTypesTestWriteOnly.(Int32[3, 4])
+    namedwriteonly = ArrowTypesTestNamedWriteOnly.(Int32[5, 6])
+
+    for file in (false, true)
+        narrowed = Arrow.Table(
+            arrowtypes_test_bytes((value=Arrow.DictEncode(Any[1, 2]),); file=file),
+        )
+        @test narrowed.value == Int64[1, 2]
+
+        structtable =
+            Arrow.Table(arrowtypes_test_bytes((value=Arrow.DictEncode(rows),); file=file))
+        @test arrowtypes_test_rowdict.(structtable.value) == arrowtypes_test_rowdict.(rows)
+
+        maptable =
+            Arrow.Table(arrowtypes_test_bytes((value=Arrow.DictEncode(maps),); file=file))
+        @test Dict.(maptable.value) == maps
+
+        tupletable =
+            Arrow.Table(arrowtypes_test_bytes((value=Arrow.DictEncode(tuples),); file=file))
+        @test collect.(tupletable.value) == collect.(tuples)
+        @test all(row -> all(x -> x isa Int16, row), tupletable.value)
+
+        for (temporal, readeltype) in temporals
+            temporaltable = Arrow.Table(
+                arrowtypes_test_bytes((value=Arrow.DictEncode(temporal),); file=file),
+            )
+            @test temporaltable.value == temporal
+            @test eltype(temporaltable.value) === readeltype
+        end
+
+        idtable =
+            Arrow.Table(arrowtypes_test_bytes((value=Arrow.DictEncode(ids),); file=file))
+        @test idtable.value == ids
+        @test eltype(idtable.value) === ArrowTypesTestID
+
+        writeonlytable = Arrow.Table(
+            arrowtypes_test_bytes((value=Arrow.DictEncode(writeonly),); file=file),
+        )
+        @test writeonlytable.value == Int32[3, 4]
+        @test eltype(writeonlytable.value) === Int32
+
+        namedbytes =
+            arrowtypes_test_bytes((value=Arrow.DictEncode(namedwriteonly),); file=file)
+        field, _ = arrowtypes_test_core_parts(namedbytes)
+        @test arrowtypes_test_extension_name(field) ==
+              String(ARROWTYPES_TEST_NAMED_WRITE_ONLY)
+        empty!(Arrow._WARNED_EXTENSIONS)  # warnings are once per process
+        namedtable =
+            @test_logs (:warn, r"unsupported .*extension.*NamedWriteOnly") Arrow.Table(
+                namedbytes,
+            )
+        @test DataAPI.colmetadata(namedtable, :value, "ARROW:extension:metadata") ==
+              "write-only"
+        @test namedtable.value == Int32[5, 6]
+        @test eltype(namedtable.value) === Int32
+    end
+end
+
+@testset "fresh DictEncode uses writer evidence once per category" begin
+    values = ArrowTypesTestConcreteWriteID.(Int32[1, 2, 1])
+    for file in (false, true)
+        ARROWTYPES_TEST_CONCRETE_WRITE_CALLS[] = 0
+        plainbytes = arrowtypes_test_bytes((value=values,); file=file)
+        @test ARROWTYPES_TEST_CONCRETE_WRITE_CALLS[] == length(values)
+        plaintable = Arrow.Table(plainbytes)
+        @test plaintable.value == values
+        @test eltype(plaintable.value) === ArrowTypesTestAbstractReadID
+
+        ARROWTYPES_TEST_CONCRETE_WRITE_CALLS[] = 0
+        bytes = arrowtypes_test_bytes((value=Arrow.DictEncode(values),); file=file)
+        @test ARROWTYPES_TEST_CONCRETE_WRITE_CALLS[] == 2
+        table = Arrow.Table(bytes)
+        @test table.value == values
+        @test eltype(table.value) === ArrowTypesTestAbstractReadID
+        @test DataAPI.colmetadata(table, :value, "ARROW:extension:name") ==
+              String(ARROWTYPES_TEST_ABSTRACT_READ_ID)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+            rewritten = Arrow.Table(arrowtypes_test_bytes(source; file=outputfile))
+            @test rewritten.value == values
+            @test eltype(rewritten.value) === ArrowTypesTestAbstractReadID
+        end
+    end
+
+    Wide = @NamedTuple{a::Union{Missing,Int64}}
+    Narrow = @NamedTuple{a::Int64}
+    parts = Tables.partitioner((
+        (value=Arrow.DictEncode(Wide[(a=missing,), (a=1,)]),),
+        (value=Arrow.DictEncode(Narrow[(a=2,)]),),
+    ))
+    for file in (false, true)
+        table = Arrow.Table(arrowtypes_test_bytes(parts; file=file))
+        @test isequal(
+            arrowtypes_test_rowdict.(table.value),
+            [Dict("a" => missing), Dict("a" => 1), Dict("a" => 2)],
+        )
+        field = getfield(table, :schema).fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test only(field.children).nullable
+    end
+
+    mixedparts = Tables.partitioner((
+        (
+            value=Arrow.DictEncode(
+                ArrowTypesTestWriteOnly[
+                    ArrowTypesTestWriteOnly(1),
+                    ArrowTypesTestWriteOnly(2),
+                ],
+            ),
+        ),
+        (
+            value=Arrow.DictEncode(
+                ArrowTypesTestAlternateWriteOnly[
+                    ArrowTypesTestAlternateWriteOnly(3),
+                    ArrowTypesTestAlternateWriteOnly(4),
+                ],
+            ),
+        ),
+    ))
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes(mixedparts; file=file)
+        table = Arrow.Table(bytes)
+        @test table.value == Int32[1, 2, 3, 4]
+        # Several partitions declare every field nullable.
+        @test eltype(table.value) === Union{Missing,Int32}
+        field, batches = arrowtypes_test_core_parts(bytes)
+        @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test field.type.valuetype isa ARROWTYPES_TEST_AC.IntType
+        @test length(batches) == 2
+        @test length.(getproperty.(first.(getproperty.(batches, :columns)), :dictionary)) ==
+              (file ? [4, 4] : [2, 4])
+    end
+
+    abstractparts = Tables.partitioner((
+        (
+            value=Arrow.DictEncode(
+                ArrowTypesTestAbstractWriteOnly[
+                    ArrowTypesTestAbstractWriteA(5),
+                    ArrowTypesTestAbstractWriteB(6),
+                ],
+            ),
+        ),
+        (
+            value=Arrow.DictEncode(
+                ArrowTypesTestAbstractWriteOnly[ArrowTypesTestAbstractWriteA(7),],
+            ),
+        ),
+    ))
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes(abstractparts; file=file)
+        table = Arrow.Table(bytes)
+        @test table.value == Int32[5, 6, 7]
+        @test eltype(table.value) === Union{Missing,Int32}
+        field, batches = arrowtypes_test_core_parts(bytes)
+        @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test field.type.valuetype isa ARROWTYPES_TEST_AC.IntType
+        @test length(batches) == 2
+        @test length.(getproperty.(first.(getproperty.(batches, :columns)), :dictionary)) ==
+              (file ? [3, 3] : [2, 3])
+    end
+
+    Mixed = ArrowTypesTestAbstractMixedWrite
+    mixedvalues =
+        Mixed[ArrowTypesTestAbstractMixedInt(8), ArrowTypesTestAbstractMixedString("nine")]
+    layouts = (
+        (
+            "one partition",
+            (value=Arrow.DictEncode(mixedvalues),),
+            Union{Int32,String}[Int32(8), "nine"],
+        ),
+        (
+            "split",
+            Tables.partitioner((
+                (value=Arrow.DictEncode(Mixed[ArrowTypesTestAbstractMixedInt(8)]),),
+                (value=Arrow.DictEncode(Mixed[ArrowTypesTestAbstractMixedString("nine")]),),
+            )),
+            Union{Int32,String}[Int32(8), "nine"],
+        ),
+        (
+            "reverse",
+            Tables.partitioner((
+                (value=Arrow.DictEncode(Mixed[ArrowTypesTestAbstractMixedString("nine")]),),
+                (value=Arrow.DictEncode(Mixed[ArrowTypesTestAbstractMixedInt(8)]),),
+            )),
+            Union{Int32,String}["nine", Int32(8)],
+        ),
+        (
+            "all-missing first",
+            Tables.partitioner((
+                (value=Arrow.DictEncode(Union{Missing,Mixed}[missing]),),
+                (value=Arrow.DictEncode(mixedvalues),),
+            )),
+            Union{Missing,Int32,String}[missing, Int32(8), "nine"],
+        ),
+        (
+            "mixed then homogeneous",
+            Tables.partitioner((
+                (value=Arrow.DictEncode(mixedvalues),),
+                (value=Arrow.DictEncode(Mixed[ArrowTypesTestAbstractMixedInt(10)]),),
+            )),
+            Union{Int32,String}[Int32(8), "nine", Int32(10)],
+        ),
+    )
+    for file in (false, true)
+        controlbytes = arrowtypes_test_bytes(layouts[1][2]; file)
+        controlfield, _ = arrowtypes_test_core_parts(controlbytes)
+        controlvaluefield =
+            ARROWTYPES_TEST_AC.dictvaluefield(controlfield, controlfield.type)
+        for (label, layout, expected) in layouts
+            @testset "$label ($(file ? "file" : "stream"))" begin
+                if label != "one partition"
+                    # Streamed partitions take the value type from the first;
+                    # a later partition must plan the same one (here the
+                    # union of both branches), which these do not.
+                    @test_throws ArgumentError arrowtypes_test_bytes(layout; file)
+                else
+                    bytes = arrowtypes_test_bytes(layout; file)
+                    table = Arrow.Table(bytes)
+                    @test isequal(table.value, expected)
+                    field, batches = arrowtypes_test_core_parts(bytes)
+                    valuefield = ARROWTYPES_TEST_AC.dictvaluefield(field, field.type)
+                    @test arrowtypes_test_field_contract_equal(
+                        controlvaluefield,
+                        valuefield,
+                    )
+                    @test length(last(batches).columns[1].dictionary) ==
+                          length(unique(expected))
+                end
+            end
+        end
+    end
+
+    indistinguishable = Union{ArrowTypesTestWriteOnly,ArrowTypesTestAlternateWriteOnly}[
+        ArrowTypesTestWriteOnly(11),
+        ArrowTypesTestAlternateWriteOnly(12),
+    ]
+    mixedunionparts = Tables.partitioner((
+        (value=Arrow.DictEncode(Union{Int64,String}[Int64(13), "fourteen"]),),
+        (
+            value=Arrow.DictEncode(
+                ArrowTypesTestWriteOnlyLogicalUnion[
+                    ArrowTypesTestWriteOnlyLogicalUnion(Int64(15)),
+                    ArrowTypesTestWriteOnlyLogicalUnion("sixteen"),
+                ],
+            ),
+        ),
+    ))
+    for file in (false, true)
+        @test Arrow.Table(
+            arrowtypes_test_bytes((value=Arrow.DictEncode(indistinguishable),); file),
+        ).value == Int32[11, 12]
+        @test Arrow.Table(arrowtypes_test_bytes(mixedunionparts; file)).value ==
+              Union{Int64,String}[Int64(13), "fourteen", Int64(15), "sixteen"]
+    end
+end
+
+@testset "retained dictionary Union reconstruction refuses lost routing" begin
+    for T in (Union{Int64,String}, Union{Missing,Int64,String}),
+        inputfile in (false, true),
+        outputfile in (false, true),
+        sourcekind in (:table, :stream)
+
+        bytes =
+            arrowtypes_test_bytes((value=Arrow.DictEncode(T[1, "two"]),); file=inputfile)
+        source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+        err = try
+            arrowtypes_test_bytes(source; file=outputfile)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("retained UnionType", sprint(showerror, err))
+    end
+end
+
+@testset "partitioned DictEncode takes its value type from the first partition" begin
+    expected = Union{Missing,Int64}[missing, missing, 3, 4]
+    for file in (false, true)
+        # An all-missing first partition types the pool from its element type.
+        parts = Tables.partitioner((
+            (value=Arrow.DictEncode(Union{Missing,Int64}[missing, missing]),),
+            (value=Arrow.DictEncode(Int64[3, 4]),),
+        ))
+        bytes = arrowtypes_test_bytes(parts; file=file)
+        table = Arrow.Table(bytes)
+        @test isequal(table.value, expected)
+        @test eltype(table.value) === Union{Missing,Int64}
+        field = getfield(table, :schema).fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test field.type.valuetype isa ARROWTYPES_TEST_AC.IntType
+        @test field.nullable
+
+        batches = collect(Arrow.Stream(bytes))
+        @test length(batches) == 2
+        @test isequal(batches[1].value, Union{Missing,Int64}[missing, missing])
+        @test batches[2].value == Int64[3, 4]
+
+        # Without an element type, later partitions cannot supply it.
+        for first in (Missing[missing, missing], Missing[missing])
+            untyped = Tables.partitioner((
+                (value=Arrow.DictEncode(first),),
+                (value=Arrow.DictEncode(Int64[3, 4]),),
+            ))
+            err = try
+                arrowtypes_test_bytes(untyped; file=file)
+                nothing
+            catch e
+                e
+            end
+            @test err isa ArgumentError
+            @test occursin("cannot infer a dictionary value type", sprint(showerror, err))
+        end
+    end
+end
+
+@testset "partitioned DictEncode enforces public-domain value agreement" begin
+    Point = ArrowTypesTestPoint{:dictionary}
+    expected = Point[Point(Int32(1), Int32(2)), Point(Int32(3), Int32(4))]
+    concretefirst = Tables.partitioner((
+        (point=Arrow.DictEncode(Point[]),),
+        (point=Arrow.DictEncode(expected),),
+    ))
+    abstractfirst = Tables.partitioner((
+        (point=Arrow.DictEncode(ArrowTypesTestPoint[]),),
+        (point=Arrow.DictEncode(expected),),
+    ))
+    for file in (false, true)
+        table = Arrow.Table(arrowtypes_test_bytes(concretefirst; file=file))
+        @test table.point == expected
+        # Several partitions declare every field nullable.
+        @test eltype(table.point) === Union{Missing,Point}
+        @test DataAPI.colmetadata(table, :point, "ARROW:extension:metadata") == "dictionary"
+        # An empty first partition of the abstract type declares the label
+        # without metadata, which the later Point{:dictionary} values lack.
+        # (It writes no record batch, so no dictionary precedes the later
+        # partition's.)
+        err = try
+            arrowtypes_test_bytes(abstractfirst; file=file)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin(
+            "holds ArrowTypesTestPoint{:dictionary} values, but its retained dictionary " *
+            "materializes as ArrowTypesTestPoint{Symbol(\"\")}",
+            sprint(showerror, err),
+        )
+    end
+
+    Left = ArrowTypesTestPoint{:left}
+    Right = ArrowTypesTestPoint{:right}
+    mismatch = Tables.partitioner((
+        (point=Arrow.DictEncode(Left[Left(Int32(1), Int32(2))]),),
+        (point=Arrow.DictEncode(Right[Right(Int32(3), Int32(4))]),),
+    ))
+    for file in (false, true)
+        err = try
+            arrowtypes_test_bytes(mismatch; file=file)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("does not conform", sprint(showerror, err))
+    end
+end
+
+@testset "partitioned DictEncode preserves registered Struct values" begin
+    Point = ArrowTypesTestPoint{:dictionary}
+    T = Union{Missing,Point}
+    parts = Tables.partitioner((
+        (point=Arrow.DictEncode(T[missing, missing]),),
+        (
+            point=Arrow.DictEncode(
+                T[Point(Int32(1), Int32(2)), missing, Point(Int32(3), Int32(4))],
+            ),
+        ),
+    ))
+    expected =
+        T[missing, missing, Point(Int32(1), Int32(2)), missing, Point(Int32(3), Int32(4))]
+    colmetadata = Dict(:point => ["application:key" => "kept"])
+
+    for file in (false, true)
+        bytes = arrowtypes_test_bytes(parts; file=file, colmetadata=colmetadata)
+        table = Arrow.Table(bytes)
+        @test isequal(table.point, expected)
+        @test eltype(table.point) === T
+
+        field = getfield(table, :schema).fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test field.nullable
+        # The physical Struct order is deliberately different from the
+        # logical Point constructor order. Dictionary lifting must honor
+        # these child names through `fromarrowstruct`.
+        @test getfield.(field.children, :name) == ["y", "x"]
+        @test DataAPI.colmetadata(table, :point, "ARROW:extension:name") ==
+              String(ARROWTYPES_TEST_POINT_NAME)
+        @test DataAPI.colmetadata(table, :point, "ARROW:extension:metadata") == "dictionary"
+        @test DataAPI.colmetadata(table, :point, "application:key") == "kept"
+
+        _, batches = arrowtypes_test_batches(bytes)
+        @test length(batches) == 2
+        # The all-missing first partition writes an empty pool; the second's
+        # categories extend it.
+        @test length(batches[1].columns[1].dictionary) == (file ? 2 : 0)
+        valuefield = ARROWTYPES_TEST_AC.dictvaluefield(field, field.type)
+        @test ARROWTYPES_TEST_AC.materialize(
+            valuefield,
+            batches[2].columns[1].dictionary,
+        ) == Any[
+            Pair{String,Any}["y" => Int32(2), "x" => Int32(1)],
+            Pair{String,Any}["y" => Int32(4), "x" => Int32(3)],
+        ]
+
+        rewritten = arrowtypes_test_bytes(Arrow.Stream(bytes); file=file)
+        rewritten_table = Arrow.Table(rewritten)
+        @test isequal(rewritten_table.point, expected)
+        @test eltype(rewritten_table.point) === T
+        rewritten_field = getfield(rewritten_table, :schema).fields[1]
+        @test rewritten_field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test rewritten_field.nullable
+        @test getfield.(rewritten_field.children, :name) == ["y", "x"]
+        @test DataAPI.colmetadata(rewritten_table, :point, "ARROW:extension:metadata") ==
+              "dictionary"
+        @test DataAPI.colmetadata(rewritten_table, :point, "application:key") == "kept"
+        _, rewritten_batches = arrowtypes_test_batches(rewritten)
+        @test length(rewritten_batches) == 2
+        @test length(rewritten_batches[2].columns[1].dictionary) == 2
+    end
+end
+
+@testset "DictEncode NullType keeps valid values distinct from outer nulls" begin
+    function checknullencoding(bytes, expectedvalid; nullable::Bool)
+        fields, batches = arrowtypes_test_batches(bytes)
+        field = fields[1]
+        @test field.type isa ARROWTYPES_TEST_AC.DictionaryType
+        @test field.type.valuetype isa ARROWTYPES_TEST_AC.NullType
+        @test field.nullable == nullable
+        @test length(batches) == length(expectedvalid)
+        for (batch, valid) in zip(batches, expectedvalid)
+            data = batch.columns[1]
+            pool = data.dictionary
+            @test pool !== nothing
+            @test length(pool) == 1
+            @test ARROWTYPES_TEST_AC.nullcount(pool) == 1
+            @test [ARROWTYPES_TEST_AC.isvalid_at(data, i) for i in eachindex(valid)] == valid
+            @test ARROWTYPES_TEST_AC.nullcount(data) == count(!, valid)
+        end
+        if length(batches) > 1
+            @test batches[1].columns[1].dictionary === batches[2].columns[1].dictionary
+        end
+        return nothing
+    end
+
+    cases = (
+        ("Nothing", Nothing, nothing),
+        ("custom", ArrowTypesTestNullLogical, ArrowTypesTestNullLogical()),
+    )
+    for (label, T, logical) in cases
+        @testset "$label fresh" begin
+            nonnullable = T[logical, logical]
+            E = Union{Missing,T}
+            nullable = E[logical, missing, logical]
+            for file in (false, true)
+                bytes =
+                    arrowtypes_test_bytes((value=Arrow.DictEncode(nonnullable),); file=file)
+                table = Arrow.Table(bytes)
+                @test table.value == nonnullable
+                @test eltype(table.value) === T
+                checknullencoding(bytes, [Bool[true, true]]; nullable=false)
+
+                nullablebytes =
+                    arrowtypes_test_bytes((value=Arrow.DictEncode(nullable),); file=file)
+                nullabletable = Arrow.Table(nullablebytes)
+                @test isequal(nullabletable.value, nullable)
+                @test eltype(nullabletable.value) === E
+                checknullencoding(nullablebytes, [Bool[true, false, true]]; nullable=true)
+
+                selected =
+                    Arrow.Table(nullablebytes; scan=Tables.Scan(select=(:value,), limit=2))
+                @test isequal(selected.value, nullable[1:2])
+                filtered = Arrow.Table(
+                    nullablebytes;
+                    scan=Tables.Scan(
+                        select=(:value,),
+                        filter=Tables.colcmp(==, Tables.col(:value), logical),
+                    ),
+                )
+                @test filtered.value == T[logical, logical]
+            end
+        end
+
+        @testset "$label partitioned retained rewrite" begin
+            E = Union{Missing,T}
+            parts = Tables.partitioner((
+                (value=Arrow.DictEncode(E[logical, missing]),),
+                (value=Arrow.DictEncode(E[logical]),),
+            ))
+            expected = E[logical, missing, logical]
+            for sourcefile in (false, true)
+                bytes = arrowtypes_test_bytes(parts; file=sourcefile)
+                table = Arrow.Table(bytes)
+                @test isequal(table.value, expected)
+                @test eltype(table.value) === E
+                checknullencoding(bytes, [Bool[true, false], Bool[true]]; nullable=true)
+
+                for outfile in (false, true)
+                    tablerewrite = arrowtypes_test_bytes(table; file=outfile)
+                    rewritten = Arrow.Table(tablerewrite)
+                    @test isequal(rewritten.value, expected)
+                    @test eltype(rewritten.value) === E
+                    checknullencoding(
+                        tablerewrite,
+                        [Bool[true, false, true]];
+                        nullable=true,
+                    )
+
+                    streamrewrite = arrowtypes_test_bytes(Arrow.Stream(bytes); file=outfile)
+                    rewrittenstream = Arrow.Table(streamrewrite)
+                    @test isequal(rewrittenstream.value, expected)
+                    @test eltype(rewrittenstream.value) === E
+                    checknullencoding(
+                        streamrewrite,
+                        [Bool[true, false], Bool[true]];
+                        nullable=true,
+                    )
+                end
+            end
+        end
+    end
+end
+
+@testset "partition extension schema mismatch" begin
+    for file in (false, true)
+        different_metadata = Tables.partitioner((
+            (point=ArrowTypesTestPoint{:a}[ArrowTypesTestPoint{:a}(1, 2)],),
+            (point=ArrowTypesTestPoint{:b}[ArrowTypesTestPoint{:b}(3, 4)],),
+        ))
+        @test_throws ArgumentError arrowtypes_test_bytes(different_metadata; file=file)
+
+        different_child_labels = Tables.partitioner((
+            (row=[(id=ArrowTypesTestID(1),)],),
+            (row=[(id=ArrowTypesTestAlternateID(2),)],),
+        ))
+        @test_throws ArgumentError arrowtypes_test_bytes(different_child_labels; file=file)
+    end
+end
+
+@testset "retained schema rewrite" begin
+    ids = ArrowTypesTestID.(Int64[4, 5])
+    points = ArrowTypesTestPoint{:retained}.(Int32[1, 2], Int32[3, 4])
+    firstids = arrowtypes_test_table((id=ids,); file=true)
+    firstpoints = arrowtypes_test_table((point=points,); file=true)
+
+    for file in (false, true)
+        format = file ? "file" : "stream"
+        @testset "scalar ($format)" begin
+            rewritten = Arrow.Table(arrowtypes_test_bytes(firstids; file=file))
+            @test rewritten.id == ids
+            @test DataAPI.colmetadata(rewritten, :id, "ARROW:extension:name") ==
+                  String(ARROWTYPES_TEST_ID_NAME)
+        end
+        @testset "struct ($format)" begin
+            rewritten = Arrow.Table(arrowtypes_test_bytes(firstpoints; file=file))
+            @test rewritten.point == points
+            @test DataAPI.colmetadata(rewritten, :point, "ARROW:extension:metadata") ==
+                  "retained"
+        end
+    end
+
+    incompatible =
+        arrowtypes_test_table((id=ArrowTypesTestID[ArrowTypesTestID(1)],); file=true)
+    getfield(incompatible, :columns)[1] = Int64[99]
+    incompatiblemissing =
+        arrowtypes_test_table((id=Union{Missing,ArrowTypesTestID}[missing],); file=true)
+    getfield(incompatiblemissing, :columns)[1] = Union{Missing,Int64}[missing]
+    for file in (false, true)
+        @test_throws ArgumentError arrowtypes_test_bytes(incompatible; file)
+        @test_throws ArgumentError arrowtypes_test_bytes(incompatiblemissing; file)
+    end
+end
+
+@testset "retained unmarked composites with marked children" begin
+    rows = [
+        (id=ArrowTypesTestID(1), plain=Int32(10)),
+        (id=ArrowTypesTestID(2), plain=Int32(20)),
+    ]
+    lists = [
+        ArrowTypesTestID[ArrowTypesTestID(1), ArrowTypesTestID(2)],
+        ArrowTypesTestID[ArrowTypesTestID(3)],
+    ]
+    structsource = arrowtypes_test_table((row=rows,); file=true)
+    listsource = arrowtypes_test_table((list=lists,); file=true)
+
+    runfield, rundata = ARROWTYPES_TEST_AC.fromjulia("run_ends", Int32[2, 4])
+    _, valuedata = ARROWTYPES_TEST_AC.fromjulia("values", Int64[1, 2])
+    valuefield = arrowtypes_test_marked_id_field("values")
+    reetype = ARROWTYPES_TEST_AC.RunEndEncodedType()
+    reefield = ARROWTYPES_TEST_AC.Field(
+        "ree",
+        reetype;
+        nullable=false,
+        children=[runfield, valuefield],
+    )
+    reedata = ARROWTYPES_TEST_AC.ArrayData(
+        reetype,
+        4,
+        ARROWTYPES_TEST_AC.BufferSlice[];
+        children=[rundata, valuedata],
+        nullcount=0,
+    )
+    reeschema = ARROWTYPES_TEST_AC.Schema([reefield])
+    reesource = Arrow.Table(
+        Arrow.writestream(
+            reeschema,
+            [ARROWTYPES_TEST_AC.RecordBatch(reeschema, [reedata], 4)],
+        ),
+    )
+    reevalues = ArrowTypesTestID.(Int64[1, 1, 2, 2])
+    @test reesource.ree == reevalues
+
+    for file in (false, true)
+        structtable = arrowtypes_test_table(structsource; file=file)
+        structfield = getfield(structtable, :schema).fields[1]
+        @test structfield.type isa ARROWTYPES_TEST_AC.StructType
+        @test arrowtypes_test_rowdict.(structtable.row) ==
+              arrowtypes_test_rowdict.(structsource.row)
+        @test all(
+            value -> value isa ArrowTypesTestID,
+            getindex.(arrowtypes_test_rowdict.(structtable.row), "id"),
+        )
+
+        listtable = arrowtypes_test_table(listsource; file=file)
+        listfield = getfield(listtable, :schema).fields[1]
+        @test listfield.type isa ARROWTYPES_TEST_AC.ListType
+        @test listtable.list == lists
+        @test all(list -> eltype(list) === ArrowTypesTestID, listtable.list)
+
+        reetable = arrowtypes_test_table(reesource; file=file)
+        rewrittenreefield = getfield(reetable, :schema).fields[1]
+        @test rewrittenreefield.type isa ARROWTYPES_TEST_AC.RunEndEncodedType
+        @test reetable.ree == reevalues
+        @test eltype(reetable.ree) === ArrowTypesTestID
+        @test any(
+            kv ->
+                first(kv) == "ARROW:extension:name" &&
+                last(kv) == String(ARROWTYPES_TEST_ID_NAME),
+            rewrittenreefield.children[2].metadata,
+        )
+    end
+end
+
+@testset "retained temporal composites stay in one writer domain" begin
+    presentdated = ArrowTypesTestDated[
+        ArrowTypesTestDated(Date(2024, 1, 2), Int32(1)),
+        ArrowTypesTestDated(Date(2024, 2, 3), Int32(2)),
+    ]
+    dated = Union{Missing,ArrowTypesTestDated}[
+        ArrowTypesTestDated(Date(2024, 1, 2), Int32(1)),
+        missing,
+        ArrowTypesTestDated(Date(2024, 2, 3), Int32(2)),
+    ]
+    presentpack = ArrowTypesTestTemporalPack[
+        ArrowTypesTestTemporalPack(
+            (ArrowTypesTestDay(Date(2024, 3, 4)), ArrowTypesTestDay(Date(2024, 3, 5))),
+            DateTime(2024, 3, 4, 5, 6, 7),
+        ),
+        ArrowTypesTestTemporalPack(
+            (ArrowTypesTestDay(Date(2024, 4, 6)), ArrowTypesTestDay(Date(2024, 4, 7))),
+            DateTime(2024, 4, 6, 7, 8, 9),
+        ),
+    ]
+    pack = Union{Missing,ArrowTypesTestTemporalPack}[
+        ArrowTypesTestTemporalPack(
+            (ArrowTypesTestDay(Date(2024, 3, 4)), ArrowTypesTestDay(Date(2024, 3, 5))),
+            DateTime(2024, 3, 4, 5, 6, 7),
+        ),
+        missing,
+        ArrowTypesTestTemporalPack(
+            (ArrowTypesTestDay(Date(2024, 4, 6)), ArrowTypesTestDay(Date(2024, 4, 7))),
+            DateTime(2024, 4, 6, 7, 8, 9),
+        ),
+    ]
+    emptyvisible = Union{Missing,ArrowTypesTestTemporalPack}[missing, missing]
+    for values in (presentdated, dated, presentpack, pack, emptyvisible),
+        encoded in (false, true),
+        inputfile in (false, true)
+
+        input = encoded ? Arrow.DictEncode(values) : values
+        bytes = arrowtypes_test_bytes((value=input,); file=inputfile)
+        @test isequal(Arrow.Table(bytes).value, values)
+        field, _ = arrowtypes_test_core_parts(bytes)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source = sourcekind === :table ? Arrow.Table(bytes) : Arrow.Stream(bytes)
+            rewrittenbytes = arrowtypes_test_bytes(source; file=outputfile)
+            @test isequal(Arrow.Table(rewrittenbytes).value, values)
+            rewrittenfield, _ = arrowtypes_test_core_parts(rewrittenbytes)
+            @test arrowtypes_test_field_contract_equal(field, rewrittenfield)
+        end
+    end
+end
+
+@testset "nullable retained composites keep logical child placeholders" begin
+    cases = (
+        ("present first", Bool[true, false], true, false),
+        ("present second", Bool[false, true], true, false),
+        ("all parents null", Bool[false, false], true, false),
+        ("nullable marked child", Bool[true, false], true, true),
+        ("native child", Bool[false, true], false, false),
+    )
+    for parentkind in (:struct, :fixed), (label, present, marked, childnullable) in cases
+        childname = parentkind === :struct ? "id" : "item"
+        physical = if parentkind === :struct
+            childnullable ? Union{Missing,Int64}[missing, 22] : Int64[11, 22]
+        else
+            childnullable ? Union{Missing,Int64}[missing, 12, 21, 22] : Int64[11, 12, 21, 22]
+        end
+        nativefield, childdata = ARROWTYPES_TEST_AC.fromjulia(childname, physical)
+        childfield =
+            marked ? arrowtypes_test_marked_id_field(childname; nullable=childnullable) :
+            nativefield
+        parenttype =
+            parentkind === :struct ? ARROWTYPES_TEST_AC.StructType() :
+            ARROWTYPES_TEST_AC.FixedSizeListType(2)
+        parentfield = ARROWTYPES_TEST_AC.Field(
+            "value",
+            parenttype;
+            nullable=true,
+            children=[childfield],
+        )
+        parentdata = ARROWTYPES_TEST_AC.ArrayData(
+            parenttype,
+            2,
+            [ARROWTYPES_TEST_AC._bitmapbuffer(present)];
+            children=[childdata],
+            nullcount=count(!, present),
+        )
+        schema = ARROWTYPES_TEST_AC.Schema([parentfield])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [parentdata], 2)
+        logical = x -> x === missing || !marked ? x : ArrowTypesTestID(x)
+        expected = Any[]
+        for i = 1:2
+            if !present[i]
+                push!(expected, missing)
+            elseif parentkind === :struct
+                # Labelled children keep `Pair` rows; native ones read as NamedTuples.
+                push!(
+                    expected,
+                    marked ? Pair{String,Any}[childname => logical(physical[i])] :
+                    NamedTuple{(Symbol(childname),)}((physical[i],)),
+                )
+            else
+                lo = 2 * (i - 1) + 1
+                values = [logical(physical[j]) for j = lo:(lo + 1)]
+                push!(expected, marked ? values : Tuple(values))
+            end
+        end
+
+        @testset "$parentkind $label" begin
+            for inputfile in (false, true)
+                inputbytes =
+                    inputfile ? Arrow.writefile(schema, [batch]) :
+                    Arrow.writestream(schema, [batch])
+                @test isequal(Arrow.Table(inputbytes).value, expected)
+                for sourcekind in (:table, :stream), outputfile in (false, true)
+                    source =
+                        sourcekind === :table ? Arrow.Table(inputbytes) :
+                        Arrow.Stream(inputbytes)
+                    outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+                    rewritten = Arrow.Table(outputbytes)
+                    @test isequal(rewritten.value, expected)
+                    rewrittenfield = getfield(rewritten, :schema).fields[1]
+                    @test arrowtypes_test_field_contract_equal(parentfield, rewrittenfield)
+                    if marked
+                        logicalchildren = Any[]
+                        for row in rewritten.value
+                            row === missing && continue
+                            if parentkind === :struct
+                                push!(logicalchildren, last(only(row)))
+                            else
+                                append!(logicalchildren, row)
+                            end
+                        end
+                        @test all(
+                            x -> x === missing || x isa ArrowTypesTestID,
+                            logicalchildren,
+                        )
+                    end
+                end
+            end
+        end
+    end
+end
+
+@testset "retained composite placeholders preserve batch topology" begin
+    for parentkind in (:struct, :fixed)
+        childname = parentkind === :struct ? "id" : "item"
+        childfield = arrowtypes_test_marked_id_field(childname)
+        parenttype =
+            parentkind === :struct ? ARROWTYPES_TEST_AC.StructType() :
+            ARROWTYPES_TEST_AC.FixedSizeListType(2)
+        parentfield = ARROWTYPES_TEST_AC.Field(
+            "value",
+            parenttype;
+            nullable=true,
+            children=[childfield],
+        )
+        schema = ARROWTYPES_TEST_AC.Schema([parentfield])
+        presentparts = (Bool[false, false], Bool[true, false])
+        physicalparts =
+            parentkind === :struct ? (Int64[0, 0], Int64[7, 0]) :
+            (Int64[0, 0, 0, 0], Int64[7, 8, 0, 0])
+        batches = ARROWTYPES_TEST_AC.RecordBatch[]
+        for (present, physical) in zip(presentparts, physicalparts)
+            _, childdata = ARROWTYPES_TEST_AC.fromjulia(childname, physical)
+            parentdata = ARROWTYPES_TEST_AC.ArrayData(
+                parenttype,
+                2,
+                [ARROWTYPES_TEST_AC._bitmapbuffer(present)];
+                children=[childdata],
+                nullcount=count(!, present),
+            )
+            push!(batches, ARROWTYPES_TEST_AC.RecordBatch(schema, [parentdata], 2))
+        end
+        expected = if parentkind === :struct
+            Any[missing, missing, Pair{String,Any}["id" => ArrowTypesTestID(7)], missing]
+        else
+            Any[
+                missing,
+                missing,
+                ArrowTypesTestID[ArrowTypesTestID(7), ArrowTypesTestID(8)],
+                missing,
+            ]
+        end
+
+        for inputfile in (false, true)
+            inputbytes =
+                inputfile ? Arrow.writefile(schema, batches) :
+                Arrow.writestream(schema, batches)
+            for sourcekind in (:table, :stream), outputfile in (false, true)
+                source =
+                    sourcekind === :table ? Arrow.Table(inputbytes) :
+                    Arrow.Stream(inputbytes)
+                outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+                rewritten = Arrow.Table(outputbytes)
+                @test isequal(rewritten.value, expected)
+                rewrittenfield, rewrittenbatches = arrowtypes_test_core_parts(outputbytes)
+                @test arrowtypes_test_field_contract_equal(parentfield, rewrittenfield)
+                @test length(rewrittenbatches) == (sourcekind === :table ? 1 : 2)
+                expectedvalidity =
+                    sourcekind === :table ? [Bool[false, false, true, false]] :
+                    collect(presentparts)
+                @test [
+                    [
+                        ARROWTYPES_TEST_AC.isvalid_at(batch.columns[1], i) for
+                        i = 1:(batch.nrows)
+                    ] for batch in rewrittenbatches
+                ] == expectedvalidity
+                width = parentkind === :struct ? 1 : 2
+                @test all(
+                    batch -> length(only(batch.columns[1].children)) == width * batch.nrows,
+                    rewrittenbatches,
+                )
+            end
+        end
+    end
+end
+
+@testset "retained nested Struct and fixed list preserve marked leaves" begin
+    idfield = arrowtypes_test_marked_id_field("item")
+    fixedtype = ARROWTYPES_TEST_AC.FixedSizeListType(2)
+    fixedfield =
+        ARROWTYPES_TEST_AC.Field("inner", fixedtype; nullable=false, children=[idfield])
+    structtype = ARROWTYPES_TEST_AC.StructType()
+    parentfield =
+        ARROWTYPES_TEST_AC.Field("value", structtype; nullable=true, children=[fixedfield])
+    schema = ARROWTYPES_TEST_AC.Schema([parentfield])
+    presentparts = (Bool[true, true], Bool[true, false])
+    physicalparts = (Int64[1, 2, 3, 4], Int64[5, 6, 70, 80])
+    batches = ARROWTYPES_TEST_AC.RecordBatch[]
+    for (present, physical) in zip(presentparts, physicalparts)
+        _, iddata = ARROWTYPES_TEST_AC.fromjulia("item", physical)
+        fixeddata = ARROWTYPES_TEST_AC.ArrayData(
+            fixedtype,
+            2,
+            [ARROWTYPES_TEST_AC.BufferSlice()];
+            children=[iddata],
+            nullcount=0,
+        )
+        parentdata = ARROWTYPES_TEST_AC.ArrayData(
+            structtype,
+            2,
+            [ARROWTYPES_TEST_AC._bitmapbuffer(present)];
+            children=[fixeddata],
+            nullcount=count(!, present),
+        )
+        push!(batches, ARROWTYPES_TEST_AC.RecordBatch(schema, [parentdata], 2))
+    end
+    expected = Any[
+        Pair{String,Any}["inner" => ArrowTypesTestID[
+            ArrowTypesTestID(1),
+            ArrowTypesTestID(2),
+        ],],
+        Pair{String,Any}["inner" => ArrowTypesTestID[
+            ArrowTypesTestID(3),
+            ArrowTypesTestID(4),
+        ],],
+        Pair{String,Any}["inner" => ArrowTypesTestID[
+            ArrowTypesTestID(5),
+            ArrowTypesTestID(6),
+        ],],
+        missing,
+    ]
+
+    for inputfile in (false, true)
+        inputbytes =
+            inputfile ? Arrow.writefile(schema, batches) :
+            Arrow.writestream(schema, batches)
+        for sourcekind in (:table, :stream), outputfile in (false, true)
+            source =
+                sourcekind === :table ? Arrow.Table(inputbytes) : Arrow.Stream(inputbytes)
+            outputbytes = arrowtypes_test_bytes(source; file=outputfile)
+            rewritten = Arrow.Table(outputbytes)
+            @test isequal(rewritten.value, expected)
+            rewrittenfield, rewrittenbatches = arrowtypes_test_core_parts(outputbytes)
+            @test arrowtypes_test_field_contract_equal(parentfield, rewrittenfield)
+            @test length(rewrittenbatches) == (sourcekind === :table ? 1 : 2)
+            @test all(
+                batch -> begin
+                    fixed = only(batch.columns[1].children)
+                    ids = only(fixed.children)
+                    length(fixed) == batch.nrows && length(ids) == 2 * batch.nrows
+                end,
+                rewrittenbatches,
+            )
+        end
+    end
+end
+
+@testset "retained null parents do not duplicate variable payloads" begin
+    payload = repeat("x", 64 * 1024)
+    present = Bool[true, falses(16)...]
+    for parentkind in (:struct, :fixed)
+        childname = parentkind === :struct ? "text" : "item"
+        physical =
+            parentkind === :struct ? String[payload, fill("", 16)...] :
+            String[payload, "tail", fill("", 32)...]
+        childfield, childdata = ARROWTYPES_TEST_AC.fromjulia(childname, physical)
+        parenttype =
+            parentkind === :struct ? ARROWTYPES_TEST_AC.StructType() :
+            ARROWTYPES_TEST_AC.FixedSizeListType(2)
+        parentfield = ARROWTYPES_TEST_AC.Field(
+            "value",
+            parenttype;
+            nullable=true,
+            children=[childfield],
+        )
+        parentdata = ARROWTYPES_TEST_AC.ArrayData(
+            parenttype,
+            length(present),
+            [ARROWTYPES_TEST_AC._bitmapbuffer(present)];
+            children=[childdata],
+            nullcount=count(!, present),
+        )
+        schema = ARROWTYPES_TEST_AC.Schema([parentfield])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [parentdata], length(present))
+        expected = if parentkind === :struct
+            Any[(text=payload,), fill(missing, 16)...]
+        else
+            Any[(payload, "tail"), fill(missing, 16)...]
+        end
+
+        for file in (false, true)
+            inputbytes =
+                file ? Arrow.writefile(schema, [batch]) : Arrow.writestream(schema, [batch])
+            for sourcekind in (:table, :stream)
+                source =
+                    sourcekind === :table ? Arrow.Table(inputbytes) :
+                    Arrow.Stream(inputbytes)
+                outputbytes = arrowtypes_test_bytes(source; file=file)
+                @test length(outputbytes) < 3 * length(inputbytes)
+                rewritten = Arrow.Table(outputbytes)
+                @test isequal(rewritten.value, expected)
+                @test arrowtypes_test_field_contract_equal(
+                    parentfield,
+                    getfield(rewritten, :schema).fields[1],
+                )
+            end
+        end
+    end
+end
+
+@testset "schema-only public composite types with marked children" begin
+    structfield = ARROWTYPES_TEST_AC.Field(
+        "struct",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        children=[arrowtypes_test_marked_id_field("id")],
+    )
+    keyfield = ARROWTYPES_TEST_AC.Field(
+        "key",
+        ARROWTYPES_TEST_AC.IntType(64, true);
+        nullable=false,
+    )
+    entriesfield = ARROWTYPES_TEST_AC.Field(
+        "entries",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        children=[keyfield, arrowtypes_test_marked_id_field("value")],
+    )
+    mapfield = ARROWTYPES_TEST_AC.Field(
+        "map",
+        ARROWTYPES_TEST_AC.MapType(false);
+        nullable=false,
+        children=[entriesfield],
+    )
+    fixedfield = ARROWTYPES_TEST_AC.Field(
+        "fixed",
+        ARROWTYPES_TEST_AC.FixedSizeListType(2);
+        nullable=false,
+        children=[arrowtypes_test_marked_id_field("item")],
+    )
+    unknownfield = ARROWTYPES_TEST_AC.Field(
+        "unknown",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        metadata=[
+            "ARROW:extension:name" => "JuliaLang.ArrowTests.UnknownStruct",
+            "ARROW:extension:metadata" => "opaque",
+        ],
+        children=[
+            ARROWTYPES_TEST_AC.Field(
+                "plain",
+                ARROWTYPES_TEST_AC.IntType(64, true);
+                nullable=false,
+            ),
+        ],
+    )
+    schema = ARROWTYPES_TEST_AC.Schema([structfield, mapfield, fixedfield, unknownfield])
+    # An unknown label reads its storage, here a struct of unlabelled fields
+    # (typed rows, as the same struct without a label).
+    expected = (
+        Vector{Pair{String,Any}},
+        Vector{Pair{Any,Any}},
+        Vector{ArrowTypesTestID},
+        @NamedTuple{plain::Int64},
+    )
+
+    _, fixedchilddata = ARROWTYPES_TEST_AC.fromjulia("item", Int64[1, 2, 3, 4])
+    fixeddata = ARROWTYPES_TEST_AC.ArrayData(
+        fixedfield.type,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[fixedchilddata],
+        nullcount=0,
+    )
+    fixedschema = ARROWTYPES_TEST_AC.Schema([fixedfield])
+    fixedbatch = ARROWTYPES_TEST_AC.RecordBatch(fixedschema, [fixeddata], 2)
+    fixedvalues = [
+        ArrowTypesTestID[ArrowTypesTestID(1), ArrowTypesTestID(2)],
+        ArrowTypesTestID[ArrowTypesTestID(3), ArrowTypesTestID(4)],
+    ]
+
+    for file in (false, true)
+        bytes =
+            file ? Arrow.writefile(schema, ARROWTYPES_TEST_AC.RecordBatch[]) :
+            Arrow.writestream(schema, ARROWTYPES_TEST_AC.RecordBatch[])
+        empty!(Arrow._WARNED_EXTENSIONS)  # warnings are once per process
+        table =
+            @test_logs (:warn, r"unsupported .*extension.*UnknownStruct") Arrow.Table(bytes)
+        @test Tuple(
+            eltype(Tables.getcolumn(table, i)) for i in eachindex(schema.fields)
+        ) === expected
+        @test all(i -> isempty(Tables.getcolumn(table, i)), eachindex(schema.fields))
+
+        fixedbytes =
+            file ? Arrow.writefile(fixedschema, [fixedbatch]) :
+            Arrow.writestream(fixedschema, [fixedbatch])
+        fixedtable = Arrow.Table(fixedbytes)
+        @test fixedtable.fixed == fixedvalues
+        @test eltype(fixedtable.fixed) === Vector{ArrowTypesTestID}
+        @test all(row -> eltype(row) === ArrowTypesTestID, fixedtable.fixed)
+    end
+end
+
+@testset "wide extension Struct signatures are bounded" begin
+    widefield = function (n; marked::Bool=true)
+        children = ARROWTYPES_TEST_AC.Field[
+            ARROWTYPES_TEST_AC.Field(
+                "child_$i",
+                ARROWTYPES_TEST_AC.NullType();
+                nullable=true,
+            ) for i = 1:n
+        ]
+        metadata =
+            marked ?
+            arrowtypes_test_extension_metadata("JuliaLang.ArrowTests.UnknownWideStruct") : nothing
+        return ARROWTYPES_TEST_AC.Field(
+            "wide",
+            ARROWTYPES_TEST_AC.StructType();
+            nullable=false,
+            metadata,
+            children,
+        )
+    end
+
+    exact = widefield(1_024)
+    # Exact NamedTuple lifting is available only for extension and child names
+    # that trusted Julia code already registered in the process.
+    Symbol("JuliaLang.ArrowTests.UnknownWideStruct")
+    foreach(child -> Symbol(child.name), exact.children)
+    haslabel, target, storage =
+        Arrow._arrowtypestarget(Arrow._ArrowTypesContext(warn=false), exact)
+    @test haslabel
+    @test target === nothing
+    @test storage <: NamedTuple
+    @test fieldcount(storage) == 1_024
+
+    bounded = widefield(1_025)
+    @test Arrow._arrowtypestarget(Arrow._ArrowTypesContext(warn=false), bounded) ==
+          (true, nothing, Vector{Pair{String,Any}})
+
+    nested = ARROWTYPES_TEST_AC.Field(
+        "outer",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(
+            "JuliaLang.ArrowTests.UnknownNestedWideStruct",
+        ),
+        children=[widefield(1_025; marked=false)],
+    )
+    Symbol("JuliaLang.ArrowTests.UnknownNestedWideStruct")
+    _, nestedtarget, nestedstorage =
+        Arrow._arrowtypestarget(Arrow._ArrowTypesContext(warn=false), nested)
+    @test nestedtarget === nothing
+    @test nestedstorage === Vector{Pair{String,Any}}
+
+    larger = widefield(8_192)
+    Arrow._arrowtypestarget(Arrow._ArrowTypesContext(warn=false), bounded)
+    Arrow._arrowtypestarget(Arrow._ArrowTypesContext(warn=false), larger)
+    GC.gc()
+    smallallocation =
+        @allocated Arrow._arrowtypestarget(Arrow._ArrowTypesContext(warn=false), bounded)
+    GC.gc()
+    largeallocation =
+        @allocated Arrow._arrowtypestarget(Arrow._ArrowTypesContext(warn=false), larger)
+    @test largeallocation <= smallallocation + 250_000
+
+    schema = ARROWTYPES_TEST_AC.Schema([bounded])
+    bytes = Arrow.writestream(schema, ARROWTYPES_TEST_AC.RecordBatch[])
+    empty!(Arrow._WARNED_EXTENSIONS)  # warnings are once per process
+    table = @test_logs (:warn, r"unsupported .*UnknownWideStruct") Arrow.Table(bytes)
+    @test isempty(table.wide)
+    @test eltype(table.wide) === Vector{Pair{String,Any}}
+
+    unmarked = widefield(1_025; marked=false)
+    unmarkedschema = ARROWTYPES_TEST_AC.Schema([unmarked])
+    unmarkedbytes = Arrow.writestream(unmarkedschema, ARROWTYPES_TEST_AC.RecordBatch[])
+    unmarkedtable = @test_logs min_level = Base.CoreLogging.Error Arrow.Table(unmarkedbytes)
+    @test isempty(unmarkedtable.wide)
+    @test eltype(unmarkedtable.wide) === Vector{Pair{String,Any}}
+
+    longname = repeat("wide-extension-", 1_000)
+    displayname = Arrow._extensionwarningname(longname)
+    @test endswith(displayname, "…")
+    @test ncodeunits(displayname) == Arrow._MAX_EXTENSION_WARNING_BYTES + ncodeunits("…")
+end
+
+@testset "ArrowTypes schema caches consume the reader allocation budget" begin
+    leaf = ARROWTYPES_TEST_AC.Field(
+        "leaf",
+        ARROWTYPES_TEST_AC.IntType(64, true);
+        nullable=false,
+    )
+
+    entryprobe = Arrow.AllocationBudget(1_000_000)
+    entrybefore = Arrow._remaining(entryprobe)
+    Arrow._chargedictentry!(entryprobe, ARROWTYPES_TEST_AC.Field, Bool, "test route cache")
+    routeentrybytes = entrybefore - Arrow._remaining(entryprobe)
+    @test routeentrybytes > 0
+
+    calls = Ref(0)
+    cache = Dict{ARROWTYPES_TEST_AC.Field,Bool}()
+    compute = function ()
+        calls[] += 1
+        return false
+    end
+    @test_throws Arrow.AllocationLimitError Arrow._memoized!(
+        compute,
+        cache,
+        leaf,
+        Arrow.AllocationBudget(0),
+        "test route cache",
+    )
+    @test isempty(cache)
+    @test calls[] == 0
+
+    exact = Arrow.AllocationBudget(routeentrybytes)
+    @test !Arrow._memoized!(compute, cache, leaf, exact, "test route cache")
+    @test Arrow._remaining(exact) == 0
+    @test calls[] == 1
+
+    @test_throws Arrow.AllocationLimitError Arrow._ArrowTypesRoutePlan(
+        Arrow.AllocationBudget(0),
+    )
+    @test_throws Arrow.AllocationLimitError Arrow._ArrowTypesContext(
+        warn=false,
+        budget=Arrow.AllocationBudget(0),
+    )
+
+    plancontainerprobe = Arrow.AllocationBudget(1_000_000)
+    plancontainerbefore = Arrow._remaining(plancontainerprobe)
+    Arrow._ArrowTypesRoutePlan(plancontainerprobe)
+    plancontainerbytes = plancontainerbefore - Arrow._remaining(plancontainerprobe)
+    @test plancontainerbytes > 0
+    Arrow._ArrowTypesRoutePlan()
+    GC.gc()
+    plancontainerallocation = @allocated Arrow._ArrowTypesRoutePlan()
+    @test plancontainerbytes >= plancontainerallocation
+
+    contextcontainerprobe = Arrow.AllocationBudget(1_000_000)
+    contextcontainerbefore = Arrow._remaining(contextcontainerprobe)
+    Arrow._ArrowTypesContext(warn=false, budget=contextcontainerprobe)
+    contextcontainerbytes = contextcontainerbefore - Arrow._remaining(contextcontainerprobe)
+    @test contextcontainerbytes > plancontainerbytes
+    Arrow._ArrowTypesContext(warn=false)
+    GC.gc()
+    contextcontainerallocation = @allocated Arrow._ArrowTypesContext(warn=false)
+    @test contextcontainerbytes >= contextcontainerallocation
+    @test !Arrow._memoized!(compute, cache, leaf, exact, "test route cache")
+    @test Arrow._remaining(exact) == 0
+    @test calls[] == 1
+
+    routeexact = Arrow.AllocationBudget(plancontainerbytes + routeentrybytes)
+    exactplan = Arrow._ArrowTypesRoutePlan(routeexact)
+    @test !Arrow._needsarrowtypesroute(leaf, exactplan)
+    @test length(exactplan.routes) == 1
+    @test Arrow._remaining(routeexact) == 0
+    @test !Arrow._needsarrowtypesroute(leaf, exactplan)
+    @test Arrow._remaining(routeexact) == 0
+
+    intfield, intdata = ARROWTYPES_TEST_AC.fromjulia("integer", Int64[])
+    textfield, textdata = ARROWTYPES_TEST_AC.fromjulia("text", String[])
+    uniontype = ARROWTYPES_TEST_AC.UnionType(ARROWTYPES_TEST_AC.DenseMode, Int8[42, 17])
+    unionfield = ARROWTYPES_TEST_AC.Field(
+        "union",
+        uniontype;
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(
+            "JuliaLang.ArrowTests.RouteBudgetProbe",
+        ),
+        children=[intfield, textfield],
+    )
+    uniondata = ARROWTYPES_TEST_AC.ArrayData(
+        uniontype,
+        0,
+        [ARROWTYPES_TEST_AC._databuffer(Int8[]), ARROWTYPES_TEST_AC._databuffer(Int32[])];
+        children=[intdata, textdata],
+        nullcount=0,
+    )
+    emptycolumnbytes = ARROWTYPES_TEST_AC._materializedvectorbytes(Any, 0)
+    multibatchbudget = Arrow.AllocationBudget(
+        plancontainerbytes + 2 * routeentrybytes + 2 * emptycolumnbytes,
+    )
+    multibatchplan = Arrow._ArrowTypesRoutePlan(multibatchbudget)
+    # The same schema Field crosses both batch materializations. The exact
+    # budget admits one extension-presence entry, one route entry, and two
+    # empty result vectors only.
+    @test isempty(Arrow._batchcolumn(unionfield, uniondata, multibatchplan))
+    @test isempty(Arrow._batchcolumn(unionfield, uniondata, multibatchplan))
+    @test length(multibatchplan.routes) == 1
+    @test Arrow._remaining(multibatchbudget) == 0
+
+    targetprobe = Arrow.AllocationBudget(1_000_000)
+    targetbefore = Arrow._remaining(targetprobe)
+    Arrow._chargedictentry!(targetprobe, ARROWTYPES_TEST_AC.Field, Any, "test target cache")
+    targetentrybytes = targetbefore - Arrow._remaining(targetprobe)
+    targetexact = Arrow.AllocationBudget(contextcontainerbytes + targetentrybytes)
+    targetctx = Arrow._ArrowTypesContext(warn=false, budget=targetexact)
+    @test Arrow._arrowtypestarget(targetctx, leaf) == (false, nothing, nothing)
+    @test Arrow._remaining(targetexact) == 0
+    @test Arrow._arrowtypestarget(targetctx, leaf) == (false, nothing, nothing)
+    @test Arrow._remaining(targetexact) == 0
+
+    targetzero = Arrow._ArrowTypesContext(warn=false)
+    targetzero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypestarget(targetzero, leaf)
+    @test isempty(targetzero.targets)
+
+    logicalzero = Arrow._ArrowTypesContext(warn=false)
+    logicalzero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypeslogicaleltype(
+        logicalzero,
+        leaf,
+    )
+    @test isempty(logicalzero.logicaltypes)
+
+    publiczero = Arrow._ArrowTypesContext(warn=false)
+    publiczero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypespubliceltype(publiczero, leaf)
+    @test isempty(publiczero.publictypes)
+
+    storagezero = Arrow._ArrowTypesContext(warn=false)
+    storagezero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypesstoragetype!(
+        storagezero,
+        ArrowTypesTestID,
+    )
+    @test isempty(storagezero.storage)
+
+    dictchildren = ARROWTYPES_TEST_AC.Field[
+        ARROWTYPES_TEST_AC.Field("left", ARROWTYPES_TEST_AC.IntType(64, true)),
+        ARROWTYPES_TEST_AC.Field("right", ARROWTYPES_TEST_AC.Utf8Type(false)),
+    ]
+    dictfield = ARROWTYPES_TEST_AC.Field(
+        "dict",
+        ARROWTYPES_TEST_AC.DictionaryType(
+            ARROWTYPES_TEST_AC.IntType(32, true),
+            ARROWTYPES_TEST_AC.StructType(),
+            false,
+        );
+        nullable=false,
+        metadata=arrowtypes_test_extension_metadata(ARROWTYPES_TEST_POINT_NAME),
+        children=dictchildren,
+    )
+    dicttype = dictfield.type
+    plainvaluefield = Arrow._arrowtypesdictvaluefield(dictfield, dicttype)
+    metadatavaluefield =
+        Arrow._arrowtypesdictvaluefield(dictfield, dicttype; retainmetadata=true)
+    publicvaluefield = Arrow._arrowtypesdictvaluefield(dictfield, dicttype; nullable=false)
+    @test plainvaluefield.children === dictfield.children
+    @test metadatavaluefield.children === dictfield.children
+    @test publicvaluefield.children === dictfield.children
+    @test plainvaluefield.metadata === nothing
+    @test metadatavaluefield.metadata === dictfield.metadata
+    @test plainvaluefield.nullable
+    @test !publicvaluefield.nullable
+
+    fieldprobe = Arrow.AllocationBudget(1_000_000)
+    fieldbefore = Arrow._remaining(fieldprobe)
+    Arrow._arrowtypesdictvaluefield(dictfield, dicttype; budget=fieldprobe)
+    fieldobjectbytes = fieldbefore - Arrow._remaining(fieldprobe)
+    @test fieldobjectbytes > 0
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypesdictvaluefield(
+        dictfield,
+        dicttype;
+        budget=Arrow.AllocationBudget(fieldobjectbytes - 1),
+    )
+    dictentryprobe = Arrow.AllocationBudget(1_000_000)
+    dictentrybefore = Arrow._remaining(dictentryprobe)
+    Arrow._chargedictentry!(
+        dictentryprobe,
+        ARROWTYPES_TEST_AC.Field,
+        ARROWTYPES_TEST_AC.Field,
+        "test dictionary-field cache",
+    )
+    dictentrybytes = dictentrybefore - Arrow._remaining(dictentryprobe)
+    cachedfieldshort = Arrow._ArrowTypesContext(warn=false)
+    cachedfieldshort.budget = Arrow.AllocationBudget(dictentrybytes + fieldobjectbytes - 1)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypesdictvaluefield(
+        cachedfieldshort,
+        dictfield,
+        dicttype,
+    )
+    @test isempty(cachedfieldshort.dictionaryfields)
+    cachedfieldexact = Arrow._ArrowTypesContext(warn=false)
+    cachedfieldexact.budget = Arrow.AllocationBudget(dictentrybytes + fieldobjectbytes)
+    cachedvaluefield =
+        Arrow._arrowtypesdictvaluefield(cachedfieldexact, dictfield, dicttype)
+    @test cachedvaluefield.children === dictfield.children
+    @test Arrow._remaining(cachedfieldexact.budget) == 0
+    @test Arrow._arrowtypesdictvaluefield(cachedfieldexact, dictfield, dicttype) ===
+          cachedvaluefield
+    @test Arrow._remaining(cachedfieldexact.budget) == 0
+
+    dictzero = Arrow._ArrowTypesContext(warn=false)
+    dictzero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypesdictvaluefield(
+        dictzero,
+        dictfield,
+        dicttype,
+    )
+    @test isempty(dictzero.dictionaryfields)
+
+    metadatazero = Arrow._ArrowTypesContext(warn=false)
+    metadatazero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypesdictvaluefield(
+        metadatazero,
+        dictfield,
+        dicttype;
+        retainmetadata=true,
+    )
+    @test isempty(metadatazero.metadata_dictionaryfields)
+
+    publicdictzero = Arrow._ArrowTypesContext(warn=false)
+    publicdictzero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypespublicdictvaluefield(
+        publicdictzero,
+        dictfield,
+        dicttype,
+    )
+    @test isempty(publicdictzero.public_dictionaryfields)
+
+    routedzero = Arrow._ArrowTypesRoutePlan()
+    routedzero.budget = Arrow.AllocationBudget(0)
+    @test_throws Arrow.AllocationLimitError Arrow._routedictionaryfield!(
+        routedzero,
+        dictfield,
+        dicttype,
+    )
+    @test isempty(routedzero.dictionaryfields)
+
+    positionalchildren = ARROWTYPES_TEST_AC.Field[
+        ARROWTYPES_TEST_AC.Field(
+            string(i),
+            ARROWTYPES_TEST_AC.IntType(64, true);
+            nullable=false,
+        ) for i = 1:1_024
+    ]
+    positional = ARROWTYPES_TEST_AC.Field(
+        "positional",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        children=positionalchildren,
+    )
+    namesprobe = Arrow.AllocationBudget(1_000_000)
+    namesbefore = Arrow._remaining(namesprobe)
+    expectednames = Tuple(Symbol.(string.(1:1_024)))
+    @test Arrow._arrowtypesstructnames(positional, namesprobe) == expectednames
+    namesbytes = namesbefore - Arrow._remaining(namesprobe)
+    @test namesbytes > 0
+    @test_throws Arrow.AllocationLimitError Arrow._arrowtypesstructnames(
+        positional,
+        Arrow.AllocationBudget(namesbytes - 1),
+    )
+    namescontext = Arrow._ArrowTypesContext(warn=false)
+    namescontext.budget = Arrow.AllocationBudget(namesbytes + 10 * routeentrybytes)
+    @test Arrow._arrowtypesstructnames(namescontext, positional) == expectednames
+    namesremaining = Arrow._remaining(namescontext.budget)
+    @test Arrow._arrowtypesstructnames(namescontext, positional) == expectednames
+    @test Arrow._remaining(namescontext.budget) == namesremaining
+    @test length(namescontext.structnames) == 1
+
+    children = ARROWTYPES_TEST_AC.Field[
+        ARROWTYPES_TEST_AC.Field(
+            "child_$i",
+            ARROWTYPES_TEST_AC.IntType(64, true);
+            nullable=false,
+        ) for i = 1:8_191
+    ]
+    push!(children, arrowtypes_test_marked_id_field("last"))
+    wide = ARROWTYPES_TEST_AC.Field(
+        "wide",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        children,
+    )
+    widebudget = Arrow.AllocationBudget(32 * routeentrybytes - 1)
+    wideplan = Arrow._ArrowTypesRoutePlan()
+    wideplan.budget = widebudget
+    @test_throws Arrow.AllocationLimitError Arrow._needsarrowtypesroute(wide, wideplan)
+    @test length(wideplan.routes) == 30
+    @test !haskey(wideplan.routes, wide)
+    @test Arrow._remaining(widebudget) == routeentrybytes - 1
+
+    presenceentries = length(children) + 1
+    presenceprobe =
+        Arrow.AllocationBudget(plancontainerbytes + presenceentries * routeentrybytes)
+    presenceplan = Arrow._ArrowTypesRoutePlan(presenceprobe)
+    presencebefore = Arrow._remaining(presenceprobe)
+    @test Arrow._hasarrowtypesextension(wide, presenceplan)
+    presenceafter = Arrow._remaining(presenceprobe)
+    @test presenceafter < presencebefore
+    @test Arrow._hasarrowtypesextension(wide, presenceplan)
+    @test Arrow._remaining(presenceprobe) == presenceafter
+    @test length(presenceplan.extensions) == presenceentries
+end
+
+@testset "unknown extension fallback" begin
+    metadata = Dict(
+        :x => Dict(
+            "ARROW:extension:name" => "JuliaLang.ArrowTests.Unknown",
+            "ARROW:extension:metadata" => "opaque",
+        ),
+    )
+    bytes = arrowtypes_test_bytes((x=Int64[7, 8],); file=false, colmetadata=metadata)
+    empty!(Arrow._WARNED_EXTENSIONS)  # warnings are once per process
+    table = @test_logs (:warn, r"unsupported .*extension.*Unknown") Arrow.Table(bytes)
+    @test table.x == Int64[7, 8]
+    @test eltype(table.x) === Int64
+    @test DataAPI.colmetadata(table, :x, "ARROW:extension:name") ==
+          "JuliaLang.ArrowTests.Unknown"
+
+    nullvaluefield, nullpool = ARROWTYPES_TEST_AC.fromjulia("x", Missing[missing])
+    nulltype = ARROWTYPES_TEST_AC.DictionaryType(
+        ARROWTYPES_TEST_AC.IntType(32, true),
+        nullvaluefield.type,
+        false,
+    )
+    nullfield = ARROWTYPES_TEST_AC.Field(
+        "x",
+        nulltype;
+        nullable=true,
+        metadata=[
+            "ARROW:extension:name" => "JuliaLang.ArrowTests.UnknownNull",
+            "ARROW:extension:metadata" => "opaque",
+        ],
+    )
+    nulldata = Arrow._dictbatch(nullfield, Union{Missing,Int64}[0, missing], nullpool)
+    nullschema = ARROWTYPES_TEST_AC.Schema([nullfield])
+    nullbatch = ARROWTYPES_TEST_AC.RecordBatch(nullschema, [nulldata], 2)
+    nullbytes = Arrow.writestream(nullschema, [nullbatch])
+    empty!(Arrow._WARNED_EXTENSIONS)  # warnings are once per process
+    nulltable =
+        @test_logs (:warn, r"unsupported .*extension.*UnknownNull") Arrow.Table(nullbytes)
+    @test isequal(nulltable.x, Missing[missing, missing])
+    @test eltype(nulltable.x) === Missing
+    for source in (nulltable, Arrow.Stream(nullbytes)), file in (false, true)
+        err = try
+            arrowtypes_test_bytes(source; file)
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test occursin("unregistered", sprint(showerror, err))
+        @test occursin("Dictionary<Null>", sprint(showerror, err))
+    end
+
+    nonnullfield = ARROWTYPES_TEST_AC.Field(
+        "x",
+        nulltype;
+        nullable=false,
+        metadata=collect(Pair{String,String}, nullfield.metadata),
+    )
+    nonnulldata = Arrow._dictbatch(nonnullfield, Int64[0, 0], nullpool)
+    nonnullschema = ARROWTYPES_TEST_AC.Schema([nonnullfield])
+    nonnullbatch = ARROWTYPES_TEST_AC.RecordBatch(nonnullschema, [nonnulldata], 2)
+    nonnullbytes = Arrow.writestream(nonnullschema, [nonnullbatch])
+    for source in (Arrow.Table(nonnullbytes), Arrow.Stream(nonnullbytes)),
+        file in (false, true)
+
+        output = arrowtypes_test_bytes(source; file)
+        table = Arrow.Table(output)
+        @test isequal(table.x, Missing[missing, missing])
+        _, batches = arrowtypes_test_core_parts(output)
+        @test all(ARROWTYPES_TEST_AC.isvalid_at(only(batches).columns[1], i) for i = 1:2)
+    end
+
+    function unknownnulldictionary(name, extension)
+        valuefield, pool = ARROWTYPES_TEST_AC.fromjulia(name, Missing[missing])
+        t = ARROWTYPES_TEST_AC.DictionaryType(
+            ARROWTYPES_TEST_AC.IntType(32, true),
+            valuefield.type,
+            false,
+        )
+        field = ARROWTYPES_TEST_AC.Field(
+            name,
+            t;
+            nullable=true,
+            metadata=[
+                "ARROW:extension:name" => extension,
+                "ARROW:extension:metadata" => "opaque",
+            ],
+        )
+        data = Arrow._dictbatch(field, Union{Missing,Int64}[0, missing], pool)
+        return field, data
+    end
+
+    nested = Any[]
+
+    structchild, structchilddata =
+        unknownnulldictionary("d", "JuliaLang.ArrowTests.UnknownNullStruct")
+    structtype = ARROWTYPES_TEST_AC.StructType()
+    structfield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        structtype;
+        nullable=false,
+        children=[structchild],
+    )
+    structdata = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[structchilddata],
+        nullcount=0,
+    )
+    push!(
+        nested,
+        (
+            "Struct",
+            structfield,
+            structdata,
+            Any[Pair{String,Any}["d" => missing], Pair{String,Any}["d" => missing]],
+        ),
+    )
+
+    listchild, listchilddata =
+        unknownnulldictionary("item", "JuliaLang.ArrowTests.UnknownNullList")
+    listtype = ARROWTYPES_TEST_AC.ListType(false)
+    listfield =
+        ARROWTYPES_TEST_AC.Field("value", listtype; nullable=false, children=[listchild])
+    listdata = ARROWTYPES_TEST_AC.ArrayData(
+        listtype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 1, 2])];
+        children=[listchilddata],
+        nullcount=0,
+    )
+    push!(nested, ("List", listfield, listdata, Any[Missing[missing], Missing[missing]]))
+
+    mapvalue, mapvaluedata =
+        unknownnulldictionary("value", "JuliaLang.ArrowTests.UnknownNullMap")
+    mapkey, mapkeydata = ARROWTYPES_TEST_AC.fromjulia("key", Int32[1, 2])
+    entriesfield = ARROWTYPES_TEST_AC.Field(
+        "entries",
+        ARROWTYPES_TEST_AC.StructType();
+        nullable=false,
+        children=[mapkey, mapvalue],
+    )
+    entriesdata = ARROWTYPES_TEST_AC.ArrayData(
+        ARROWTYPES_TEST_AC.StructType(),
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[mapkeydata, mapvaluedata],
+        nullcount=0,
+    )
+    maptype = ARROWTYPES_TEST_AC.MapType(false)
+    mapfield =
+        ARROWTYPES_TEST_AC.Field("value", maptype; nullable=false, children=[entriesfield])
+    mapdata = ARROWTYPES_TEST_AC.ArrayData(
+        maptype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice(), ARROWTYPES_TEST_AC._databuffer(Int32[0, 1, 2])];
+        children=[entriesdata],
+        nullcount=0,
+    )
+    push!(
+        nested,
+        (
+            "Map",
+            mapfield,
+            mapdata,
+            Any[Pair{Any,Any}[Int32(1) => missing], Pair{Any,Any}[Int32(2) => missing]],
+        ),
+    )
+
+    reevalue, reevaludata =
+        unknownnulldictionary("values", "JuliaLang.ArrowTests.UnknownNullREE")
+    runfield, rundata = ARROWTYPES_TEST_AC.fromjulia("run_ends", Int32[1, 2])
+    reetype = ARROWTYPES_TEST_AC.RunEndEncodedType()
+    reefield = ARROWTYPES_TEST_AC.Field(
+        "value",
+        reetype;
+        nullable=false,
+        children=[runfield, reevalue],
+    )
+    reedata = ARROWTYPES_TEST_AC.ArrayData(
+        reetype,
+        2,
+        ARROWTYPES_TEST_AC.BufferSlice[];
+        children=[rundata, reevaludata],
+        nullcount=0,
+    )
+    push!(nested, ("RunEndEncoded", reefield, reedata, Missing[missing, missing]))
+
+    for (label, field, data, expected) in nested
+        schema = ARROWTYPES_TEST_AC.Schema([field])
+        batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 2)
+        for file in (false, true)
+            bytes =
+                file ? Arrow.writefile(schema, [batch]) : Arrow.writestream(schema, [batch])
+            # The top-level fallback above verifies the warning contract.
+            # These cases isolate recursive marker consumption.
+            table = @test_logs min_level = Base.CoreLogging.Error Arrow.Table(bytes)
+            @testset "$label ($(file ? "file" : "stream"))" begin
+                @test isequal(table.value, expected)
+                @test !occursin("_ArrowTypesRoutedNull", sprint(show, table.value))
+            end
+        end
+    end
+end
+
+@testset "unknown duplicate-name Struct extension fallback" begin
+    child1, childdata1 = ARROWTYPES_TEST_AC.fromjulia("x", Int64[1, 2])
+    child2, childdata2 = ARROWTYPES_TEST_AC.fromjulia("x", Int64[10, 20])
+    structtype = ARROWTYPES_TEST_AC.StructType()
+    field = ARROWTYPES_TEST_AC.Field(
+        "duplicate",
+        structtype;
+        nullable=false,
+        metadata=[
+            "ARROW:extension:name" => "JuliaLang.ArrowTests.UnknownDuplicateStruct",
+            "ARROW:extension:metadata" => "opaque",
+        ],
+        children=[child1, child2],
+    )
+    data = ARROWTYPES_TEST_AC.ArrayData(
+        structtype,
+        2,
+        [ARROWTYPES_TEST_AC.BufferSlice()];
+        children=[childdata1, childdata2],
+        nullcount=0,
+    )
+    schema = ARROWTYPES_TEST_AC.Schema([field])
+    batch = ARROWTYPES_TEST_AC.RecordBatch(schema, [data], 2)
+    expected =
+        [Pair{String,Any}["x" => 1, "x" => 10], Pair{String,Any}["x" => 2, "x" => 20]]
+
+    for file in (false, true)
+        bytes = file ? Arrow.writefile(schema, [batch]) : Arrow.writestream(schema, [batch])
+        empty!(Arrow._WARNED_EXTENSIONS)  # warnings are once per process
+        table =
+            @test_logs (:warn, r"unsupported .*extension.*UnknownDuplicateStruct") Arrow.Table(
+                bytes,
+            )
+        @test table.duplicate == expected
+        @test eltype(table.duplicate) === Vector{Pair{String,Any}}
+    end
+end
+
+@testset "Tables.Scan public-domain values" begin
+    ids = ArrowTypesTestID.(Int64[1, 2, 3, 2])
+    labels = ["one", "two-a", "three", "two-b"]
+    bytes = arrowtypes_test_bytes((id=ids, label=labels); file=true)
+
+    selected = Arrow.Table(bytes; scan=Tables.Scan(select=(:id,)))
+    @test selected.id == ids
+    @test eltype(selected.id) === ArrowTypesTestID
+
+    for emptyscan in (
+        Tables.Scan(select=(:id => ArrowTypesTestID,), limit=0),
+        Tables.Scan(select=(:id => ArrowTypesTestID,), offset=99),
+    )
+        emptyselected = Arrow.Table(bytes; scan=emptyscan)
+        @test isempty(emptyselected.id)
+        @test eltype(emptyselected.id) === ArrowTypesTestID
+        @test collect(Tables.columnnames(emptyselected)) == [:id]
+        fields = getfield(emptyselected, :schema).fields
+        @test length(fields) == 1
+        if length(fields) == 1
+            @test fields[1].metadata !== nothing
+            @test any(
+                kv ->
+                    first(kv) == "ARROW:extension:name" &&
+                    last(kv) == String(ARROWTYPES_TEST_ID_NAME),
+                fields[1].metadata,
+            )
+        end
+    end
+
+    filtered = Arrow.Table(
+        bytes;
+        scan=Tables.Scan(
+            select=(:id, :label),
+            filter=Tables.colcmp(==, Tables.col(:id), ArrowTypesTestID(2)),
+        ),
+    )
+    @test filtered.id == ArrowTypesTestID.(Int64[2, 2])
+    @test filtered.label == ["two-a", "two-b"]
+    @test eltype(filtered.id) === ArrowTypesTestID
+
+    parityids = ArrowTypesTestParityID.(Int64[1, 2, 3, 4, 5])
+    paritybytes = arrowtypes_test_bytes((id=parityids, row=Int32[1, 2, 3, 4, 5]); file=true)
+    parityfiltered = Arrow.Table(
+        paritybytes;
+        scan=Tables.Scan(
+            select=(:id, :row),
+            filter=Tables.colcmp(==, Tables.col(:id), ArrowTypesTestParityID(2)),
+        ),
+    )
+    @test getfield.(parityfiltered.id, :value) == Int64[2, 4]
+    @test eltype(parityfiltered.id) === ArrowTypesTestParityID
+    @test parityfiltered.row == Int32[2, 4]
+
+    nestedparity = ArrowTypesTestParityID.(Int64[1, 2, 4])
+    nestedbytes = arrowtypes_test_bytes(
+        (
+            structrow=[(id=value,) for value in nestedparity],
+            listrow=[[value] for value in nestedparity],
+            row=Int32[1, 2, 3],
+        );
+        file=true,
+    )
+    nestedfull = Arrow.Table(nestedbytes)
+    nestedempty =
+        Arrow.Table(nestedbytes; scan=Tables.Scan(select=(:structrow, :listrow), limit=0))
+    @test isempty(nestedempty.structrow) && isempty(nestedempty.listrow)
+    @test eltype(nestedempty.structrow) === eltype(nestedfull.structrow)
+    @test eltype(nestedempty.listrow) === eltype(nestedfull.listrow)
+    nestedemptyfields = getfield(nestedempty, :schema).fields
+    nestedfullfields = getfield(nestedfull, :schema).fields
+    @test length(nestedemptyfields) == 2
+    @test length(nestedfullfields) == 3
+    @test all(
+        arrowtypes_test_field_contract_equal(emptyfield, fullfield) for
+        (emptyfield, fullfield) in zip(nestedemptyfields, nestedfullfields[1:2])
+    )
+    structfiltered = Arrow.Table(
+        nestedbytes;
+        scan=Tables.Scan(
+            select=(:structrow, :row),
+            filter=Tables.colcmp(==, Tables.col(:structrow), nestedfull.structrow[2]),
+        ),
+    )
+    @test structfiltered.row == Int32[2, 3]
+    @test [
+        arrowtypes_test_rowdict(value)["id"].value for value in structfiltered.structrow
+    ] == Int64[2, 4]
+
+    listfiltered = Arrow.Table(
+        nestedbytes;
+        scan=Tables.Scan(
+            select=(:listrow, :row),
+            filter=Tables.colcmp(==, Tables.col(:listrow), nestedfull.listrow[2]),
+        ),
+    )
+    @test listfiltered.row == Int32[2, 3]
+    @test [only(value).value for value in listfiltered.listrow] == Int64[2, 4]
+
+    unionvalues = ArrowTypesTestLogicalUnion[
+        ArrowTypesTestLogicalUnion(Int64(1)),
+        ArrowTypesTestLogicalUnion("two"),
+    ]
+    unionbytes = arrowtypes_test_bytes((value=unionvalues,); file=true)
+    unionfull = Arrow.Table(unionbytes)
+    for emptyscan in (Tables.Scan(limit=0), Tables.Scan(offset=99))
+        unionempty = Arrow.Table(unionbytes; scan=emptyscan)
+        @test isempty(unionempty.value)
+        @test eltype(unionempty.value) === ArrowTypesTestLogicalUnion
+        @test arrowtypes_test_field_contract_equal(
+            only(getfield(unionempty, :schema).fields),
+            only(getfield(unionfull, :schema).fields),
+        )
+    end
+
+    stringvalues = arrowtypes_test_pointer_string.(["alpha", "beta", "alpine"])
+    stringbytes = arrowtypes_test_bytes((value=stringvalues, row=Int32[1, 2, 3]); file=true)
+    ARROWTYPES_TEST_POINTER_STRING_CALLS[] = 0
+    stringfiltered = Arrow.Table(
+        stringbytes;
+        scan=Tables.Scan(
+            select=(:value, :row),
+            filter=Tables.startswith(Tables.col(:value), "al"),
+        ),
+    )
+    @test stringfiltered.value == stringvalues[[1, 3]]
+    @test eltype(stringfiltered.value) === ArrowTypesTestPointerString
+    @test stringfiltered.row == Int32[1, 3]
+    @test ARROWTYPES_TEST_POINTER_STRING_CALLS[] == length(stringvalues)
+
+    nothingvalues = Nothing[nothing, nothing, nothing]
+    nothingbytes =
+        arrowtypes_test_bytes((value=nothingvalues, row=Int32[1, 2, 3]); file=true)
+    nothingfiltered = Arrow.Table(
+        nothingbytes;
+        scan=Tables.Scan(
+            select=(:value, :row),
+            filter=Tables.colcmp(==, Tables.col(:value), nothing),
+        ),
+    )
+    @test nothingfiltered.value == nothingvalues
+    @test eltype(nothingfiltered.value) === Nothing
+    @test nothingfiltered.row == Int32[1, 2, 3]
+
+    nullfiltered = Arrow.Table(
+        nothingbytes;
+        scan=Tables.Scan(select=(:value, :row), filter=Tables.isnull(Tables.col(:value))),
+    )
+    @test Tables.rowcount(nullfiltered) == 0
+    @test isempty(nullfiltered.value)
+    @test eltype(nullfiltered.value) === Nothing
+
+    notnullfiltered = Arrow.Table(
+        nothingbytes;
+        scan=Tables.Scan(
+            select=(:value, :row),
+            filter=(!Tables.isnull(Tables.col(:value))),
+        ),
+    )
+    @test notnullfiltered.value == nothingvalues
+    @test eltype(notnullfiltered.value) === Nothing
+    @test notnullfiltered.row == Int32[1, 2, 3]
+end
diff --git a/test/arrowtypes_fixedlist_alloc_child.jl b/test/arrowtypes_fixedlist_alloc_child.jl
new file mode 100644
index 00000000..ee8fa113
--- /dev/null
+++ b/test/arrowtypes_fixedlist_alloc_child.jl
@@ -0,0 +1,414 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Keep the allocation assertions in a small process. The full ArrowTypes suite
+# deliberately creates many heap-backed regions; finalizer work from unrelated
+# cases would make a process-global allocation counter measure the wrong seam.
+
+using Arrow
+using ArrowTypes
+using Test
+
+const AC = Arrow.ArrowCore
+
+struct FixedListAllocID
+    value::Int32
+end
+
+const FIXED_LIST_ALLOC_NAME = Symbol("JuliaLang.ArrowTests.FixedListAllocID")
+const FIXED_LIST_ALLOC_CALLS = Ref(0)
+
+ArrowTypes.ArrowType(::Type{FixedListAllocID}) = Int32
+function ArrowTypes.toarrow(value::FixedListAllocID)
+    FIXED_LIST_ALLOC_CALLS[] += 1
+    return value.value
+end
+ArrowTypes.arrowname(::Type{FixedListAllocID}) = FIXED_LIST_ALLOC_NAME
+ArrowTypes.JuliaType(::Val{FIXED_LIST_ALLOC_NAME}, storage, metadata) = FixedListAllocID
+ArrowTypes.fromarrow(::Type{FixedListAllocID}, value::Int32) = FixedListAllocID(value)
+
+struct FixedListAllocValue{T}
+    value::T
+end
+
+const FIXED_LIST_ALLOC_BOOL_NAME = Symbol("JuliaLang.ArrowTests.FixedListAllocBool")
+const FIXED_LIST_ALLOC_INT_NAME = Symbol("JuliaLang.ArrowTests.FixedListAllocInt")
+const FIXED_LIST_ALLOC_STRING_NAME = Symbol("JuliaLang.ArrowTests.FixedListAllocString")
+const FIXED_LIST_ALLOC_VALUE_CALLS = Ref(0)
+
+ArrowTypes.ArrowType(::Type{FixedListAllocValue{T}}) where {T} = T
+function ArrowTypes.toarrow(value::FixedListAllocValue)
+    FIXED_LIST_ALLOC_VALUE_CALLS[] += 1
+    return value.value
+end
+ArrowTypes.arrowname(::Type{FixedListAllocValue{Bool}}) = FIXED_LIST_ALLOC_BOOL_NAME
+ArrowTypes.arrowname(::Type{FixedListAllocValue{Int64}}) = FIXED_LIST_ALLOC_INT_NAME
+ArrowTypes.arrowname(::Type{FixedListAllocValue{String}}) = FIXED_LIST_ALLOC_STRING_NAME
+ArrowTypes.JuliaType(::Val{FIXED_LIST_ALLOC_BOOL_NAME}, storage, metadata) =
+    FixedListAllocValue{Bool}
+ArrowTypes.JuliaType(::Val{FIXED_LIST_ALLOC_INT_NAME}, storage, metadata) =
+    FixedListAllocValue{Int64}
+ArrowTypes.JuliaType(::Val{FIXED_LIST_ALLOC_STRING_NAME}, storage, metadata) =
+    FixedListAllocValue{String}
+ArrowTypes.fromarrow(::Type{FixedListAllocValue{T}}, value::T) where {T} =
+    FixedListAllocValue{T}(value)
+
+struct FixedListAllocUnion
+    value::Union{Vector{Int64},String}
+end
+
+const FIXED_LIST_ALLOC_UNION_NAME = Symbol("JuliaLang.ArrowTests.FixedListAllocUnion")
+
+ArrowTypes.ArrowType(::Type{FixedListAllocUnion}) = Union{Vector{Int64},String}
+ArrowTypes.toarrow(value::FixedListAllocUnion) = value.value
+ArrowTypes.arrowname(::Type{FixedListAllocUnion}) = FIXED_LIST_ALLOC_UNION_NAME
+ArrowTypes.JuliaType(::Val{FIXED_LIST_ALLOC_UNION_NAME}, storage, metadata) =
+    FixedListAllocUnion
+ArrowTypes.fromarrow(::Type{FixedListAllocUnion}, value::AbstractVector) =
+    FixedListAllocUnion(Int64[value...])
+ArrowTypes.fromarrow(::Type{FixedListAllocUnion}, value::AbstractString) =
+    FixedListAllocUnion(String(value))
+
+extensionmetadata() = Pair{String,String}[
+    "ARROW:extension:name" => String(FIXED_LIST_ALLOC_NAME),
+    "ARROW:extension:metadata" => "",
+]
+
+function registeredhidden(listsize::Int, missingrows::Int)
+    child =
+        AC.Field("item", AC.IntType(32, true); nullable=false, metadata=extensionmetadata())
+    field =
+        AC.Field("value", AC.FixedSizeListType(listsize); nullable=true, children=[child])
+    T = Union{Missing,Vector{FixedListAllocID}}
+    values = T[FixedListAllocID.(Int32.(1:listsize))]
+    append!(values, fill(missing, missingrows))
+
+    FIXED_LIST_ALLOC_CALLS[] = 0
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    FIXED_LIST_ALLOC_CALLS[] == listsize || error("hidden slots called toarrow")
+    length(only(rebuiltdata.children)) == (missingrows + 1) * listsize ||
+        error("fixed-list child length changed")
+    return nothing
+end
+
+allocsample(::Type{Bool}) = true
+allocsample(::Type{Int64}) = Int64(7)
+allocsample(::Type{String}) = "x"
+
+function fixedlistallocfield(::Type{S}, nullable::Bool; registered::Bool) where {S}
+    sample = allocsample(S)
+    probe = nullable ? Union{Missing,S}[sample] : S[sample]
+    field, _ = AC.fromjulia("item", probe)
+    registered || return field
+    name = ArrowTypes.arrowname(FixedListAllocValue{S})
+    return AC.Field(
+        field.name,
+        field.type;
+        nullable=field.nullable,
+        metadata=Pair{String,String}[
+            "ARROW:extension:name" => String(name),
+            "ARROW:extension:metadata" => "",
+        ],
+        children=collect(AC.Field, field.children),
+    )
+end
+
+function maskedleafallocation(
+    ::Type{S},
+    listsize::Int,
+    missingrows::Int;
+    nullable::Bool,
+    registered::Bool,
+) where {S}
+    child = fixedlistallocfield(S, nullable; registered)
+    field =
+        AC.Field("value", AC.FixedSizeListType(listsize); nullable=true, children=[child])
+    sample = allocsample(S)
+    if registered
+        L = FixedListAllocValue{S}
+        values = Union{Missing,Vector{L}}[fill(L(sample), listsize)]
+    else
+        E = nullable ? Union{Missing,S} : S
+        values = Union{Missing,Vector{E}}[fill(convert(E, sample), listsize)]
+    end
+    append!(values, fill(missing, missingrows))
+
+    FIXED_LIST_ALLOC_VALUE_CALLS[] = 0
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    childfield = only(rebuiltfield.children)
+    childdata = only(rebuiltdata.children)
+    registered &&
+        FIXED_LIST_ALLOC_VALUE_CALLS[] != listsize &&
+        error("hidden slots called toarrow")
+    length(childdata) == (missingrows + 1) * listsize ||
+        error("fixed-list child length changed")
+    firstvalue = AC.getvalue(childfield, childdata, Int64(1))
+    firstvalue == sample || error("visible payload changed")
+    if nullable && missingrows > 0
+        AC.getvalue(childfield, childdata, Int64(listsize + 1)) === missing ||
+            error("hidden nullable child slot became valid")
+    end
+    return nothing
+end
+
+# Least of three warm readings, each after a full collection. `@allocated`
+# counts each big block's usable size; the parent test runs this file with
+# MallocLargeCache=0 so macOS malloc does not hand a request a larger cached
+# region (counted as up to twice the request). A real extra allocation shows
+# in every reading.
+function leastallocated(f)
+    least = typemax(Int)
+    for _ = 1:3
+        GC.gc()
+        least = min(least, @allocated f())
+    end
+    return least
+end
+
+function allocationguard(
+    ::Type{S};
+    nullable::Bool,
+    registered::Bool,
+    listsize::Int=50_000,
+) where {S}
+    maskedleafallocation(S, 2, 1; nullable, registered)
+    maskedleafallocation(S, listsize, 1; nullable, registered)
+    maskedleafallocation(S, listsize, 49; nullable, registered)
+    few = leastallocated(() -> maskedleafallocation(S, listsize, 1; nullable, registered))
+    many = leastallocated(() -> maskedleafallocation(S, listsize, 49; nullable, registered))
+    slots = 48 * listsize
+    physicaldelta = if S === Bool
+        (nullable ? 2 : 1) * cld(slots, 8)
+    elseif S === String
+        # A registered string leaf lowers to a vector of its slots, one
+        # pointer each, before its offsets are built.
+        (registered ? 12 : 4) * slots + (nullable ? cld(slots, 8) : 0)
+    else
+        sizeof(S) * slots + (nullable ? cld(slots, 8) : 0)
+    end
+    @test many <= few + (7 * physicaldelta) ÷ 4 + 1_000_000
+end
+
+function allocationdelta(f, small::Int, large::Int, allowance::Int)
+    f(2)
+    f(small)
+    f(large)
+    smallallocation = leastallocated(() -> f(small))
+    largeallocation = leastallocated(() -> f(large))
+    @test largeallocation <= smallallocation + allowance
+    return nothing
+end
+
+function emptyunion(listsize::Int)
+    itemfield, itemdata = AC.fromjulia("item", Int64[])
+    fixedtype = AC.FixedSizeListType(listsize)
+    fixedfield = AC.Field("huge", fixedtype; nullable=false, children=[itemfield])
+    fixeddata =
+        AC.ArrayData(fixedtype, 0, [AC.BufferSlice()]; children=[itemdata], nullcount=0)
+    textfield, textdata = AC.fromjulia("text", String[])
+    uniontype = AC.UnionType(AC.SparseMode, Int8[42, 17])
+    field = AC.Field(
+        "value",
+        uniontype;
+        nullable=false,
+        metadata=Pair{String,String}[
+            "ARROW:extension:name" => String(FIXED_LIST_ALLOC_UNION_NAME),
+            "ARROW:extension:metadata" => "",
+        ],
+        children=[fixedfield, textfield],
+    )
+    data = AC.ArrayData(
+        uniontype,
+        0,
+        [AC._databuffer(Int8[])];
+        children=[fixeddata, textdata],
+        nullcount=0,
+    )
+    return field, data
+end
+
+function readempty(listsize::Int)
+    field, data = emptyunion(listsize)
+    schema = AC.Schema([field])
+    batch = AC.RecordBatch(schema, [data], 0)
+    isempty(Arrow.Table(Arrow.writestream(schema, [batch])).value) ||
+        error("empty Union materialized a row")
+    return nothing
+end
+
+function directmissing(listsize::Int)
+    child = AC.Field("item", AC.NullType(); nullable=true)
+    fixedtype = AC.FixedSizeListType(listsize)
+    field = AC.Field("value", fixedtype; nullable=true, children=[child])
+    values = Union{Missing,Vector{Missing}}[missing]
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    return nothing
+end
+
+function directmixed(listsize::Int)
+    child = AC.Field("item", AC.NullType(); nullable=true)
+    fixedtype = AC.FixedSizeListType(listsize)
+    field = AC.Field("value", fixedtype; nullable=true, children=[child])
+    values = Union{Missing,Vector{Missing}}[fill(missing, listsize)]
+    append!(values, fill(missing, 49))
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    return nothing
+end
+
+function freshmixed(listsize::Int)
+    values = Union{Missing,Vector{Missing}}[fill(missing, listsize)]
+    append!(values, fill(missing, 49))
+    kind = ArrowTypes.FixedSizeListKind{listsize,Missing}()
+    rebuiltfield, rebuiltdata = Arrow._fixedlistpart(
+        "value",
+        values,
+        Arrow._WriterContext("value"),
+        ArrowTypes.getsize(kind),
+    )
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    return nothing
+end
+
+function nullsparsefield(listsize::Int)
+    child = AC.Field("item", AC.NullType(); nullable=true)
+    fixed =
+        AC.Field("fixed", AC.FixedSizeListType(listsize); nullable=false, children=[child])
+    text = AC.Field("text", AC.Utf8Type(false); nullable=false)
+    uniontype = AC.UnionType(AC.SparseMode, Int8[42, 17])
+    return AC.Field("value", uniontype; nullable=false, children=[fixed, text])
+end
+
+function inactivesparse(listsize::Int)
+    field = nullsparsefield(listsize)
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(field, Any["text"]; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    schema = AC.Schema([rebuiltfield])
+    batch = AC.RecordBatch(schema, [rebuiltdata], 1)
+    Arrow.Table(Arrow.writestream(schema, [batch])).value == ["text"] ||
+        error("inactive sparse fixed-list child changed the visible value")
+    return nothing
+end
+
+function mixedsparse(listsize::Int)
+    field = nullsparsefield(listsize)
+    values = Any[fill(missing, listsize)]
+    append!(values, ("text" for _ = 1:49))
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    return nothing
+end
+
+function generalhidden(listsize::Int)
+    child = AC.Field("item", AC.IntType(64, true); nullable=false)
+    field =
+        AC.Field("value", AC.FixedSizeListType(listsize); nullable=true, children=[child])
+    values = Any[collect(Int64, 1:listsize)]
+    append!(values, fill(missing, 49))
+    rebuiltfield, rebuiltdata =
+        Arrow._constructpart(field, values; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    childdata = only(rebuiltdata.children)
+    length(childdata) == 50 * listsize || error("fixed-list child length changed")
+    AC.getvalue(child, childdata, Int64(1)) == 1 || error("visible payload changed")
+    !AC.isvalid_at(rebuiltdata, Int64(2)) || error("missing parent became valid")
+    return nothing
+end
+
+function freshnative(listsize::Int)
+    values = Union{Missing,Vector{Int64}}[collect(Int64, 1:listsize)]
+    append!(values, fill(missing, 49))
+    kind = ArrowTypes.FixedSizeListKind{listsize,Int64}()
+    rebuiltfield, rebuiltdata = Arrow._fixedlistpart(
+        "value",
+        values,
+        Arrow._WriterContext("value"),
+        ArrowTypes.getsize(kind),
+    )
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    childfield = only(rebuiltfield.children)
+    childdata = only(rebuiltdata.children)
+    length(childdata) == 50 * listsize || error("fixed-list child length changed")
+    AC.getvalue(childfield, childdata, Int64(1)) == 1 || error("visible payload changed")
+    return nothing
+end
+
+function freshbool(listsize::Int)
+    values = Union{Missing,Vector{Bool}}[Bool[isodd(index) for index = 1:listsize],]
+    append!(values, fill(missing, 49))
+    kind = ArrowTypes.FixedSizeListKind{listsize,Bool}()
+    rebuiltfield, rebuiltdata = Arrow._fixedlistpart(
+        "value",
+        values,
+        Arrow._WriterContext("value"),
+        ArrowTypes.getsize(kind),
+    )
+    AC.validate_full(rebuiltfield, rebuiltdata)
+    childfield = only(rebuiltfield.children)
+    childdata = only(rebuiltdata.children)
+    length(childdata) == 50 * listsize || error("fixed-list child length changed")
+    AC.getvalue(childfield, childdata, Int64(1)) || error("visible payload changed")
+    !AC.getvalue(childfield, childdata, Int64(2)) || error("visible payload changed")
+    return nothing
+end
+
+@testset "hidden fixed-list allocation" begin
+    listsize = 50_000
+    registeredhidden(2, 1)
+    registeredhidden(listsize, 1)
+    registeredhidden(listsize, 49)
+
+    few = leastallocated(() -> registeredhidden(listsize, 1))
+    many = leastallocated(() -> registeredhidden(listsize, 49))
+    physicaldelta = 48 * sizeof(Int32) * listsize
+    @test many <= few + (7 * physicaldelta) ÷ 4 + 1_000_000
+
+    allocationguard(Int64; nullable=false, registered=false, listsize=20_000)
+    for registered in (false, true)
+        allocationguard(Bool; nullable=false, registered)
+        allocationguard(Bool; nullable=true, registered)
+        allocationguard(Int64; nullable=true, registered, listsize=20_000)
+        allocationguard(String; nullable=true, registered, listsize=20_000)
+    end
+
+    allocationdelta(readempty, 1_000, 100_000, 250_000)
+    allocationdelta(directmissing, 1_000, 100_000, 250_000)
+    allocationdelta(directmixed, 1_000, 20_000, 250_000)
+    allocationdelta(freshmixed, 1_000, 20_000, 750_000)
+    allocationdelta(inactivesparse, 1_000, 100_000, 250_000)
+    allocationdelta(mixedsparse, 1_000, 20_000, 250_000)
+
+    physicaldelta = 50 * sizeof(Int64) * (50_000 - 1_000)
+    listallowance = (7 * physicaldelta) ÷ 4 + 1_000_000
+    allocationdelta(generalhidden, 1_000, 50_000, listallowance)
+    allocationdelta(freshnative, 1_000, 50_000, listallowance)
+
+    boolphysicaldelta = cld(50 * 100_000, 8) - cld(50 * 1_000, 8)
+    boolallowance = (7 * boolphysicaldelta) ÷ 4 + 1_000_000
+    allocationdelta(freshbool, 1_000, 100_000, boolallowance)
+end
+
+println("ArrowTypes fixed-list allocation guard passed")
diff --git a/test/arrowtypes_storage_guard_child.jl b/test/arrowtypes_storage_guard_child.jl
new file mode 100644
index 00000000..7fe3e0e5
--- /dev/null
+++ b/test/arrowtypes_storage_guard_child.jl
@@ -0,0 +1,42 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+using Arrow
+using ArrowTypes
+
+struct ArrowTypesStorageGuardValue{N}
+    value::Int8
+end
+
+ArrowTypes.ArrowType(::Type{ArrowTypesStorageGuardValue{N}}) where {N} = NTuple{N,Int8}
+ArrowTypes.toarrow(x::ArrowTypesStorageGuardValue{N}) where {N} =
+    ntuple(_ -> x.value, Val(N))
+
+T = ArrowTypesStorageGuardValue{2048}
+input = Union{Missing,T}[missing]
+io = IOBuffer()
+err = try
+    Arrow.write(io, (value=input,); file=false)
+    nothing
+catch e
+    e
+end
+err isa ArgumentError || error("oversized ArrowType result did not fail with ArgumentError")
+message = sprint(showerror, err)
+occursin("concrete Tuple with 2048 fields", message) || error(message)
+occursin("supported limit is 1024", message) || error(message)
+println("oversized ArrowType storage rejected")
diff --git a/test/arrowtypes_struct_alloc_child.jl b/test/arrowtypes_struct_alloc_child.jl
new file mode 100644
index 00000000..5f0da9b0
--- /dev/null
+++ b/test/arrowtypes_struct_alloc_child.jl
@@ -0,0 +1,190 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Keep the allocation assertions in a small process. The full ArrowTypes suite
+# deliberately creates many heap-backed regions; finalizer work from unrelated
+# cases would make a process-global allocation counter measure the wrong seam.
+
+using Arrow
+using ArrowTypes
+using Test
+
+const AC = Arrow.ArrowCore
+const STRUCT_ALLOC_WIDTH = 16
+const STRUCT_ALLOC_NAMES = ntuple(i -> Symbol("child_$i"), STRUCT_ALLOC_WIDTH)
+
+struct StructAllocID
+    value::Int32
+end
+
+const STRUCT_ALLOC_ID_NAME = Symbol("JuliaLang.ArrowTests.StructAllocID")
+const STRUCT_ALLOC_LOWER_CALLS = Ref(0)
+
+ArrowTypes.ArrowType(::Type{StructAllocID}) = Int32
+function ArrowTypes.toarrow(value::StructAllocID)
+    STRUCT_ALLOC_LOWER_CALLS[] += 1
+    return value.value
+end
+ArrowTypes.arrowname(::Type{StructAllocID}) = STRUCT_ALLOC_ID_NAME
+ArrowTypes.JuliaType(::Val{STRUCT_ALLOC_ID_NAME}, storage, metadata) = StructAllocID
+ArrowTypes.fromarrow(::Type{StructAllocID}, value::Int32) = StructAllocID(value)
+
+const StructAllocFreshRow =
+    NamedTuple{STRUCT_ALLOC_NAMES,NTuple{STRUCT_ALLOC_WIDTH,StructAllocID}}
+const StructAllocRetainedRow = Vector{Pair{String,Any}}
+
+function freshrows(n::Int)
+    rows = Vector{Union{Missing,StructAllocFreshRow}}(undef, n)
+    for i = 1:n
+        rows[i] =
+            i == 1 ?
+            StructAllocFreshRow(
+                ntuple(j -> StructAllocID(Int32(i + j)), STRUCT_ALLOC_WIDTH),
+            ) : missing
+    end
+    return rows
+end
+
+function constructfresh(rows)
+    STRUCT_ALLOC_LOWER_CALLS[] = 0
+    field, data = Arrow._structpart("value", rows, Arrow._WriterContext("value"))
+    AC.validate_full(field, data)
+    visible = count(!ismissing, rows)
+    STRUCT_ALLOC_LOWER_CALLS[] == STRUCT_ALLOC_WIDTH * visible ||
+        error("fresh Struct child lowering did not run exactly once")
+    length(data.children) == STRUCT_ALLOC_WIDTH || error("fresh Struct width changed")
+    all(child -> length(child) == length(rows), data.children) ||
+        error("fresh Struct child length changed")
+    return nothing
+end
+
+function retainedfield(; marked::Bool=false)
+    metadata =
+        marked ?
+        Pair{String,String}[
+            "ARROW:extension:name" => String(STRUCT_ALLOC_ID_NAME),
+            "ARROW:extension:metadata" => "",
+        ] : nothing
+    children = AC.Field[
+        AC.Field(
+            "child_$i",
+            marked ? AC.IntType(32, true) : AC.IntType(64, true);
+            nullable=false,
+            metadata,
+        ) for i = 1:STRUCT_ALLOC_WIDTH
+    ]
+    return AC.Field("value", AC.StructType(); nullable=true, children)
+end
+
+function retainedrows(n::Int; allnull::Bool)
+    rows = Vector{Union{Missing,StructAllocRetainedRow}}(undef, n)
+    for i = 1:n
+        rows[i] =
+            allnull || i % 4 != 0 ? missing :
+            Pair{String,Any}["child_$j" => Int64(i + j) for j = 1:STRUCT_ALLOC_WIDTH]
+    end
+    return rows
+end
+
+function registeredretainedrows(n::Int)
+    rows = Vector{Union{Missing,StructAllocRetainedRow}}(undef, n)
+    for i = 1:n
+        rows[i] =
+            i % 4 == 0 ?
+            Pair{String,Any}[
+                "child_$j" => StructAllocID(Int32(i + j)) for j = 1:STRUCT_ALLOC_WIDTH
+            ] : missing
+    end
+    return rows
+end
+
+function constructretained(field, rows)
+    rebuiltfield, data =
+        Arrow._constructpart(field, rows; context=Arrow._WriterContext("value"))
+    AC.validate_full(rebuiltfield, data)
+    length(data.children) == STRUCT_ALLOC_WIDTH || error("retained Struct width changed")
+    all(child -> length(child) == length(rows), data.children) ||
+        error("retained Struct child length changed")
+    return nothing
+end
+
+# Least of three warm readings, each after a full collection. `@allocated`
+# counts each big block's usable size; the parent test runs this file with
+# MallocLargeCache=0 so macOS malloc does not hand a request a larger cached
+# region (counted as up to twice the request). A real extra allocation shows
+# in every reading.
+function leastallocated(f)
+    least = typemax(Int)
+    for _ = 1:3
+        GC.gc()
+        least = min(least, @allocated f())
+    end
+    return least
+end
+
+function allocationdelta(f, small, large, physicaldelta::Int)
+    f(small)
+    f(large)
+    smallallocation = leastallocated(() -> f(small))
+    largeallocation = leastallocated(() -> f(large))
+    @test largeallocation <= smallallocation + (7 * physicaldelta) ÷ 4 + 1_000_000
+end
+
+@testset "Struct child projection allocation" begin
+    smalln = 2_000
+    largen = 50_000
+    freshsmall = freshrows(smalln)
+    freshlarge = freshrows(largen)
+    freshphysicaldelta =
+        STRUCT_ALLOC_WIDTH * sizeof(Int32) * (largen - smalln) + cld(largen - smalln, 8)
+    allocationdelta(constructfresh, freshsmall, freshlarge, freshphysicaldelta)
+
+    field = retainedfield()
+    retainedsmall = retainedrows(smalln; allnull=true)
+    retainedlarge = retainedrows(largen; allnull=true)
+    retainedphysicaldelta =
+        STRUCT_ALLOC_WIDTH * sizeof(Int64) * (largen - smalln) + cld(largen - smalln, 8)
+    allocationdelta(
+        rows -> constructretained(field, rows),
+        retainedsmall,
+        retainedlarge,
+        retainedphysicaldelta,
+    )
+
+    mixed = retainedrows(8; allnull=false)
+    constructretained(field, mixed)
+
+    registeredrows = registeredretainedrows(8)
+    STRUCT_ALLOC_LOWER_CALLS[] = 0
+    constructretained(retainedfield(; marked=true), registeredrows)
+    @test STRUCT_ALLOC_LOWER_CALLS[] ==
+          STRUCT_ALLOC_WIDTH * count(!ismissing, registeredrows)
+
+    wrongname = copy(mixed)
+    wrongname[4] = copy(wrongname[4])
+    wrongname[4][7] = "wrong" => last(wrongname[4][7])
+    err = try
+        constructretained(field, wrongname)
+        nothing
+    catch e
+        e
+    end
+    @test err isa ArgumentError
+    @test occursin("retained struct child 7 is named", sprint(showerror, err))
+end
+
+println("ArrowTypes Struct allocation guard passed")
diff --git a/test/arrowtypes_symbol_guard_child.jl b/test/arrowtypes_symbol_guard_child.jl
new file mode 100644
index 00000000..e85ef4f2
--- /dev/null
+++ b/test/arrowtypes_symbol_guard_child.jl
@@ -0,0 +1,327 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Run these checks in a fresh Julia process. Symbol interning is permanent for
+# the process, so an in-process test could pass or fail because of an earlier
+# test's global state instead of the Arrow read under test.
+
+using Arrow
+using ArrowTypes
+using Logging
+using Tables
+using Test
+
+const AC = Arrow.ArrowCore
+const REGISTERED_STRUCT_NAME = Symbol("JuliaLang.ArrowTests.SymbolGuardStruct")
+
+struct SymbolGuardStruct end
+
+ArrowTypes.JuliaType(::Val{REGISTERED_STRUCT_NAME}, storage, metadata) = SymbolGuardStruct
+
+const UNIQUE_SUFFIX = string(getpid(), "_", time_ns())
+
+freshname(prefix::AbstractString) = string(prefix, "_", UNIQUE_SUFFIX)
+
+# Compiling an exception handler lazily interns Julia IR symbols (:phic and
+# friends), and "phic" is a four-letter lowercase name this guard generates.
+# Intern them NOW, so the generated-name scans below measure what Arrow
+# interns — not what the compiler happened to compile first.
+try
+    error("intern the exception-handler IR symbols")
+catch
+end
+
+function isinterned(name::String)
+    occursin('\0', name) && error("the Symbol guard only accepts NUL-free names")
+    pointer = GC.@preserve name begin
+        ccall(:jl_symbol_lookup, Ptr{Cvoid}, (Cstring,), name)
+    end
+    return pointer != C_NULL
+end
+
+function ipcone(field::AC.Field, data::AC.ArrayData; file::Bool)
+    schema = AC.Schema([field])
+    batch = AC.RecordBatch(schema, [data], data.len)
+    return file ? Arrow.writefile(schema, [batch]) : Arrow.writestream(schema, [batch])
+end
+
+extensionmetadata(name::AbstractString) = Pair{String,String}[
+    "ARROW:extension:name" => String(name),
+    "ARROW:extension:metadata" => "",
+]
+
+@testset "ArrowTypes untrusted Symbol guard" begin
+    unknown = freshname("JuliaLang.ArrowTests.UnknownSymbolGuard")
+    @test !isinterned(unknown)
+    _, unknowndata = AC.fromjulia("value", Int64[7])
+    unknownfield = AC.Field(
+        "value",
+        AC.IntType(64, true);
+        nullable=false,
+        metadata=extensionmetadata(unknown),
+    )
+    for file in (false, true)
+        empty!(Arrow._WARNED_EXTENSIONS)
+        table = @test_logs (:warn, r"unsupported ARROW:extension:name") Arrow.Table(
+            ipcone(unknownfield, unknowndata; file),
+        )
+        @test table.value == Int64[7]
+        @test !isinterned(unknown)
+    end
+    # The warning is once per process for each extension name.
+    table = @test_logs min_level = Logging.Warn Arrow.Table(
+        ipcone(unknownfield, unknowndata; file=true),
+    )
+    @test table.value == Int64[7]
+
+    childname = freshname("untrusted_struct_child")
+    @test !isinterned(childname)
+    childfield, childdata = AC.fromjulia(childname, Int64[8])
+    structtype = AC.StructType()
+    structfield = AC.Field(
+        "value",
+        structtype;
+        nullable=false,
+        metadata=extensionmetadata(String(REGISTERED_STRUCT_NAME)),
+        children=[childfield],
+    )
+    structdata =
+        AC.ArrayData(structtype, 1, [AC.BufferSlice()]; children=[childdata], nullcount=0)
+    for file in (false, true)
+        empty!(Arrow._WARNED_EXTENSIONS)
+        table = @test_logs (:warn, r"unsupported ARROW:extension:name") Arrow.Table(
+            ipcone(structfield, structdata; file),
+        )
+        @test table.value == [Pair{String,Any}[childname => Int64(8)]]
+        @test !isinterned(childname)
+    end
+
+    payload = freshname("untrusted_symbol_payload")
+    @test !isinterned(payload)
+    payloadfield, payloaddata = AC.fromjulia("value", String[payload])
+    symbolfield = AC.Field(
+        payloadfield.name,
+        payloadfield.type;
+        nullable=false,
+        metadata=extensionmetadata("JuliaLang.Symbol"),
+    )
+    # A read creates new Symbol values, up to `Limits.max_new_symbols`.
+    @test Arrow.Table(ipcone(symbolfield, payloaddata; file=false)).value ==
+          [Symbol(payload)]
+    @test isinterned(payload)
+    symbolcolumn(name, values) = begin
+        f, d = AC.fromjulia(name, values)
+        f = AC.Field(
+            f.name,
+            f.type;
+            nullable=false,
+            metadata=extensionmetadata("JuliaLang.Symbol"),
+        )
+        return f, d
+    end
+    novel = [freshname("untrusted_symbol_payload_$i") for i = 1:5]
+    @test !any(isinterned, novel)
+    # Repeated values count once.
+    manyfield, manydata = symbolcolumn("value", vcat(novel, novel))
+    manybytes = ipcone(manyfield, manydata; file=true)
+    # A column needing more is refused before any of its values becomes a
+    # Symbol, so the same read is refused every time.
+    for _ = 1:2
+        err = try
+            Arrow.Table(manybytes; limits=Arrow.Limits(max_new_symbols=4))
+            nothing
+        catch exception
+            exception
+        end
+        @test err isa Arrow.ValidationError
+        msg = sprint(showerror, err)
+        @test occursin("column value holds more than 4 Symbol values", msg)
+        @test occursin("limits=Arrow.Limits(max_new_symbols=...)", msg)
+        @test occursin("select=[:value => String]", msg)
+        @test !any(isinterned, novel)
+    end
+    # `=> String` reads the stored strings without creating Symbols.
+    for kw in
+        ((; select=[:value => String]), (; scan=Tables.Scan(select=[:value => String])))
+        strings = Arrow.Table(manybytes; kw..., limits=Arrow.Limits(max_new_symbols=0))
+        @test strings.value == vcat(novel, novel)
+        @test eltype(strings.value) == String
+        for b in Arrow.Stream(manybytes; kw...)
+            @test b.value == vcat(novel, novel)
+        end
+    end
+    @test !any(isinterned, novel)
+    # A filter on the column compares Symbols, so it creates them even when the
+    # column is read as strings, and a column needing too many is refused.
+    hit = Symbol(novel[2])
+    onvalue = (; select=[:value => String], filter=Arrow.colcmp(==, Arrow.col(:value), hit))
+    @test_throws Arrow.ValidationError Arrow.Table(
+        manybytes;
+        onvalue...,
+        limits=Arrow.Limits(max_new_symbols=3),
+    )
+    @test !any(isinterned, novel[[1, 3, 4, 5]])
+    strings = Arrow.Table(manybytes; onvalue..., limits=Arrow.Limits(max_new_symbols=4))
+    @test strings.value == [novel[2], novel[2]] && eltype(strings.value) == String
+    # An Arrow.Stream counts each record batch on its own.
+    streamnames = [freshname("untrusted_stream_symbol_$i") for i = 1:6]
+    halves = (streamnames[1:3], streamnames[4:6])
+    schema = AC.Schema([first(symbolcolumn("value", halves[1]))])
+    batches = [AC.RecordBatch(schema, [last(symbolcolumn("value", h))], 3) for h in halves]
+    for streambytes in
+        (Arrow.writestream(schema, batches), Arrow.writefile(schema, batches))
+        @test_throws Arrow.ValidationError Arrow.Table(
+            streambytes;
+            limits=Arrow.Limits(max_new_symbols=4),
+        )
+        @test !any(isinterned, streamnames)
+    end
+    got = [
+        b.value for b in Arrow.Stream(
+            Arrow.writestream(schema, batches);
+            limits=Arrow.Limits(max_new_symbols=4),
+        )
+    ]
+    @test got == [Symbol.(h) for h in halves]
+    @test Arrow.Table(manybytes; limits=Arrow.Limits(max_new_symbols=5)).value ==
+          Symbol.(vcat(novel, novel))
+
+    streamname = freshname("untrusted_stream_field")
+    @test !isinterned(streamname)
+    streamfield, streamdata = AC.fromjulia(streamname, Int64[9])
+    streambytes = ipcone(streamfield, streamdata; file=false)
+    Arrow.readstream(streambytes)
+    @test !isinterned(streamname)
+    Arrow.Table(streambytes)
+    @test isinterned(streamname)
+
+    filename = freshname("untrusted_file_field")
+    @test !isinterned(filename)
+    filefield, filedata = AC.fromjulia(filename, Int64[10])
+    filebytes = ipcone(filefield, filedata; file=true)
+    Arrow.readfile(filebytes)
+    @test !isinterned(filename)
+    Arrow.Table(filebytes)
+    @test isinterned(filename)
+
+    # Four ASCII letters provide enough distinct four-byte names to reach the
+    # count gate while staying below the independent 1 MiB byte budget. Skip
+    # the small set that Julia or a loaded dependency already interned.
+    #
+    # Generated names race the JIT: compiling code at runtime interns the
+    # symbols of the freshly lowered methods (IR heads like :phic, Base local
+    # names like :imid), and any of them can collide with a four-letter name.
+    # Warm every code path this check uses FIRST, then filter immediately
+    # before the guarded call, so the assertions measure what Arrow interns
+    # rather than what the compiler compiled in between.
+    internedof(names) = String[n for n in names if isinterned(n)]
+    guarderr(fields) =
+        try
+            Arrow._fieldnamesymbols(fields)
+            nothing
+        catch exception
+            exception
+        end
+    warmfield = AC.Field(freshname("warm_count_gate"), AC.NullType(); nullable=true)
+    guarderr(AC.Field[warmfield])
+    countnames = String[]
+    candidate = 0
+    while length(countnames) <= Arrow._MAX_TABLES_NEW_FIELD_NAMES + 64
+        value = candidate
+        bytes = Vector{UInt8}(undef, 4)
+        for index = 1:4
+            bytes[index] = UInt8('a') + UInt8(value % 26)
+            value ÷= 26
+        end
+        name = String(bytes)
+        isinterned(name) || push!(countnames, name)
+        candidate += 1
+    end
+    internedof(countnames)
+    countfields =
+        AC.Field[AC.Field(name, AC.NullType(); nullable=true) for name in countnames]
+    filter!(f -> !isinterned(f.name), countfields)
+    @test length(countfields) > Arrow._MAX_TABLES_NEW_FIELD_NAMES
+    resize!(countfields, Arrow._MAX_TABLES_NEW_FIELD_NAMES + 1)
+    countnames = String[f.name for f in countfields]
+    counterr = guarderr(countfields)
+    stillnovel = internedof(countnames)
+    @test isempty(stillnovel)
+    @test counterr isa Arrow.ValidationError
+    @test occursin("novel-name limit", sprint(showerror, counterr))
+
+    bytenames = String[]
+    for index =
+            1:(Arrow._MAX_TABLES_NEW_FIELD_NAME_BYTES ÷ Arrow._MAX_ARROWTYPE_SCHEMA_NAME_BYTES + 1)
+
+        base = freshname("untrusted_byte_field_$index")
+        push!(
+            bytenames,
+            base * repeat("x", Arrow._MAX_ARROWTYPE_SCHEMA_NAME_BYTES - ncodeunits(base)),
+        )
+    end
+    @test all(!isinterned, bytenames)
+    bytefields =
+        AC.Field[AC.Field(name, AC.NullType(); nullable=true) for name in bytenames]
+    byteerr = try
+        Arrow._fieldnamesymbols(bytefields)
+        nothing
+    catch exception
+        exception
+    end
+    @test byteerr isa Arrow.ValidationError
+    @test occursin("novel-name byte budget", sprint(showerror, byteerr))
+    @test all(!isinterned, bytenames)
+
+    warningnames = [freshname("unknown_warning_$index") for index = 1:20]
+    @test all(!isinterned, warningnames)
+    warningfields = AC.Field[]
+    warningcolumns = AC.ArrayData[]
+    for (index, name) in enumerate(warningnames)
+        _, data = AC.fromjulia("value", Int64[index])
+        push!(
+            warningfields,
+            AC.Field(
+                "value",
+                AC.IntType(64, true);
+                nullable=false,
+                metadata=extensionmetadata(name),
+            ),
+        )
+        push!(warningcolumns, data)
+    end
+    warningschema = AC.Schema(warningfields)
+    warningbatch = AC.RecordBatch(warningschema, warningcolumns, 1)
+    warningbytes = Arrow.writestream(warningschema, [warningbatch])
+    warningio = IOBuffer()
+    logger = SimpleLogger(warningio, Logging.Warn)
+    empty!(Arrow._WARNED_EXTENSIONS)
+    with_logger(logger) do
+        Arrow.Table(warningbytes)
+    end
+    warningtext = String(take!(warningio))
+    @test length(findall("unsupported ARROW:extension:name type", warningtext)) == 16
+    @test length(
+        findall(
+            "additional unsupported Arrow extension warnings were suppressed",
+            warningtext,
+        ),
+    ) == 1
+    @test all(!isinterned, warningnames)
+end
+
+println("ArrowTypes symbol guard passed")
diff --git a/test/batteries.jl b/test/batteries.jl
new file mode 100644
index 00000000..304a1cfb
--- /dev/null
+++ b/test/batteries.jl
@@ -0,0 +1,39 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The Test adapter owns only presentation. AcceptanceSupport owns the private
+# package dependencies, fixtures, runner order, and implementation.
+module Batteries
+
+using Test
+include(joinpath(@__DIR__, "support", "AcceptanceSupport.jl"))
+
+# The batteries signal failure by throwing; a testset that completes is the
+# pass.
+const ACCEPTANCE_SUITES = AcceptanceSupport.acceptance_suites()
+@assert map(first, ACCEPTANCE_SUITES) == (
+    "IPC read acceptance",
+    "IPC write acceptance",
+    "C data acceptance",
+    "Scan acceptance",
+)
+for (name, runner) in ACCEPTANCE_SUITES
+    @testset "$name" begin
+        runner()
+    end
+end
+
+end # module Batteries
diff --git a/test/battery_helpers.jl b/test/battery_helpers.jl
new file mode 100644
index 00000000..abfbbfc0
--- /dev/null
+++ b/test/battery_helpers.jl
@@ -0,0 +1,790 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ---------------------------------------------------------------------------
+# 2.x-written fixtures: bytes the OLD package wrote, frozen to disk so 3.0
+# keeps proving it reads what deployed 2.x writers produced. While 2.x is
+# still importable, ARROW_FIXTURE_MODE=record runs each site's closure (the
+# original 2.x write, kept inline as provenance) and snapshots its bytes;
+# the default replay mode never executes the closure — it reads the frozen
+# file, so the closures may reference APIs that no longer exist.
+# ---------------------------------------------------------------------------
+const FIXTURES2X_DIR = joinpath(@__DIR__, "fixtures2x")
+function _fixture2x(write2x::F, name::String) where {F}
+    path = joinpath(FIXTURES2X_DIR, name * ".arrowbytes")
+    if get(ENV, "ARROW_FIXTURE_MODE", "") == "record"
+        bytes = write2x()::Vector{UInt8}
+        mkpath(dirname(path))
+        write(path, bytes)
+        return bytes
+    end
+    isfile(path) || error(
+        "missing 2.x fixture $name — regenerate against " *
+        "a 2.x checkout with ARROW_FIXTURE_MODE=record",
+    )
+    return read(path)
+end
+
+# The mixed-layout table three batteries share, and its frozen 2.x-written
+# two-partition stream (two record batches plus dictionary batches).
+const MIXED_EXPECTED = (
+    ints=Int64[1, 2, 3, 4, 5],
+    floats=[1.5, missing, 3.5, missing, 5.5],
+    bools=[true, false, true, missing, false],
+    strs=["hey", "", missing, "αβ∀", "last"],
+    lists=[[1, 2], Int64[], [3], missing, [4, 5, 6]],
+    structs=[(a=1, b="x"), (a=2, b="y"), (a=3, b="z"), (a=4, b="w"), (a=5, b="v")],
+    dict=["lo", "hi", "lo", missing, "hi"],
+)
+function _mixed_two_partitions_bytes()
+    expected = MIXED_EXPECTED
+    return _fixture2x("mixed-two-partitions") do
+        io = IOBuffer()
+        writetable = merge(expected, (dict=Arrow.DictEncode(expected.dict),))
+        Arrow.write(io, Tables.partitioner([writetable, writetable]); file=false)
+        take!(io)
+    end
+end
+
+# Test-support helpers for exact, length-preserving metadata mutations. They
+# use the same checked parser as the verifier, so the adversarial cases do not
+# rely on generated unsafe getters to locate fields.
+function _writele!(bytes::Vector{UInt8}, pos::Int64, x::UInt64, width::Int)
+    _vrange(bytes, pos, width, "test mutation")
+    for i = 0:(width - 1)
+        bytes[pos + i + 1] = UInt8((x >> (8i)) & 0xff)
+    end
+    return bytes
+end
+_write_i64!(bytes, pos, x::Int64) = _writele!(bytes, pos, reinterpret(UInt64, x), 8)
+_write_i32!(bytes, pos, x::Int32) = _writele!(bytes, pos, UInt64(reinterpret(UInt32, x)), 4)
+_write_i16!(bytes, pos, x::Int16) = _writele!(bytes, pos, UInt64(reinterpret(UInt16, x)), 2)
+_write_u32!(bytes, pos, x::UInt32) = _writele!(bytes, pos, UInt64(x), 4)
+
+function _frameinfo(bytes::Vector{UInt8})
+    info = NamedTuple[]
+    pos = Int64(0)
+    while pos < length(bytes)
+        length(bytes) - pos >= 8 || throw(ValidationError("truncated test frame"))
+        _vu32(bytes, pos) == CONTINUATION || throw(ValidationError("bad test frame"))
+        metalen = Int64(_vi32(bytes, pos + 4))
+        if metalen == 0
+            push!(
+                info,
+                (kind=UInt8(0), frame=(pos + 1):(pos + 8), metadata=Int64(0):Int64(-1)),
+            )
+            break
+        end
+        metastart = pos + 8
+        meta = bytes[(metastart + 1):(metastart + metalen)]
+        _, kind, _, _ = verify_ipc_metadata(meta, Limits())
+        msg = _vtable(meta, Int64(_vu32(meta, 0)))
+        bp = _vfield(msg, 3, 8)
+        bodylen = bp === nothing ? Int64(0) : _vi64(meta, bp)
+        frameend = AC.checked_add(AC.checked_add(metastart, metalen), bodylen)
+        push!(
+            info,
+            (
+                kind=kind,
+                frame=(pos + 1):frameend,
+                metadata=(metastart + 1):(metastart + metalen),
+            ),
+        )
+        pos = frameend
+    end
+    return info
+end
+
+function _mutatemessage!(bytes::Vector{UInt8}, index::Int, f)
+    frame = _frameinfo(bytes)[index]
+    meta = copy(bytes[frame.metadata])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    f(meta, msg)
+    copyto!(bytes, first(frame.metadata), meta, 1, length(meta))
+    return bytes
+end
+_mutatemessage!(f, bytes::Vector{UInt8}, index::Int) = _mutatemessage!(bytes, index, f)
+
+function _headertable(meta::Vector{UInt8}, msg::_VTable)
+    return _vtable(meta, _vref(msg, 2; required=true))
+end
+
+function _rejects(f)
+    try
+        f()
+        false
+    catch e
+        e isa Union{ValidationError,AllocationLimitError}
+    end
+end
+
+function _compressed_wire(payload::Vector{UInt8}, declared::Int64)
+    return vcat(collect(reinterpret(UInt8, [declared])), payload)
+end
+
+function _decode_fixture(
+    codec::Int8,
+    payload::Vector{UInt8},
+    declared::Int64;
+    budget::Int64=AC._materializedvectorbytes(UInt8, max(declared, Int64(0))),
+)
+    bytes = _compressed_wire(payload, declared)
+    wire = BufferSlice(heapregion(bytes), 0, length(bytes))
+    state = DecodeState(AllocationBudget(budget))
+    cursor =
+        DecodeCursor(nothing, nothing, BufferSlice(), Limits(); codec=codec, state=state)
+    try
+        return AC.slicebytes(_decompressbuffer!(cursor, wire))
+    finally
+        close(state)
+    end
+end
+
+function _schema_stream_from_field!(b, field; features::Vector{Int64}=Int64[])
+    Meta.schemaStartFieldsVector(b, 1)
+    FB.prependoffset!(b, field)
+    fields = FB.endvector!(b, 1)
+    featurevec = 0
+    if !isempty(features)
+        FB.startvector!(b, 8, length(features), 8)
+        foreach(x -> FB.prepend!(b, x), Iterators.reverse(features))
+        featurevec = FB.endvector!(b, length(features))
+    end
+    Meta.schemaStart(b)
+    Meta.schemaAddEndianness(b, Meta.Endianness.Little)
+    Meta.schemaAddFields(b, fields)
+    featurevec == 0 || Meta.schemaAddFeatures(b, featurevec)
+    sch = Meta.schemaEnd(b)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(b, Meta.Schema)
+    Meta.messageAddHeader(b, sch)
+    msg = Meta.messageEnd(b)
+    FB.finish!(b, msg)
+    meta = collect(FB.finishedbytes(b))
+    resize!(meta, 8cld(length(meta), 8))
+    out = UInt8[]
+    append!(out, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), UInt32(length(meta))]))
+    append!(out, meta)
+    append!(out, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), 0]))
+    return out
+end
+
+function _int64_schema_stream(features::Vector{Int64}=Int64[])
+    b = FB.Builder(256)
+    name = FB.createstring!(b, "x")
+    Meta.intStart(b)
+    Meta.intAddBitWidth(b, Int32(64))
+    Meta.intAddIsSigned(b, true)
+    typ = Meta.intEnd(b)
+    Meta.fieldStartChildrenVector(b, 0)
+    kids = FB.endvector!(b, 0)
+    Meta.fieldStart(b)
+    Meta.fieldAddName(b, name)
+    Meta.fieldAddNullable(b, true)
+    Meta.fieldAddTypeType(b, Meta.Int)
+    Meta.fieldAddType(b, typ)
+    Meta.fieldAddChildren(b, kids)
+    return _schema_stream_from_field!(b, Meta.fieldEnd(b); features=features)
+end
+
+function _dictionary_schema_frame_with_replacement(id::Int64)
+    b = FB.Builder(512)
+    name = FB.createstring!(b, "d")
+
+    Meta.utf8Start(b)
+    valuetype = Meta.utf8End(b)
+    Meta.intStart(b)
+    Meta.intAddBitWidth(b, Int32(8))
+    Meta.intAddIsSigned(b, true)
+    indextype = Meta.intEnd(b)
+    Meta.dictionaryEncodingStart(b)
+    Meta.dictionaryEncodingAddId(b, id)
+    Meta.dictionaryEncodingAddIndexType(b, indextype)
+    dict = Meta.dictionaryEncodingEnd(b)
+
+    Meta.fieldStartChildrenVector(b, 0)
+    children = FB.endvector!(b, 0)
+    Meta.fieldStart(b)
+    Meta.fieldAddName(b, name)
+    Meta.fieldAddTypeType(b, Meta.Utf8)
+    Meta.fieldAddType(b, valuetype)
+    Meta.fieldAddDictionary(b, dict)
+    Meta.fieldAddChildren(b, children)
+    field = Meta.fieldEnd(b)
+
+    Meta.schemaStartFieldsVector(b, 1)
+    FB.prependoffset!(b, field)
+    fields = FB.endvector!(b, 1)
+    FB.startvector!(b, 8, 1, 8)
+    FB.prepend!(b, Int64(1)) # Feature.DICTIONARY_REPLACEMENT
+    features = FB.endvector!(b, 1)
+
+    Meta.schemaStart(b)
+    Meta.schemaAddEndianness(b, Meta.Endianness.Little)
+    Meta.schemaAddFields(b, fields)
+    Meta.schemaAddFeatures(b, features)
+    sch = Meta.schemaEnd(b)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(b, Meta.Schema)
+    Meta.messageAddHeader(b, sch)
+    msg = Meta.messageEnd(b)
+    FB.finish!(b, msg)
+    meta = collect(FB.finishedbytes(b))
+    append!(meta, zeros(UInt8, mod(-length(meta), 8)))
+    frame = UInt8[]
+    append!(frame, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), UInt32(length(meta))]))
+    append!(frame, meta)
+    return frame
+end
+
+function _dictionary_replacement_stream()
+    id = Int64(7)
+    firstbytes = _fixture2x("dict-replacement-first") do
+        firstio = IOBuffer()
+        Arrow.write(firstio, (d=Arrow.DictEncode(["aa", "bb", "aa"], id),); file=false)
+        take!(firstio)
+    end
+    secondbytes = _fixture2x("dict-replacement-second") do
+        secondio = IOBuffer()
+        Arrow.write(secondio, (d=Arrow.DictEncode(["xx", "yy", "xx"], id),); file=false)
+        take!(secondio)
+    end
+    firstframes = _frameinfo(firstbytes)
+    secondframes = _frameinfo(secondbytes)
+    frameof(frames, bytes, kind) = bytes[only(x.frame for x in frames if x.kind == kind)]
+    return vcat(
+        _dictionary_schema_frame_with_replacement(id),
+        frameof(firstframes, firstbytes, UInt8(2)),
+        frameof(firstframes, firstbytes, UInt8(3)),
+        frameof(secondframes, secondbytes, UInt8(2)),
+        frameof(secondframes, secondbytes, UInt8(3)),
+        frameof(firstframes, firstbytes, UInt8(0)),
+    )
+end
+
+function _experimental_v4_stream(value::Int64)
+    schema = _int64_schema_stream()
+    _mutatemessage!(schema, 1) do meta, msg
+        _write_i16!(meta, _vfield(msg, 0, 2; required=true), Int16(3)) # V4
+    end
+    resize!(schema, length(schema) - 8) # remove helper EOS
+
+    raw = collect(reinterpret(UInt8, [value]))
+    compressed = transcode(Arrow.LZ4FrameCompressor, raw)
+    body = vcat(collect(reinterpret(UInt8, Int64[Int64(length(raw))])), compressed)
+    encodedlen = length(body)
+    append!(body, zeros(UInt8, mod(-length(body), 8)))
+
+    b = FB.Builder(512)
+    key = FB.createstring!(b, EXPERIMENTAL_COMPRESSION_KEY)
+    val = FB.createstring!(b, "LZ4")
+    Meta.keyValueStart(b)
+    Meta.keyValueAddKey(b, key)
+    Meta.keyValueAddValue(b, val)
+    kv = Meta.keyValueEnd(b)
+    Meta.recordBatchStartNodesVector(b, 1)
+    Meta.createFieldNode(b, Int64(1), Int64(0))
+    nodes = FB.endvector!(b, 1)
+    Meta.recordBatchStartBuffersVector(b, 2)
+    Meta.createBuffer(b, Int64(0), Int64(encodedlen)) # data (reverse build)
+    Meta.createBuffer(b, Int64(0), Int64(0))          # validity
+    buffers = FB.endvector!(b, 2)
+    Meta.recordBatchStart(b)
+    Meta.recordBatchAddLength(b, Int64(1))
+    Meta.recordBatchAddNodes(b, nodes)
+    Meta.recordBatchAddBuffers(b, buffers)
+    rb = Meta.recordBatchEnd(b)
+    Meta.messageStartCustomMetadataVector(b, 1)
+    FB.prependoffset!(b, kv)
+    custom = FB.endvector!(b, 1)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V4)
+    Meta.messageAddHeaderType(b, Meta.RecordBatch)
+    Meta.messageAddHeader(b, rb)
+    Meta.messageAddBodyLength(b, Int64(length(body)))
+    Meta.messageAddCustomMetadata(b, custom)
+    msg = Meta.messageEnd(b)
+    FB.finish!(b, msg)
+    meta = collect(FB.finishedbytes(b))
+    append!(meta, zeros(UInt8, mod(-length(meta), 8)))
+    prefix = collect(reinterpret(UInt8, UInt32[UInt32(CONTINUATION), UInt32(length(meta))]))
+    eos = collect(reinterpret(UInt8, UInt32[UInt32(CONTINUATION), UInt32(0)]))
+    return vcat(schema, prefix, meta, body, eos)
+end
+
+function _aliased_field_stream(depth::Int)
+    b = FB.Builder(1024)
+    Meta.intStart(b)
+    Meta.intAddBitWidth(b, Int32(64))
+    Meta.intAddIsSigned(b, true)
+    typ = Meta.intEnd(b)
+    Meta.fieldStartChildrenVector(b, 0)
+    kids = FB.endvector!(b, 0)
+    Meta.fieldStart(b)
+    Meta.fieldAddTypeType(b, Meta.Int)
+    Meta.fieldAddType(b, typ)
+    Meta.fieldAddChildren(b, kids)
+    next = Meta.fieldEnd(b)
+    for _ = 1:depth
+        Meta.fieldStartChildrenVector(b, 2)
+        FB.prependoffset!(b, next)
+        FB.prependoffset!(b, next)
+        kids = FB.endvector!(b, 2)
+        Meta.structStart(b)
+        typ = Meta.structEnd(b)
+        Meta.fieldStart(b)
+        Meta.fieldAddTypeType(b, Meta.Struct)
+        Meta.fieldAddType(b, typ)
+        Meta.fieldAddChildren(b, kids)
+        next = Meta.fieldEnd(b)
+    end
+    return _schema_stream_from_field!(b, next)
+end
+
+function _shared_name_stream(nfields::Int, namesize::Int)
+    b = FB.Builder(max(1024, namesize + 1024))
+    name = FB.createstring!(b, repeat("x", namesize))
+    Meta.intStart(b)
+    Meta.intAddBitWidth(b, Int32(64))
+    Meta.intAddIsSigned(b, true)
+    typ = Meta.intEnd(b)
+    Meta.fieldStartChildrenVector(b, 0)
+    kids = FB.endvector!(b, 0)
+    fields = Vector{FB.UOffsetT}(undef, nfields)
+    for i = 1:nfields
+        Meta.fieldStart(b)
+        Meta.fieldAddName(b, name)
+        Meta.fieldAddTypeType(b, Meta.Int)
+        Meta.fieldAddType(b, typ)
+        Meta.fieldAddChildren(b, kids)
+        fields[i] = Meta.fieldEnd(b)
+    end
+    Meta.schemaStartFieldsVector(b, nfields)
+    for f in Iterators.reverse(fields)
+        FB.prependoffset!(b, f)
+    end
+    fieldvec = FB.endvector!(b, nfields)
+    Meta.schemaStart(b)
+    Meta.schemaAddEndianness(b, Meta.Endianness.Little)
+    Meta.schemaAddFields(b, fieldvec)
+    sch = Meta.schemaEnd(b)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(b, Meta.Schema)
+    Meta.messageAddHeader(b, sch)
+    msg = Meta.messageEnd(b)
+    FB.finish!(b, msg)
+    meta = collect(FB.finishedbytes(b))
+    resize!(meta, 8cld(length(meta), 8))
+    out = UInt8[]
+    append!(out, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), UInt32(length(meta))]))
+    append!(out, meta)
+    append!(out, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), 0]))
+    return out
+end
+
+function _zero_width_schema_stream(fixedlist::Bool)
+    b = FB.Builder(1024)
+    children = FB.UOffsetT(0)
+    if fixedlist
+        Meta.intStart(b)
+        Meta.intAddBitWidth(b, Int32(64))
+        Meta.intAddIsSigned(b, true)
+        childtype = Meta.intEnd(b)
+        Meta.fieldStartChildrenVector(b, 0)
+        childkids = FB.endvector!(b, 0)
+        Meta.fieldStart(b)
+        Meta.fieldAddTypeType(b, Meta.Int)
+        Meta.fieldAddType(b, childtype)
+        Meta.fieldAddChildren(b, childkids)
+        child = Meta.fieldEnd(b)
+        Meta.fieldStartChildrenVector(b, 1)
+        FB.prependoffset!(b, child)
+        children = FB.endvector!(b, 1)
+        Meta.fixedSizeListStart(b)       # listSize=0 is omitted by default
+        typ = Meta.fixedSizeListEnd(b)
+        tag = Meta.FixedSizeList
+    else
+        Meta.fieldStartChildrenVector(b, 0)
+        children = FB.endvector!(b, 0)
+        Meta.fixedSizeBinaryStart(b)     # byteWidth=0 is omitted by default
+        typ = Meta.fixedSizeBinaryEnd(b)
+        tag = Meta.FixedSizeBinary
+    end
+    Meta.fieldStart(b)
+    Meta.fieldAddTypeType(b, tag)
+    Meta.fieldAddType(b, typ)
+    Meta.fieldAddChildren(b, children)
+    field = Meta.fieldEnd(b)
+    return _schema_stream_from_field!(b, field)
+end
+
+function _misaligned_empty_buffers_stream()
+    # FlatBuffers C++ historically aligns an empty vector only for its UInt32
+    # length, not for an element that does not exist. Official Arrow
+    # integration streams therefore contain empty vectors of 16-byte Buffer
+    # structs whose nominal element area is four-byte aligned. Relocate the
+    # empty buffers vector of the frozen zero-row Null batch to reproduce
+    # that valid encoding.
+    bytes = _fixture2x("null-column-zero-rows") do
+        io = IOBuffer()
+        Arrow.write(io, (x=Missing[],); file=false)
+        take!(io)
+    end
+    frames = _frameinfo(bytes)
+    schemaidx = only(findall(x -> x.kind == 1, frames))
+    recordidx = only(findall(x -> x.kind == 3, frames))
+    eosidx = only(findall(x -> x.kind == 0, frames))
+
+    meta = copy(bytes[frames[recordidx].metadata])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    record = _headertable(meta, msg)
+    bufferslot = _vfield(record, 2, 4; required=true)
+    oldvector = _vref(record, 2; required=true)
+    _vu32(meta, oldvector) == 0 || error("Null fixture has nonempty buffers")
+
+    target = Int64(length(meta))
+    target % 8 == 0 || error("padded metadata is not eight-byte aligned")
+    append!(meta, zeros(UInt8, 8)) # zero length plus framing padding
+    _write_u32!(meta, bufferslot, UInt32(target - bufferslot))
+
+    out = UInt8[]
+    append!(out, bytes[frames[schemaidx].frame])
+    append!(out, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), UInt32(length(meta))]))
+    append!(out, meta)
+    append!(out, bytes[frames[eosidx].frame])
+    return out
+end
+
+function _misaligned_empty_children_stream()
+    bytes = _zero_width_schema_stream(false)
+    _mutatemessage!(bytes, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        fields, nfields = _vvector(schema, 1, 4; required=true)
+        nfields == 1 || error("fixture schema has an unexpected field count")
+        field = _vtable(meta, fields + Int64(_vu32(meta, fields)))
+        slot = _vfield(field, 5, 4; required=true)
+        vector = _vref(field, 5; required=true)
+        _vu32(meta, vector) == 0 || error("fixture has nonempty children")
+        # Retarget the children reference one byte early: the length word
+        # then sits at a position that is not 4-aligned, which the verifier
+        # must reject before any generated getter dereferences it.
+        vector % 4 == 0 || error("fixture vector was not aligned to begin with")
+        _write_u32!(meta, slot, UInt32(_vu32(meta, slot) - 1))
+    end
+    return bytes
+end
+
+function _metadata_value_stream(explicit_empty::Bool)
+    b = FB.Builder(1024)
+    key = FB.createstring!(b, "owner")
+    value = explicit_empty ? FB.createstring!(b, "") : zero(FB.UOffsetT)
+    Meta.keyValueStart(b)
+    Meta.keyValueAddKey(b, key)
+    explicit_empty && Meta.keyValueAddValue(b, value)
+    kv = Meta.keyValueEnd(b)
+    Meta.schemaStartCustomMetadataVector(b, 1)
+    FB.prependoffset!(b, kv)
+    custom = FB.endvector!(b, 1)
+
+    name = FB.createstring!(b, "x")
+    Meta.intStart(b)
+    Meta.intAddBitWidth(b, Int32(64))
+    Meta.intAddIsSigned(b, true)
+    typ = Meta.intEnd(b)
+    Meta.fieldStart(b)
+    Meta.fieldAddName(b, name)
+    Meta.fieldAddNullable(b, true)
+    Meta.fieldAddTypeType(b, Meta.Int)
+    Meta.fieldAddType(b, typ)
+    field = Meta.fieldEnd(b)
+    Meta.schemaStartFieldsVector(b, 1)
+    FB.prependoffset!(b, field)
+    fields = FB.endvector!(b, 1)
+
+    Meta.schemaStart(b)
+    Meta.schemaAddEndianness(b, Meta.Endianness.Little)
+    Meta.schemaAddFields(b, fields)
+    Meta.schemaAddCustomMetadata(b, custom)
+    schema = Meta.schemaEnd(b)
+    Meta.messageStart(b)
+    Meta.messageAddVersion(b, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(b, Meta.Schema)
+    Meta.messageAddHeader(b, schema)
+    msg = Meta.messageEnd(b)
+    FB.finish!(b, msg)
+    meta = collect(FB.finishedbytes(b))
+    resize!(meta, 8cld(length(meta), 8))
+    out = UInt8[]
+    append!(out, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), UInt32(length(meta))]))
+    append!(out, meta)
+    append!(out, reinterpret(UInt8, UInt32[UInt32(CONTINUATION), 0]))
+    return out
+end
+
+const TEST_NONCONFORMING_RELEASES = ReleaseCounter()
+
+function _test_nonconforming_release(::Ptr{CArrowArray})::Cvoid
+    increment!(TEST_NONCONFORMING_RELEASES)
+    return nothing
+end
+
+# Runtime accessors, NOT module-level pointer constants: a raw @cfunction
+# pointer stored in a const is serialized into the precompile cache and is
+# garbage when the package reloads. The static @cfunction form is cheap at
+# runtime (it returns the session's cached trampoline).
+test_nonconforming_release() =
+    @cfunction(_test_nonconforming_release, Cvoid, (Ptr{CArrowArray},))
+
+# A one-batch C stream producer over a hand-built struct column, for batch
+# shapes `export_stream!` never emits (null struct rows, struct offsets).
+# `private_data` stays non-NULL until the batch has been sent. With a `gate`
+# of two channels, `get_next` signals the first and waits on the second, to
+# hold a pull open.
+const ONE_BATCH_STREAM = Ref{Any}(nothing)
+
+function _one_batch_move!(out::Ptr{T}, src::Ptr{T}) where {T}
+    unsafe_store!(out, unsafe_load(src))
+    _store_field!(src, :release, Ptr{Cvoid}(C_NULL))
+    return nothing
+end
+
+function _one_batch_get_schema(::Ptr{CArrowArrayStream}, out::Ptr{CArrowSchema})::Cint
+    f, d, _ = ONE_BATCH_STREAM[]::Tuple{Field,ArrayData,Any}
+    sp, ap = to_c_data(f, d)
+    _one_batch_move!(out, sp)
+    ccall(unsafe_load(ap).release, Cvoid, (Ptr{CArrowArray},), ap)
+    return Cint(0)
+end
+
+function _one_batch_get_next(stream::Ptr{CArrowArrayStream}, out::Ptr{CArrowArray})::Cint
+    if unsafe_load(stream).private_data == C_NULL
+        unsafe_store!(
+            out,
+            CArrowArray(
+                0,
+                0,
+                0,
+                0,
+                0,
+                Ptr{Ptr{Cvoid}}(C_NULL),
+                Ptr{Ptr{CArrowArray}}(C_NULL),
+                Ptr{CArrowArray}(C_NULL),
+                Ptr{Cvoid}(C_NULL),
+                Ptr{Cvoid}(C_NULL),
+            ),
+        )
+        return Cint(0)
+    end
+    f, d, gate = ONE_BATCH_STREAM[]::Tuple{Field,ArrayData,Any}
+    if gate !== nothing
+        put!(gate[1], nothing)
+        take!(gate[2])
+    end
+    sp, ap = to_c_data(f, d)
+    _one_batch_move!(out, ap)
+    ccall(unsafe_load(sp).release, Cvoid, (Ptr{CArrowSchema},), sp)
+    _store_field!(stream, :private_data, Ptr{Cvoid}(C_NULL))
+    return Cint(0)
+end
+
+_one_batch_last_error(::Ptr{CArrowArrayStream})::Ptr{UInt8} = Ptr{UInt8}(C_NULL)
+
+function _one_batch_release(stream::Ptr{CArrowArrayStream})::Cvoid
+    _store_field!(stream, :release, Ptr{Cvoid}(C_NULL))
+    return nothing
+end
+
+"Fill `sp` with a C stream whose single batch is the struct column `(f, d)`."
+function one_batch_stream!(sp::Ptr{CArrowArrayStream}, f::Field, d::ArrayData, gate=nothing)
+    ONE_BATCH_STREAM[] = (f, d, gate)
+    unsafe_store!(
+        sp,
+        CArrowArrayStream(
+            @cfunction(
+                _one_batch_get_schema,
+                Cint,
+                (Ptr{CArrowArrayStream}, Ptr{CArrowSchema})
+            ),
+            @cfunction(
+                _one_batch_get_next,
+                Cint,
+                (Ptr{CArrowArrayStream}, Ptr{CArrowArray})
+            ),
+            @cfunction(_one_batch_last_error, Ptr{UInt8}, (Ptr{CArrowArrayStream},)),
+            @cfunction(_one_batch_release, Cvoid, (Ptr{CArrowArrayStream},)),
+            Ptr{Cvoid}(1),
+        ),
+    )
+    return sp
+end
+
+# ---------------------------------------------------------------------------
+# C Data battery support
+# ---------------------------------------------------------------------------
+
+function _expect_invalid_schema_flags!(flags::Int64)
+    f, d = fromjulia("bad-flags", Int64[1])
+    before = _registry_count()
+    sp, ap = to_c_data(f, d)
+    _store_field!(sp, :flags, flags)
+    @assert try
+        from_c_data(sp, ap)
+        false
+    catch e
+        e isa ValidationError
+    end
+    @assert unsafe_load(sp).release == C_NULL
+    @assert unsafe_load(ap).release == C_NULL
+    @assert _drained() == before
+    return nothing
+end
+
+@noinline function _import_and_forget(sp::Ptr{CArrowSchema}, ap::Ptr{CArrowArray})
+    f, d = from_c_data(sp, ap)
+    @assert materialize(f, d) == [1]
+    return nothing
+end
+
+@noinline function _export_and_forget()
+    f, d = fromjulia("registry-rooted", Int64[1, 2])
+    region = d.buffers[2].region
+    sp, ap = to_c_data(f, d)
+    return sp, ap, WeakRef(d), WeakRef(region)
+end
+
+# Bytes the release callbacks of one exported column and one exported stream
+# allocate when a consumer calls them.
+@noinline function _release_allocations()
+    f, d = fromjulia("alloc", Int64[1, 2, 3])
+    sp, ap = to_c_data(f, d)
+    bytes = (@allocated _release_c!(ap)) + (@allocated _release_c!(sp))
+    ref = Ref{CArrowArrayStream}()
+    GC.@preserve ref begin
+        p = Base.unsafe_convert(Ptr{CArrowArrayStream}, ref)
+        export_stream!(p, Schema(Field[f]), AC.RecordBatch[])
+        bytes += @allocated _release_c!(p)
+    end
+    return bytes
+end
+
+# Seconds for `n` exports that the consumer keeps, the fastest of three runs, with
+# collections off so only the exports are timed. Each run's exports are released after.
+@noinline function _held_export_seconds(n)
+    f, d = fromjulia("held", Int64[1])
+    best = Inf
+    for _ = 1:3
+        held = Vector{Tuple{Ptr{CArrowSchema},Ptr{CArrowArray}}}(undef, n)
+        GC.enable(false)
+        t = try
+            @elapsed for i = 1:n
+                held[i] = to_c_data(f, d)
+            end
+        finally
+            GC.enable(true)
+        end
+        _release_all!(held)
+        best = min(best, t)
+    end
+    return best
+end
+
+_hold_exports(n) = [to_c_data(fromjulia("held", Int64[1])...) for _ = 1:n]
+
+function _release_all!(held)
+    for (sp, ap) in held
+        _release_c!(ap)
+        _release_c!(sp)
+    end
+    return nothing
+end
+
+# The registry key of an export whose consumer released both of its structs.
+@noinline function _released_export_key()
+    sp, ap = to_c_data(fromjulia("released", Int64[1, 2, 3])...)
+    key = _exportkey(ap)
+    _release_c!(ap)
+    _release_c!(sp)
+    return key
+end
+
+# An imported table released and dropped, a column taken from it read after the
+# release; returns the export's key, still registered while the column lives.
+@noinline function _released_import_key()
+    sp, ap = to_c_data((x=collect(Int64, 1:10),))
+    key = _exportkey(ap)
+    t = Arrow.Table(sp, ap)
+    col = t.x
+    release!(t)
+    @assert try
+        t.x
+        false
+    catch e
+        e isa InvalidStateException
+    end
+    @assert collect(col) == 1:10
+    _reapreleased!()
+    @assert _registered(key)
+    return key
+end
+
+# Test-support: one 16-byte view entry (inline / out-of-line forms).
+_viewentry(len::Int, rest::Vector{UInt8}) =
+    vcat(reinterpret(UInt8, Int32[Int32(len)]), rest, zeros(UInt8, 12 - length(rest)))
+_viewlong(len::Int, prefix::Vector{UInt8}, bufidx::Int, off::Int) = vcat(
+    reinterpret(UInt8, Int32[Int32(len)]),
+    prefix,
+    reinterpret(UInt8, Int32[Int32(bufidx), Int32(off)]),
+)
+
+# ---------------------------------------------------------------------------
+# Byte-range sources over in-memory bytes for the ranged-scan battery: the
+# plain one, and one that logs every range and byte it is asked for.
+# ---------------------------------------------------------------------------
+struct BytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::BytesSource) = length(s.data)
+Arrow.readrange(s::BytesSource, off, len) = s.data[(off + 1):(off + len)]
+
+mutable struct FetchLog
+    requests::Int
+    bytes::Int64
+    ranges::Vector{NTuple{2,Int64}}
+end
+FetchLog() = FetchLog(0, 0, NTuple{2,Int64}[])
+
+struct CountingSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+    log::FetchLog
+end
+Arrow.sourcelength(s::CountingSource) = length(s.data)
+function Arrow.readrange(s::CountingSource, off, len)
+    s.log.requests += 1
+    s.log.bytes += len
+    push!(s.log.ranges, (off, len))
+    return s.data[(off + 1):(off + len)]
+end
+
+function countingsource(bytes::Vector{UInt8})
+    log = FetchLog()
+    return log, CountingSource(bytes, log)
+end
+
+_fetched(log::FetchLog, pos::Int64) =
+    any(off <= pos < off + len for (off, len) in log.ranges)
diff --git a/test/cdata_battery.jl b/test/cdata_battery.jl
new file mode 100644
index 00000000..74e9eaef
--- /dev/null
+++ b/test/cdata_battery.jl
@@ -0,0 +1,1805 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+function cdata_battery()
+    if Sys.WORD_SIZE == 64
+        @assert sizeof(CArrowSchema) == 72
+        @assert fieldoffset.(Ref(CArrowSchema), 1:9) == 0:8:64
+        @assert sizeof(CArrowArray) == 80
+        @assert fieldoffset.(Ref(CArrowArray), 1:10) == 0:8:72
+    elseif Sys.WORD_SIZE == 32
+        if Base.datatype_alignment(Int64) == 4 # i686 SysV ABI
+            @assert sizeof(CArrowSchema) == 44
+            @assert fieldoffset.(Ref(CArrowSchema), 1:9) ==
+                    [0, 4, 8, 12, 20, 28, 32, 36, 40]
+            @assert sizeof(CArrowArray) == 60
+            @assert fieldoffset.(Ref(CArrowArray), 1:10) ==
+                    [0, 8, 16, 24, 32, 40, 44, 48, 52, 56]
+        else # 32-bit ABIs that align int64_t to 8 bytes
+            @assert sizeof(CArrowSchema) == 48
+            @assert fieldoffset.(Ref(CArrowSchema), 1:9) ==
+                    [0, 4, 8, 16, 24, 32, 36, 40, 44]
+            @assert sizeof(CArrowArray) == 64
+            @assert fieldoffset.(Ref(CArrowArray), 1:10) ==
+                    [0, 8, 16, 24, 32, 40, 44, 48, 52, 56]
+        end
+    else
+        error("unsupported pointer width $(Sys.WORD_SIZE)")
+    end
+    println("C ABI size and field-offset gate passed for $(Sys.WORD_SIZE)-bit ✓")
+
+    # The export, not the caller's Julia variables, keeps the source column
+    # and its buffers alive while the consumer holds raw C pointers.
+    before = _drained()
+    sp, ap, dataref, regionref = _export_and_forget()
+    GC.gc(true)
+    @assert dataref.value !== nothing
+    @assert regionref.value !== nothing
+    rootedf, rootedd = from_c_data(sp, ap)
+    @assert materialize(rootedf, rootedd) == [1, 2]
+    @assert _drained() == before + 1
+    release!(rootedd.owner::ForeignOwner)
+    @assert _drained() == before
+    println("an export roots its Julia sources across GC ✓")
+
+    b = batch((
+        xs=Int64[1, 2, 3, 4],
+        ys=[1.5, missing, 3.5, missing],
+        strs=["a", "", missing, "δεζ"],
+        lists=[[1, 2], missing, Int64[], [3]],
+    ))
+    expected = Dict(
+        "xs" => Any[1, 2, 3, 4],
+        "ys" => Any[1.5, missing, 3.5, missing],
+        "strs" => Any["a", "", missing, "δεζ"],
+        "lists" => Any[[1, 2], missing, Int64[], [3]],
+    )
+
+    imported = Tuple{Field,ArrayData}[]
+    for (f, col) in zip(b.schema.fields, b.columns)
+        sp, ap = to_c_data(f, col)
+        f2, d2 = from_c_data(sp, ap)
+        push!(imported, (f2, d2))
+    end
+    for (f2, d2) in imported
+        got = materialize(f2, d2)
+        @assert isequal(collect(Any, got), expected[f2.name]) "$(f2.name): $got"
+    end
+    println("export → import round-trip for $(length(imported)) columns ✓")
+    nlive = _registry_count()
+    @assert nlive == length(imported)
+
+    # The consumer's release (here the imported columns' owners) marks each
+    # export; the reaper frees it, once, and a second release is inert.
+    for (_, d2) in imported
+        release!(d2.owner::ForeignOwner)
+    end
+    @assert _drained() == 0
+    for (_, d2) in imported
+        release!(d2.owner::ForeignOwner)
+    end
+    @assert _reap!() == 0
+    println("consumer releases free each export once; double release is inert ✓")
+
+    # Releasing an import revokes every region over it, so touching a slice
+    # afterwards is a clean InvalidStateException rather than the C Data
+    # spec's post-release undefined behavior.
+    for (f2, d2) in imported
+        @assert (@atomic (d2.owner::ForeignOwner).cell.closed)
+        isempty(d2.buffers) && continue
+        slice = d2.buffers[end]
+        slice.region === nothing && continue
+        @assert try
+            AC.loadat(slice, UInt8, Int64(0))
+            false
+        catch e
+            e isa InvalidStateException
+        end
+    end
+    println("released owners are revoked ✓")
+
+    # Format parity with Core's accessor set: every mapped descriptor
+    # round-trips its format string, declared geometry, and values through
+    # the raw C ABI. Ground truth is the SOURCE column's materialization.
+    fslu, _ = fromjulia("fsl-child", Int64[1, 2, 3, 4])
+    sui, sud = fromjulia("i", Int64[10, 20, 30])
+    sus, susd = fromjulia("s", ["x", "y", "z"])
+    dui, duid = fromjulia("i", Int64[10, 30])
+    dus, dusd = fromjulia("s", ["y"])
+    sut = UnionType(AC.SparseMode, Int8[0, 1])
+    dut = UnionType(AC.DenseMode, Int8[0, 1])
+    tsnulls = TimestampType(AC.MICROSECOND, "UTC")
+    nestedirf, nestedird = fromjulia("run_ends", Int32[1, 2])
+    nestedivf, nestedivd = fromjulia("values", Int64[10, 20])
+    nestedinnerf = Field("values", RunEndEncodedType(); children=[nestedirf, nestedivf])
+    nestedinnerd = ArrayData(
+        RunEndEncodedType(),
+        2,
+        BufferSlice[];
+        children=[nestedird, nestedivd],
+        nullcount=0,
+    )
+    nestedorf, nestedord = fromjulia("run_ends", Int32[2, 4])
+    paritycases = Tuple{Field,ArrayData}[
+        (
+            Field("dec128", DecimalType(38, 10, 128)),
+            ArrayData(
+                DecimalType(38, 10, 128),
+                2,
+                [BufferSlice(), AC._databuffer(Int128[123, -456])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("dec32", DecimalType(9, 2, 32)),
+            ArrayData(
+                DecimalType(9, 2, 32),
+                2,
+                [BufferSlice(), AC._databuffer(Int32[1234, -5678])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("date32", DateType(AC.DAY)),
+            ArrayData(
+                DateType(AC.DAY),
+                2,
+                [BufferSlice(), AC._databuffer(Int32[0, 19000])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("date64", DateType(AC.MILLISECOND_DATE)),
+            ArrayData(
+                DateType(AC.MILLISECOND_DATE),
+                2,
+                [BufferSlice(), AC._databuffer(Int64[0, 86_400_000])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("time32s", TimeType(AC.SECOND, 32)),
+            ArrayData(
+                TimeType(AC.SECOND, 32),
+                2,
+                [BufferSlice(), AC._databuffer(Int32[0, 86_399])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("time64n", TimeType(AC.NANOSECOND, 64)),
+            ArrayData(
+                TimeType(AC.NANOSECOND, 64),
+                2,
+                [BufferSlice(), AC._databuffer(Int64[0, 12_345])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("ts-utc", tsnulls),
+            ArrayData(
+                tsnulls,
+                3,
+                [AC._databuffer(UInt8[0x05]), AC._databuffer(Int64[7, 0, 9])];
+                nullcount=1,
+            ),
+        ),
+        (
+            Field("ts-naive", TimestampType(AC.SECOND, nothing)),
+            ArrayData(
+                TimestampType(AC.SECOND, nothing),
+                1,
+                [BufferSlice(), AC._databuffer(Int64[42])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("dur", DurationType(AC.MILLISECOND)),
+            ArrayData(
+                DurationType(AC.MILLISECOND),
+                2,
+                [BufferSlice(), AC._databuffer(Int64[5, -5])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("iym", IntervalType(AC.YEAR_MONTH)),
+            ArrayData(
+                IntervalType(AC.YEAR_MONTH),
+                2,
+                [BufferSlice(), AC._databuffer(Int32[12, -1])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("idt", IntervalType(AC.DAY_TIME)),
+            ArrayData(
+                IntervalType(AC.DAY_TIME),
+                2,
+                [BufferSlice(), AC._databuffer(Int32[1, 2, 3, 4])];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("imdn", IntervalType(AC.MONTH_DAY_NANO)),
+            ArrayData(
+                IntervalType(AC.MONTH_DAY_NANO),
+                1,
+                [
+                    BufferSlice(),
+                    AC._databuffer(
+                        vcat(reinterpret(UInt8, Int32[1, 2]), reinterpret(UInt8, Int64[3])),
+                    ),
+                ];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("fsb", FixedSizeBinaryType(3)),
+            ArrayData(
+                FixedSizeBinaryType(3),
+                2,
+                [BufferSlice(), AC._databuffer(collect(codeunits("abcdef")))];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("fsl", FixedSizeListType(2); children=[fslu]),
+            ArrayData(
+                FixedSizeListType(2),
+                2,
+                [BufferSlice()];
+                children=[fromjulia("fsl-child", Int64[1, 2, 3, 4])[2]],
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("lu", Utf8Type(true)),
+            ArrayData(
+                Utf8Type(true),
+                2,
+                [
+                    BufferSlice(),
+                    AC._databuffer(Int64[0, 1, 3]),
+                    AC._databuffer(collect(codeunits("abc"))),
+                ];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("lz", BinaryType(true)),
+            ArrayData(
+                BinaryType(true),
+                2,
+                [
+                    BufferSlice(),
+                    AC._databuffer(Int64[0, 2, 3]),
+                    AC._databuffer(UInt8[0x01, 0x02, 0x03]),
+                ];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("ll", ListType(true); children=[fslu]),
+            ArrayData(
+                ListType(true),
+                2,
+                [BufferSlice(), AC._databuffer(Int64[0, 2, 4])];
+                children=[fromjulia("fsl-child", Int64[1, 2, 3, 4])[2]],
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("su", sut; nullable=false, children=[sui, sus]),
+            ArrayData(
+                sut,
+                3,
+                [AC._databuffer(Int8[0, 1, 0])];
+                children=[sud, susd],
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("du", dut; nullable=false, children=[dui, dus]),
+            ArrayData(
+                dut,
+                3,
+                [AC._databuffer(Int8[0, 1, 0]), AC._databuffer(Int32[0, 0, 1])];
+                children=[duid, dusd],
+                nullcount=0,
+            ),
+        ),
+        (Field("nulls", NullType()), ArrayData(NullType(), 3, BufferSlice[]; nullcount=3)),
+        # format 1.3/1.4: views (with the C-only trailing sizes buffer),
+        # list-views (per-slot offsets+sizes, unordered/overlapping), REE
+        (
+            Field("vu", ViewType(true); nullable=true),
+            ArrayData(
+                ViewType(true),
+                3,
+                [
+                    AC._databuffer(UInt8[0x05]),
+                    AC._databuffer(
+                        vcat(
+                            _viewentry(3, collect(codeunits("abc"))),
+                            _viewlong(25, collect(codeunits("firs")), 0, 0),
+                            _viewlong(26, collect(codeunits("seco")), 1, 0),
+                        ),
+                    ),
+                    AC._databuffer(collect(codeunits("first-out-of-line-payload"))),
+                    AC._databuffer(collect(codeunits("second-buffer-payload-here"))),
+                ];
+                nullcount=1,
+            ),
+        ),
+        (
+            Field("vz", ViewType(false)),
+            ArrayData(
+                ViewType(false),
+                1,
+                [BufferSlice(), AC._databuffer(_viewentry(2, UInt8[0xff, 0x00]))];
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("lv", ListViewType(false); children=[fslu]),
+            ArrayData(
+                ListViewType(false),
+                3,
+                [
+                    BufferSlice(),
+                    AC._databuffer(Int32[2, 0, 0]),
+                    AC._databuffer(Int32[2, 2, 4]),
+                ];
+                children=[fromjulia("fsl-child", Int64[1, 2, 3, 4])[2]],
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("Lv", ListViewType(true); children=[fslu]),
+            ArrayData(
+                ListViewType(true),
+                1,
+                [BufferSlice(), AC._databuffer(Int64[1]), AC._databuffer(Int64[3])];
+                children=[fromjulia("fsl-child", Int64[1, 2, 3, 4])[2]],
+                nullcount=0,
+            ),
+        ),
+        (
+            Field(
+                "ree",
+                RunEndEncodedType();
+                children=[
+                    Field("run_ends", IntType(32, true); nullable=false),
+                    Field("values", Utf8Type(false); nullable=true),
+                ],
+            ),
+            ArrayData(
+                RunEndEncodedType(),
+                4,
+                BufferSlice[];
+                children=[
+                    fromjulia("run_ends", Int32[2, 3, 4])[2],
+                    fromjulia("values", Union{Missing,String}["x", missing, "z"])[2],
+                ],
+                nullcount=0,
+            ),
+        ),
+        (
+            Field("nested-ree", RunEndEncodedType(); children=[nestedorf, nestedinnerf]),
+            ArrayData(
+                RunEndEncodedType(),
+                4,
+                BufferSlice[];
+                children=[nestedord, nestedinnerd],
+                nullcount=0,
+            ),
+        ),
+    ]
+    for (f, d) in paritycases
+        want = collect(Any, materialize(f, d))
+        sp, ap = to_c_data(f, d)
+        f2, d2 = from_c_data(sp, ap)
+        @assert AC.typeequal(f2.type, f.type) f.name
+        @assert isequal(collect(Any, materialize(f2, d2)), want) f.name
+        release!(d2.owner::ForeignOwner)
+    end
+    @assert _drained() == 0
+    println("format parity round-trips for $(length(paritycases)) descriptor shapes ✓")
+    # Format-string spot checks and refusals.
+    @assert formatstring(DecimalType(38, 10, 128)) == "d:38,10"
+    @assert formatstring(DecimalType(9, 2, 32)) == "d:9,2,32"
+    @assert formatstring(TimestampType(AC.MICROSECOND, "UTC")) == "tsu:UTC"
+    @assert formatstring(TimestampType(AC.SECOND, nothing)) == "tss:"
+    @assert formatstring(IntervalType(AC.MONTH_DAY_NANO)) == "tin"
+    @assert formatstring(UnionType(AC.DenseMode, Int8[0, 1])) == "+ud:0,1"
+    @assert formatstring(FixedSizeListType(2)) == "+w:2"
+    @assert parseformat("tsu:UTC") == TimestampType(AC.MICROSECOND, "UTC")
+    @assert parseformat("tsu:Δ") == TimestampType(AC.MICROSECOND, "Δ")
+    @assert parseformat("d:38,10") == DecimalType(38, 10, 128)
+    @assert parseformat("d:38,-2") == DecimalType(38, -2, 128)
+    @assert parseformat("vu") == ViewType(true) && formatstring(ViewType(true)) == "vu"
+    @assert parseformat("vz") == ViewType(false) && formatstring(ViewType(false)) == "vz"
+    @assert parseformat("+vl") == ListViewType(false)
+    @assert parseformat("+vL") == ListViewType(true) &&
+            formatstring(ListViewType(true)) == "+vL"
+    @assert parseformat("+r") == RunEndEncodedType() &&
+            formatstring(RunEndEncodedType()) == "+r"
+    badformats = String[
+        "v",
+        "vx",
+        "+v",
+        "+vx",
+        "+rr",
+        "d:x",
+        "w:",
+        "tsq:",
+        "tsé:",
+        "ts💣:",
+        "tsu:UTC\0hidden",
+        "w: 1",
+        "w:1 ",
+        "w:+1",
+        "w:0x10",
+        "+w: 2",
+        "d: 1,0",
+        "d:1, 0",
+        "d:+1,+0",
+        "d:0x9,0x2,0x20",
+        "d:0,0",
+        "d:39,0",
+        "d:1,0,1",
+        "d:77,0,256",
+        "+ud:200",
+        "+ud:0,0",
+        "+ud: 0,1",
+        "+us:+1",
+        "+ud:0x0,0x1",
+        "+ud:" * join(0:128, ","),
+    ]
+    push!(badformats, String(UInt8[0x74, 0x73, 0x75, 0x3a, 0xff]))
+    for bad in badformats
+        @assert try
+            parseformat(bad)
+            false
+        catch e
+            e isa ValidationError
+        end (bad)
+    end
+    println("format strings use strict byte-safe grammar and reject corrupt forms ✓")
+    # Core can omit the physical offsets allocation for a canonical empty
+    # array. C Data still requires its length+1 terminal offset. The export
+    # aggregate owns that adapter-only zero until the consumer releases it.
+    emptyitemf, emptyitemd = fromjulia("item", Int64[])
+    emptyoffsetcases = Tuple{Field,ArrayData}[]
+    for t in (Utf8Type(false), Utf8Type(true), BinaryType(false), BinaryType(true))
+        push!(
+            emptyoffsetcases,
+            (
+                Field("empty", t),
+                ArrayData(t, 0, [BufferSlice(), BufferSlice(), BufferSlice()]; nullcount=0),
+            ),
+        )
+    end
+    for t in (ListType(false), ListType(true))
+        push!(
+            emptyoffsetcases,
+            (
+                Field("empty-list", t; children=[emptyitemf]),
+                ArrayData(
+                    t,
+                    0,
+                    [BufferSlice(), BufferSlice()];
+                    children=[emptyitemd],
+                    nullcount=0,
+                ),
+            ),
+        )
+    end
+    emptykeyt = Utf8Type(false)
+    emptykeyf = Field("key", emptykeyt; nullable=false)
+    emptykeyd =
+        ArrayData(emptykeyt, 0, [BufferSlice(), BufferSlice(), BufferSlice()]; nullcount=0)
+    emptyvaluef, emptyvalued = fromjulia("value", Int64[])
+    emptyentriesf =
+        Field("entries", StructType(); nullable=false, children=[emptykeyf, emptyvaluef])
+    emptyentriesd = ArrayData(
+        StructType(),
+        0,
+        [BufferSlice()];
+        children=[emptykeyd, emptyvalued],
+        nullcount=0,
+    )
+    emptymapt = MapType(false)
+    push!(
+        emptyoffsetcases,
+        (
+            Field("empty-map", emptymapt; children=[emptyentriesf]),
+            ArrayData(
+                emptymapt,
+                0,
+                [BufferSlice(), BufferSlice()];
+                children=[emptyentriesd],
+                nullcount=0,
+            ),
+        ),
+    )
+    for (f, d) in emptyoffsetcases
+        spec = layoutspec(f.type)
+        oi = findfirst(==(AC.OFFSETS), spec.buffers)::Int
+        sp, ap = to_c_data(f, d)
+        arr = unsafe_load(ap)
+        offsetp = Ptr{UInt8}(unsafe_load(arr.buffers, oi))
+        @assert offsetp != C_NULL
+        GC.gc(true)
+        @assert spec.offsetwidth == 4 ? unsafe_load(Ptr{Int32}(offsetp)) == 0 :
+                unsafe_load(Ptr{Int64}(offsetp)) == 0
+        f2, d2 = from_c_data(sp, ap)
+        @assert d2.buffers[oi].len == spec.offsetwidth
+        @assert isempty(materialize(f2, d2))
+        release!(d2.owner::ForeignOwner)
+        @assert _drained() == 0
+    end
+    println("empty C Data offset layouts export one rooted terminal zero ✓")
+    nullf = Field("null-empty", Utf8Type(false))
+    nulld = ArrayData(
+        Utf8Type(false),
+        0,
+        [BufferSlice(), BufferSlice(), BufferSlice()];
+        nullcount=0,
+    )
+    sp, ap = to_c_data(nullf, nulld)
+    unsafe_store!(unsafe_load(ap).buffers, Ptr{Cvoid}(C_NULL), 2)
+    @assert try
+        from_c_data(sp, ap)
+        false
+    catch e
+        e isa ValidationError && occursin("NULL OFFSETS buffer", e.msg)
+    end
+    @assert _drained() == 0
+    println("NULL empty C Data offsets fail with exact cleanup ✓")
+    # Descriptor and union shape failures must happen before malformed
+    # metadata can direct recursive or fixed-width geometry work.
+    earlyf, earlyd = fromjulia("early", Int64[1])
+    sp, ap = to_c_data(earlyf, earlyd)
+    baddecimal = "d:1,0,2147483647"
+    GC.@preserve baddecimal begin
+        _store_field!(sp, :format, pointer(baddecimal))
+        _store_field!(ap, :length, typemax(Int64))
+        @assert try
+            from_c_data(sp, ap)
+            false
+        catch e
+            e isa ValidationError
+        end
+    end
+    @assert _drained() == 0
+
+    earlyunionf = Field("early-union", sut; children=[sui, sus])
+    earlyuniond = ArrayData(
+        sut,
+        3,
+        [AC._databuffer(Int8[0, 1, 0])];
+        children=[sud, susd],
+        nullcount=0,
+    )
+    sp, ap = to_c_data(earlyunionf, earlyuniond)
+    shortunion = "+us:0"
+    badchild = "not-a-format"
+    firstchild = unsafe_load(unsafe_load(sp).children, 1)
+    GC.@preserve shortunion badchild begin
+        _store_field!(sp, :format, pointer(shortunion))
+        _store_field!(firstchild, :format, pointer(badchild))
+        @assert try
+            from_c_data(sp, ap)
+            false
+        catch e
+            e isa ValidationError && occursin("type ids", e.msg)
+        end
+    end
+    @assert _drained() == 0
+    println("invalid descriptors and union counts fail before geometry/children ✓")
+    # A negative final variable-length offset cannot become a negative foreign
+    # region extent. Reject it at the adapter boundary with ValidationError.
+    negativef, negatived = fromjulia("negative-offset", ["x"])
+    sp, ap = to_c_data(negativef, negatived)
+    offsetp = Ptr{Int32}(unsafe_load(unsafe_load(ap).buffers, 2))
+    unsafe_store!(offsetp, Int32(-1), 2)
+    @assert try
+        from_c_data(sp, ap)
+        false
+    catch e
+        e isa ValidationError && occursin("negative final offset", e.msg)
+    end
+    @assert _drained() == 0
+    println("negative C Data final offsets fail cleanly ✓")
+    # Lengths and offsets whose required extents overflow Int64 are malformed
+    # declarations: ValidationError, never a raw OverflowError.
+    for (f, d) in (fromjulia("wide", Int64[1]), fromjulia("text", ["x"]))
+        for (len, off) in ((typemax(Int64), 0), (2, typemax(Int64)), (Int64(2)^61, 0))
+            sp, ap = to_c_data(f, d)
+            _store_field!(ap, :length, len)
+            _store_field!(ap, :offset, off)
+            @assert try
+                from_c_data(sp, ap)
+                false
+            catch e
+                e isa ValidationError
+            end
+            @assert _drained() == 0
+        end
+    end
+    println("overflowing C Data extents fail as ValidationErrors ✓")
+    # Import of an already-released structure is refused.
+    f, col = b.schema.fields[1], b.columns[1]
+    sp, ap = to_c_data(f, col)
+    _f, _d = from_c_data(sp, ap)      # moves: source release now NULL
+    caught = try
+        from_c_data(sp, ap)
+        false
+    catch e
+        e isa ArgumentError
+    end
+    @assert caught
+    release!(_d.owner::ForeignOwner)
+    @assert _drained() == 0
+    println("moved (released) source cannot be imported twice ✓")
+
+    # A producer whose release callback does not mark the struct released
+    # breaks the interface: `release!` reports it, once, and later releases
+    # are inert.
+    before_calls = TEST_NONCONFORMING_RELEASES[]
+    badarr = Ref(_test_c_array(test_nonconforming_release()))
+    badowner = GC.@preserve badarr _moveowner(Base.unsafe_convert(Ptr{CArrowArray}, badarr))
+    @assert badarr[].release == C_NULL        # moved out of the source
+    @assert try
+        release!(badowner)
+        false
+    catch e
+        e isa ErrorException &&
+            e.msg == "C Data producer release did not mark the structure released"
+    end
+    @assert TEST_NONCONFORMING_RELEASES[] == before_calls + 1
+    release!(badowner)
+    finalize(badowner)
+    @assert TEST_NONCONFORMING_RELEASES[] == before_calls + 1
+    println("nonconforming producer release reports the error once ✓")
+
+    # A root release must transitively release every child. Inspect before
+    # reap, while the exported structs remain allocated.
+    lf, ld = b.schema.fields[4], b.columns[4]
+    sp, ap = to_c_data(lf, ld)
+    schild = unsafe_load(unsafe_load(sp).children, 1)
+    achild = unsafe_load(unsafe_load(ap).children, 1)
+    _release_c!(sp)
+    _release_c!(ap)
+    @assert unsafe_load(sp).release == C_NULL
+    @assert unsafe_load(schild).release == C_NULL
+    @assert unsafe_load(ap).release == C_NULL
+    @assert unsafe_load(achild).release == C_NULL
+    @assert _drained() == 0
+    println("root release is transitive across child trees ✓")
+    # C Data move semantics permit a consumer to shallow-copy a child and
+    # null the source child's release field. The parent must skip that child,
+    # and the aggregate allocation must remain live until the moved copy is
+    # released independently.
+    sp, ap = to_c_data(lf, ld)
+    schild = unsafe_load(unsafe_load(sp).children, 1)
+    achild = unsafe_load(unsafe_load(ap).children, 1)
+    smoved = Ref(unsafe_load(schild))
+    amoved = Ref(unsafe_load(achild))
+    _store_field!(schild, :release, Ptr{Cvoid}(C_NULL))
+    _store_field!(achild, :release, Ptr{Cvoid}(C_NULL))
+    _release_c!(sp)
+    _release_c!(ap)
+    @assert _drained() == 1
+    GC.@preserve smoved amoved begin
+        smovedp = Base.unsafe_convert(Ptr{CArrowSchema}, smoved)
+        amovedp = Base.unsafe_convert(Ptr{CArrowArray}, amoved)
+        @assert unsafe_load(smovedp).release != C_NULL
+        @assert unsafe_load(amovedp).release != C_NULL
+        movedf, movedd = from_c_data(smovedp, amovedp)
+        @assert materialize(movedf, movedd) == [1, 2, 3]
+        release!(movedd.owner::ForeignOwner)
+    end
+    @assert _drained() == 0
+    println("moved children retain aggregate ownership until release ✓")
+
+    # The C release entrypoints have no error channel: a release marks the
+    # struct released, a repeat call on it is inert, and the export is freed
+    # once every node has been released.
+    rf, rd = fromjulia("plain-release", Int64[1])
+    sp, ap = to_c_data(rf, rd)
+    _release_c!(ap)
+    @assert unsafe_load(ap).release == C_NULL
+    _release_c!(ap)   # inert repeat
+    @assert _drained() == 1
+    _release_c!(sp)
+    @assert _drained() == 0
+    println("C release entrypoints are exactly-once and repeats are inert ✓")
+
+    # A consumer may read a top-level struct it just released in place (Arrow C++
+    # checks that its `release` is NULL), so the reap that frees the export keeps the
+    # two top-level structs for 10 ms, however many reaps run meanwhile; 5 ms in, they
+    # are still there. Collections are off so no other reap runs.
+    GC.enable(false)
+    try
+        @assert _drained() == 0
+        sp, ap = to_c_data(fromjulia("in-place", Int64[1, 2])...)
+        key = _exportkey(ap)
+        top = Ptr{Cvoid}(sp)
+        retired() = any(r -> r[2] == top, _RETIRED)
+        _release_c!(sp)
+        _release_c!(ap)
+        t0 = time_ns()
+        @assert _reap!() == 1
+        @assert !_registered(key) && retired()
+        Libc.systemsleep(0.005)
+        _reap!()
+        _reap!()
+        if time_ns() - t0 < 10_000_000
+            @assert retired()
+            @assert unsafe_load(ap).release == C_NULL
+        end
+        Libc.systemsleep(0.011)
+        _reap!()
+        @assert !retired()
+    finally
+        GC.enable(true)
+    end
+    println("to_c_data's top-level structs outlive their export by 10 ms ✓")
+
+    # Consumers call the release callbacks from their own threads and from inside
+    # garbage-collector finalizers, so they allocate nothing. (Julia 1.10 and 1.11
+    # allocate 16 bytes in a call through a precompiled `@cfunction`'s pointer; the
+    # same body through one made in the session allocates none.)
+    _release_allocations()
+    VERSION >= v"1.12" && @assert _release_allocations() == 0
+    # With nothing exported afterwards, garbage collections free what a
+    # consumer released.
+    key = _released_export_key()
+    for _ = 1:10
+        _registered(key) || break
+        GC.gc(true)
+        yield()
+    end
+    @assert !_registered(key)
+    println("release callbacks allocate nothing; collections free released exports ✓")
+
+    # A consumer that keeps every batch it pulls (pyarrow's `read_all`) pays the
+    # same for each export however many it holds: exports on top of 50,000 held
+    # ones cost what they cost alone, not a scan of the held ones each.
+    before = _drained()
+    alone = _held_export_seconds(2_000)
+    held = _hold_exports(50_000)
+    ontop = _held_export_seconds(2_000)
+    _release_all!(held)
+    @assert ontop < 5 * alone (ontop, alone)
+    @assert _drained() == before
+    # Once the held exports are freed the registry shrinks, so later reaps walk only
+    # what is registered.
+    @assert length(EXPORTS.slots) <= 16 * max(64, _registry_count())
+    println("exports cost the same however many the consumer holds ✓")
+
+    # Schema/data mismatch and malformed buffers must fail before either
+    # independently-owned export root is published.
+    before = _registry_count()
+    mf = Field("wrong", IntType(32, true); nullable=false)
+    _, md = fromjulia("wrong", Int64[1])
+    @assert try
+        to_c_data(mf, md)
+        false
+    catch e
+        e isa ValidationError
+    end
+    short = ArrayData(IntType(64, true), 10, [AC._databuffer(UInt8[0xff]), BufferSlice()])
+    @assert try
+        to_c_data(Field("short", IntType(64, true)), short)
+        false
+    catch e
+        e isa ValidationError
+    end
+    @assert _registry_count() == before
+    println("failed exports leave no registry roots ✓")
+    # C strings cannot represent embedded NULs: reject before any export
+    # root becomes visible.
+    badname = Field("embedded\0nul", IntType(64, true); nullable=false)
+    @assert try
+        to_c_data(badname, md)
+        false
+    catch e
+        e isa ValidationError
+    end
+    @assert _registry_count() == before
+    # Utf8 content is NOT judged at the boundary — the exporter applies the
+    # semantic tier, exactly like the IPC writer. Invalid UTF-8 is what the
+    # opt-in `validate_full` tier catches; the export itself succeeds and the
+    # bytes cross unchanged.
+    badutf8type = Utf8Type(false)
+    badutf8field = Field("bad-utf8", badutf8type)
+    badutf8data = ArrayData(
+        badutf8type,
+        1,
+        [BufferSlice(), AC._databuffer(Int32[0, 1]), AC._databuffer(UInt8[0xff])];
+        nullcount=0,
+    )
+    @assert try
+        validate_full(badutf8field, badutf8data)
+        false
+    catch e
+        e isa ValidationError
+    end
+    sp, ap = to_c_data(badutf8field, badutf8data)
+    rawf, rawd = from_c_data(sp, ap)
+    @assert codeunits(getvalue(rawf, rawd, 1)) == UInt8[0xff]
+    release!(rawd.owner::ForeignOwner)
+    @assert _drained() == 0
+    @assert _registry_count() == before
+    println("unrepresentable names fail before export; content policy is opt-in ✓")
+    # Dictionary values have independent nullability. Ordered state is a C
+    # schema flag, and a non-nullable index may select a null pool value.
+    vf, vd = fromjulia("dict", Union{Missing,String}[missing, "x"])
+    dt = DictionaryType(IntType(32, true), vf.type, true)
+    df = Field("dict", dt; nullable=false, children=vf.children)
+    dd = ArrayData(
+        dt,
+        2,
+        [BufferSlice(), AC._databuffer(Int32[0, 1])];
+        dictionary=vd,
+        nullcount=0,
+    )
+    sp, ap = to_c_data(df, dd)
+    @assert (unsafe_load(sp).flags & ARROW_FLAG_DICTIONARY_ORDERED) != 0
+    df2, dd2 = from_c_data(sp, ap)
+    @assert (df2.type::DictionaryType).ordered
+    @assert isequal(materialize(df2, dd2), [missing, "x"])
+    release!(dd2.owner::ForeignOwner)
+    @assert _drained() == 0
+    println("dictionary ordered flag and nullable pool values round-trip ✓")
+    sp, ap = to_c_data(df, dd)
+    sdict = unsafe_load(sp).dictionary
+    adict = unsafe_load(ap).dictionary
+    smoved = Ref(unsafe_load(sdict))
+    amoved = Ref(unsafe_load(adict))
+    _store_field!(sdict, :release, Ptr{Cvoid}(C_NULL))
+    _store_field!(adict, :release, Ptr{Cvoid}(C_NULL))
+    _release_c!(sp)
+    _release_c!(ap)
+    @assert _drained() == 1
+    GC.@preserve smoved amoved begin
+        movedf, movedd = from_c_data(
+            Base.unsafe_convert(Ptr{CArrowSchema}, smoved),
+            Base.unsafe_convert(Ptr{CArrowArray}, amoved),
+        )
+        @assert isequal(materialize(movedf, movedd), [missing, "x"])
+        release!(movedd.owner::ForeignOwner)
+    end
+    @assert _drained() == 0
+    println("moved dictionaries retain aggregate ownership until release ✓")
+    kf, kd = fromjulia("key", ["a"])
+    mvf, mvd = fromjulia("value", Int64[7])
+    entriesf = Field("entries", StructType(); nullable=false, children=[kf, mvf])
+    entriesd = ArrayData(StructType(), 1, [BufferSlice()]; children=[kd, mvd], nullcount=0)
+    mt = MapType(true)
+    mapf = Field("map", mt; children=[entriesf])
+    mapd = ArrayData(
+        mt,
+        1,
+        [BufferSlice(), AC._databuffer(Int32[0, 1])];
+        children=[entriesd],
+        nullcount=0,
+    )
+    sp, ap = to_c_data(mapf, mapd)
+    @assert (unsafe_load(sp).flags & ARROW_FLAG_MAP_KEYS_SORTED) != 0
+    mapf2, mapd2 = from_c_data(sp, ap)
+    @assert (mapf2.type::MapType).keyssorted
+    @assert materialize(mapf2, mapd2) == [["a" => 7]]
+    release!(mapd2.owner::ForeignOwner)
+    @assert _drained() == 0
+    println("map sorted-key flag round-trips ✓")
+    # Moving a nested subtree keeps all of its descendants live. Releasing
+    # the moved entries struct recursively releases its key/value children.
+    sp, ap = to_c_data(mapf, mapd)
+    sentries = unsafe_load(unsafe_load(sp).children, 1)
+    aentries = unsafe_load(unsafe_load(ap).children, 1)
+    smoved = Ref(unsafe_load(sentries))
+    amoved = Ref(unsafe_load(aentries))
+    _store_field!(sentries, :release, Ptr{Cvoid}(C_NULL))
+    _store_field!(aentries, :release, Ptr{Cvoid}(C_NULL))
+    _release_c!(sp)
+    _release_c!(ap)
+    @assert _drained() == 1
+    GC.@preserve smoved amoved begin
+        movedf, movedd = from_c_data(
+            Base.unsafe_convert(Ptr{CArrowSchema}, smoved),
+            Base.unsafe_convert(Ptr{CArrowArray}, amoved),
+        )
+        @assert materialize(movedf, movedd) == [["key" => "a", "value" => 7]]
+        release!(movedd.owner::ForeignOwner)
+    end
+    @assert _drained() == 0
+    println("moved nested subtrees retain descendants until release ✓")
+    # Two moved siblings keep one aggregate alive. Releasing the first does
+    # not free either tree; the second release performs the single reap.
+    af, ad = fromjulia("a", Int64[1, 2])
+    bf, bd = fromjulia("b", Int64[3, 4])
+    sf = Field("s", StructType(); children=[af, bf])
+    sd = ArrayData(StructType(), 2, [BufferSlice()]; children=[ad, bd], nullcount=0)
+    sp, ap = to_c_data(sf, sd)
+    smoved = Ref{CArrowSchema}[]
+    amoved = Ref{CArrowArray}[]
+    for i = 1:2
+        source_s = unsafe_load(unsafe_load(sp).children, i)
+        source_a = unsafe_load(unsafe_load(ap).children, i)
+        push!(smoved, Ref(unsafe_load(source_s)))
+        push!(amoved, Ref(unsafe_load(source_a)))
+        _store_field!(source_s, :release, Ptr{Cvoid}(C_NULL))
+        _store_field!(source_a, :release, Ptr{Cvoid}(C_NULL))
+    end
+    _release_c!(sp)
+    _release_c!(ap)
+    @assert _drained() == 1
+    for (i, expected_values) in enumerate(([1, 2], [3, 4]))
+        GC.@preserve smoved amoved begin
+            movedf, movedd = from_c_data(
+                Base.unsafe_convert(Ptr{CArrowSchema}, smoved[i]),
+                Base.unsafe_convert(Ptr{CArrowArray}, amoved[i]),
+            )
+            @assert materialize(movedf, movedd) == expected_values
+            release!(movedd.owner::ForeignOwner)
+        end
+        @assert _drained() == (i == 2 ? 0 : 1)
+    end
+    println("multiple moved siblings defer one aggregate reap ✓")
+    # Even when every imported buffer pointer is NULL, ArrayData owns the
+    # ForeignOwner. GC cannot release the producer while the empty array lives.
+    ef, ed = fromjulia("empty", Int64[])
+    sp, ap = to_c_data(ef, ed)
+    ef2, ed2 = from_c_data(sp, ap)
+    _reap!()
+    ownerref = WeakRef(ed2.owner)
+    GC.gc(true)
+    @assert ownerref.value !== nothing
+    @assert _drained() == 1          # the export still roots the source
+    @assert isempty(materialize(ef2, ed2))
+    release!(ed2.owner::ForeignOwner)
+    @assert _drained() == 0
+    println("empty imports retain their shared foreign owner ✓")
+    # Natural collection of a forgotten imported tree is also an exactly-once
+    # release path: the ForeignOwner finalizer runs the producer callback, so
+    # the export root becomes reapable without any caller calling release!.
+    ff, fd = fromjulia("finalized", Int64[1])
+    sp, ap = to_c_data(ff, fd)
+    _import_and_forget(sp, ap)
+    for _ = 1:10
+        _drained() == 0 && break
+        GC.gc(true)
+        yield()   # let queued finalizer work drain before rescanning
+    end
+    @assert _registry_count() == 0
+    println("natural foreign-owner finalization releases the producer ✓")
+    # Verifiable C structural failures are clean errors and still release
+    # both moved lifetimes exactly once.
+    bf, bd = fromjulia("bad", Int64[1])
+    sp, ap = to_c_data(bf, bd)
+    _store_field!(ap, :buffers, Ptr{Ptr{Cvoid}}(C_NULL))
+    @assert try
+        from_c_data(sp, ap)
+        false
+    catch e
+        e isa ValidationError
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == 0
+    println("invalid C pointer tables fail with exact cleanup ✓")
+    # Flags carry schema semantics, so the importer must reject unknown bits
+    # and known flags on layouts where those meanings do not apply. Silent
+    # acceptance would discard information that this adapter cannot preserve.
+    _expect_invalid_schema_flags!(Int64(8))
+    _expect_invalid_schema_flags!(ARROW_FLAG_DICTIONARY_ORDERED)
+    _expect_invalid_schema_flags!(ARROW_FLAG_MAP_KEYS_SORTED)
+    println("unknown and type-invalid schema flags fail with exact cleanup ✓")
+    # Imported C names must be valid UTF-8 (they become Field names). The
+    # failure happens after the array move, so both producer lifetimes must
+    # still be released exactly once.
+    nf, nd = fromjulia("name", Int64[1])
+    sp, ap = to_c_data(nf, nd)
+    unsafe_store!(unsafe_load(sp).name, 0xff, 1)
+    @assert try
+        from_c_data(sp, ap)
+        false
+    catch e
+        e isa ValidationError
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == 0
+
+    # Imported Utf8 CONTENT is not judged by the importer (semantic tier, the
+    # IPC reader's default); the opt-in `validate_full` on the returned pair
+    # is where invalid UTF-8 is caught.
+    uf, ud = fromjulia("utf8", ["a"])
+    sp, ap = to_c_data(uf, ud)
+    datap = Ptr{UInt8}(unsafe_load(unsafe_load(ap).buffers, 3))
+    unsafe_store!(datap, 0xff, 1)
+    uf2, ud2 = from_c_data(sp, ap)
+    @assert try
+        validate_full(uf2, ud2)
+        false
+    catch e
+        e isa ValidationError
+    end
+    release!(ud2.owner::ForeignOwner)
+    @assert _drained() == 0
+    @assert _registry_count() == 0
+    println("invalid imported names fail with exact cleanup; content policy is opt-in ✓")
+
+    # ---- C stream interface --------------------------------------------
+
+    # Export a two-batch stream through a caller-owned struct, move it into
+    # an importer, and compare both batches against the source. The stream,
+    # its get_schema result, and every get_next result are exports of their
+    # own, freed once the consumer has released each.
+    sbefore = _registry_count()
+    b1 = batch((xs=Int64[1, 2, 3], strs=["a", missing, "c"]))
+    b2 = batch((xs=Int64[4, 5], strs=[missing, "e"]))
+
+    # Every exported callback closes its C exception boundary: a NULL output
+    # slot is EINVAL with the reason in get_last_error, a NULL stream is
+    # inert, and an importer refuses a stream missing a required callback.
+    callbackref = Ref{CArrowArrayStream}()
+    GC.@preserve callbackref begin
+        callbackp = Base.unsafe_convert(Ptr{CArrowArrayStream}, callbackref)
+        export_stream!(callbackp, b1.schema, AC.RecordBatch[])
+        callbacks = callbackref[]
+        @assert ccall(
+            callbacks.get_last_error,
+            Ptr{UInt8},
+            (Ptr{CArrowArrayStream},),
+            callbackp,
+        ) == C_NULL
+        @assert ccall(
+            callbacks.get_schema,
+            Cint,
+            (Ptr{CArrowArrayStream}, Ptr{CArrowSchema}),
+            callbackp,
+            Ptr{CArrowSchema}(C_NULL),
+        ) == EINVAL
+        errorp = ccall(
+            callbacks.get_last_error,
+            Ptr{UInt8},
+            (Ptr{CArrowArrayStream},),
+            callbackp,
+        )
+        @assert errorp != C_NULL
+        @assert occursin("output pointer is NULL", unsafe_string(errorp))
+        @assert ccall(
+            callbacks.get_next,
+            Cint,
+            (Ptr{CArrowArrayStream}, Ptr{CArrowArray}),
+            callbackp,
+            Ptr{CArrowArray}(C_NULL),
+        ) == EINVAL
+        @assert ccall(
+            callbacks.get_last_error,
+            Ptr{UInt8},
+            (Ptr{CArrowArrayStream},),
+            Ptr{CArrowArrayStream}(C_NULL),
+        ) == C_NULL
+        ccall(
+            callbacks.release,
+            Cvoid,
+            (Ptr{CArrowArrayStream},),
+            Ptr{CArrowArrayStream}(C_NULL),
+        )
+        _store_field!(callbackp, :get_last_error, Ptr{Cvoid}(C_NULL))
+        @assert try
+            from_c_stream(callbackp)
+            false
+        catch e
+            e isa ArgumentError
+        end
+        ccall(callbacks.release, Cvoid, (Ptr{CArrowArrayStream},), callbackp)
+        @assert callbackref[].release == C_NULL
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == sbefore
+    println("stream callbacks close errors and required callbacks are enforced ✓")
+
+    # One task uses an imported stream at a time. Hold one pull open inside
+    # the producer: a second pull and a release fail at once, without
+    # touching the producer, and the first pull completes afterwards.
+    overlapref = Ref{CArrowArrayStream}()
+    GC.@preserve overlapref begin
+        overlapp = Base.unsafe_convert(Ptr{CArrowArrayStream}, overlapref)
+        entered = Channel{Nothing}(1)
+        resume = Channel{Nothing}(1)
+        rowf, rowd = fromjulia("x", Int64[7, 8])
+        rowsf = Field("", StructType(); nullable=false, children=[rowf])
+        rowsd = ArrayData(StructType(), 2, [BufferSlice()]; children=[rowd], nullcount=0)
+        overlapstream =
+            from_c_stream(one_batch_stream!(overlapp, rowsf, rowsd, (entered, resume)))
+        firstpull = @async nextbatch!(overlapstream)
+        take!(entered)
+        @assert try
+            nextbatch!(overlapstream)
+            false
+        catch e
+            e isa Base.ConcurrencyViolationError
+        end
+        @assert try
+            release!(overlapstream)
+            false
+        catch e
+            e isa Base.ConcurrencyViolationError
+        end
+        put!(resume, nothing)
+        overlapbatch = fetch(firstpull)
+        @assert overlapbatch isa AC.RecordBatch
+        @assert materialize(rowf, overlapbatch.columns[1]) == [7, 8]
+        @assert nextbatch!(overlapstream) === nothing
+        release!(overlapbatch.columns[1].owner::ForeignOwner)
+        release!(overlapstream)
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == sbefore
+    println("overlapping imported-stream calls fail and the cursor recovers ✓")
+
+    streamref = Ref{CArrowArrayStream}()
+    GC.@preserve streamref begin
+        spp = Base.unsafe_convert(Ptr{CArrowArrayStream}, streamref)
+        export_stream!(spp, b1.schema, AC.RecordBatch[b1, b2])
+        s = from_c_stream(spp)
+        @assert streamref[].release == C_NULL      # moved out of the source
+        @assert length(s.schema.fields) == 2
+        @assert [f.name for f in s.schema.fields] == ["xs", "strs"]
+        owners = ForeignOwner[]
+        for source in (b1, b2)
+            got = nextbatch!(s)
+            @assert got isa AC.RecordBatch
+            @assert got.nrows == source.nrows
+            for (i, f) in enumerate(s.schema.fields)
+                @assert isequal(
+                    collect(Any, materialize(f, got.columns[i])),
+                    collect(Any, materialize(source.schema.fields[i], source.columns[i])),
+                ) f.name
+            end
+            push!(owners, got.columns[1].owner::ForeignOwner)
+        end
+        @assert nextbatch!(s) === nothing
+        @assert nextbatch!(s) === nothing          # end of stream is sticky
+        release!(s)
+        release!(s)                                 # exactly-once
+        @assert try
+            nextbatch!(s)
+            false
+        catch e
+            e isa ArgumentError
+        end
+        foreach(release!, owners)
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == sbefore
+    println("C stream export/import round-trips with exact lifecycle ✓")
+    # Producer-side failures surface through get_last_error: batch two has
+    # non-monotonic offsets (a semantic-tier defect that structural
+    # construction cannot see), so its get_next reports EINVAL and the
+    # importer throws a ValidationError carrying the producer's message.
+    okf, okd = fromjulia("s", ["ok"])
+    badd = ArrayData(
+        Utf8Type(false),
+        1,
+        [BufferSlice(), AC._databuffer(Int32[1, 0]), AC._databuffer(UInt8[0x61])];
+        nullcount=0,
+    )
+    badsch = Schema(Field[okf])
+    streamref2 = Ref{CArrowArrayStream}()
+    GC.@preserve streamref2 begin
+        spp2 = Base.unsafe_convert(Ptr{CArrowArrayStream}, streamref2)
+        export_stream!(
+            spp2,
+            badsch,
+            AC.RecordBatch[
+                AC.RecordBatch(badsch, ArrayData[okd], 1),
+                AC.RecordBatch(badsch, ArrayData[badd], 1),
+            ],
+        )
+        s2 = from_c_stream(spp2)
+        first = nextbatch!(s2)
+        @assert first isa AC.RecordBatch
+        caught = try
+            nextbatch!(s2)
+            false
+        catch e
+            e isa ValidationError && occursin("monotonic", e.msg)
+        end
+        @assert caught
+        release!(s2)
+        release!(first.columns[1].owner::ForeignOwner)
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == sbefore
+    println("producer errors travel through get_last_error into clean throws ✓")
+    # Zero-batch streams end immediately; a moved source cannot be imported
+    # twice; releasing the producer side directly leaves importer calls
+    # failing cleanly rather than crashing.
+    streamref3 = Ref{CArrowArrayStream}()
+    GC.@preserve streamref3 begin
+        spp3 = Base.unsafe_convert(Ptr{CArrowArrayStream}, streamref3)
+        export_stream!(spp3, b1.schema, AC.RecordBatch[])
+        s3 = from_c_stream(spp3)
+        @assert try
+            from_c_stream(spp3)
+            false
+        catch e
+            e isa ArgumentError
+        end
+        @assert nextbatch!(s3) === nothing
+        release!(s3)
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == sbefore
+    println("zero-batch streams, double import, and release edges hold ✓")
+    # A C stream batch is a struct array. Null struct rows have no record-batch
+    # form and must be refused, not dropped; a struct offset and children that
+    # run past the struct select the visible child window.
+    rowf, rowd = fromjulia("x", Int64[10, 20, 30, 40, 50])
+    rowsf = Field("", StructType(); nullable=false, children=[rowf])
+    rowsref = Ref{CArrowArrayStream}()
+    GC.@preserve rowsref begin
+        rowsp = Base.unsafe_convert(Ptr{CArrowArrayStream}, rowsref)
+        nullrows = ArrayData(
+            StructType(),
+            5,
+            [AC._bitmapbuffer(Bool[1, 0, 1, 1, 1])];
+            children=[rowd],
+            nullcount=1,
+        )
+        rows = from_c_stream(one_batch_stream!(rowsp, rowsf, nullrows))
+        @assert try
+            nextbatch!(rows)
+            false
+        catch e
+            e isa ValidationError && occursin("null rows", e.msg)
+        end
+        release!(rows)
+        window = ArrayData(
+            StructType(),
+            2,
+            [BufferSlice()];
+            offset=2,
+            children=[rowd],
+            nullcount=0,
+        )
+        rows = from_c_stream(one_batch_stream!(rowsp, rowsf, window))
+        got = nextbatch!(rows)
+        @assert got.nrows == 2
+        @assert materialize(got.schema.fields[1], got.columns[1]) == Any[30, 40]
+        @assert nextbatch!(rows) === nothing
+        release!(rows)
+        release!(got.columns[1].owner::ForeignOwner)
+    end
+    @assert _drained() == 0
+    @assert _registry_count() == sbefore
+    println("C stream struct batches refuse null rows and use their child window ✓")
+    # Field metadata crosses the C boundary (the C data interface blob:
+    # int32 pair count, length-prefixed keys and values), recursively
+    # through children and dictionary value fields; absent metadata stays
+    # NULL and imports as nothing.
+    mleaf = Field("item", IntType(64, true); nullable=false, metadata=["lk" => "lv"])
+    _, mld = fromjulia("l", [Int64[1, 2], Int64[3]])
+    mlist = Field(
+        "l",
+        ListType(false);
+        nullable=false,
+        metadata=["k" => "v", "empty" => ""],
+        children=[mleaf],
+    )
+    msp, map_ = to_c_data(mlist, mld)
+    mf2, mld2 = from_c_data(msp, map_)
+    @assert collect(mf2.metadata) == ["k" => "v", "empty" => ""]
+    @assert collect(mf2.children[1].metadata) == ["lk" => "lv"]
+    @assert getvalue(mf2, mld2, 1) == Any[1, 2]
+    release!(mld2.buffers[2].region::OwnerRegion)
+    _reap!()
+    dvf, dvd = AC.fromjulia_dict("d", ["lo", "hi"], [0, 1, missing])
+    dmf = Field(
+        "d",
+        dvf.type;
+        nullable=dvf.nullable,
+        metadata=["dk" => "dv"],
+        children=collect(Field, dvf.children),
+    )
+    dsp, dap = to_c_data(dmf, dvd)
+    # Dictionary field metadata rides the OUTER wrapper node (the C++
+    # bridge exports field metadata there; PyArrow imports only the
+    # wrapper's pairs); the dependent value node carries none.
+    dsch = unsafe_load(dsp)
+    @assert dsch.metadata != C_NULL
+    @assert unsafe_load(dsch.dictionary).metadata == C_NULL
+    df2, dd2 = from_c_data(dsp, dap)
+    @assert collect(df2.metadata) == ["dk" => "dv"]
+    @assert getvalue(df2, dd2, 2) == "hi"
+    release!(dd2.buffers[2].region::OwnerRegion)
+    _reap!()
+    # Canonical (`arrow.`) extension pairs name the dictionary's VALUE type:
+    # they ride the value node (on the wrapper they would declare dictionary
+    # storage, which PyArrow refuses), and import rejoins them after the
+    # wrapper's pairs.
+    extmeta = [
+        "dk" => "dv",
+        "ARROW:extension:name" => "arrow.json",
+        "ARROW:extension:metadata" => "",
+    ]
+    xf = Field(
+        "d",
+        dvf.type;
+        nullable=dvf.nullable,
+        metadata=extmeta,
+        children=collect(Field, dvf.children),
+    )
+    xsp, xap = to_c_data(xf, dvd)
+    xsch = unsafe_load(xsp)
+    @assert Arrow._import_cmetadata(xsch.metadata) == extmeta[1:1]
+    @assert Arrow._import_cmetadata(unsafe_load(xsch.dictionary).metadata) == extmeta[2:3]
+    xf2, xd2 = from_c_data(xsp, xap)
+    @assert collect(xf2.metadata) == extmeta
+    release!(xd2.buffers[2].region::OwnerRegion)
+    _reap!()
+    # Other extension names stay on the wrapper as field metadata, where a
+    # consumer that does not know them keeps them.
+    appmeta =
+        ["ARROW:extension:name" => "dict-extension", "ARROW:extension:metadata" => "m"]
+    af = Field(
+        "d",
+        dvf.type;
+        nullable=dvf.nullable,
+        metadata=appmeta,
+        children=collect(Field, dvf.children),
+    )
+    asp, aap = to_c_data(af, dvd)
+    asch = unsafe_load(asp)
+    @assert Arrow._import_cmetadata(asch.metadata) == appmeta
+    @assert unsafe_load(asch.dictionary).metadata == C_NULL
+    af2, ad2 = from_c_data(asp, aap)
+    @assert collect(af2.metadata) == appmeta
+    release!(ad2.buffers[2].region::OwnerRegion)
+    _reap!()
+    # A foreign producer annotating the DEPENDENT node too (extension-type
+    # metadata is legal there) loses no pair on import: wrapper pairs
+    # first, then the dependent node's.
+    wsp, wap = to_c_data(dmf, dvd)
+    wsch0 = unsafe_load(wsp)
+    vsch0 = unsafe_load(wsch0.dictionary)
+    wblob = vcat(
+        reinterpret(UInt8, Int32[1]),
+        reinterpret(UInt8, Int32[2]),
+        codeunits("vk"),
+        reinterpret(UInt8, Int32[2]),
+        codeunits("vv"),
+    )
+    GC.@preserve wblob begin
+        unsafe_store!(
+            wsch0.dictionary,
+            CArrowSchema(
+                vsch0.format,
+                vsch0.name,
+                pointer(wblob),
+                vsch0.flags,
+                vsch0.n_children,
+                vsch0.children,
+                vsch0.dictionary,
+                vsch0.release,
+                vsch0.private_data,
+            ),
+        )
+        wf2, wd2 = from_c_data(wsp, wap)
+        @assert collect(wf2.metadata) == ["dk" => "dv", "vk" => "vv"]
+        release!(wd2.buffers[2].region::OwnerRegion)
+        _reap!()
+    end
+    pf, pd = fromjulia("plain", Int64[1])
+    psp, pap = to_c_data(pf, pd)
+    pf2, pd2 = from_c_data(psp, pap)
+    @assert pf2.metadata === nothing
+    release!(pd2.buffers[2].region::OwnerRegion)
+    _reap!()
+    # Hostile blobs refuse: negative counts and lengths would wrap the walk.
+    for negblob in (
+        reinterpret(UInt8, Int32[-1]),
+        vcat(reinterpret(UInt8, Int32[1]), reinterpret(UInt8, Int32[-5])),
+    )
+        blob = collect(negblob)
+        caught = try
+            GC.@preserve blob Arrow._import_cmetadata(pointer(blob))
+            false
+        catch e
+            e isa ValidationError
+        end
+        @assert caught
+    end
+    if Sys.iswindows()
+        println("C-string POSIX guard-page child skipped on Windows ✓")
+    else
+        guardscript = joinpath(@__DIR__, "cstring_guard_child.jl")
+        guardcmd = `$(Base.julia_cmd()) --startup-file=no --project=$(Base.active_project()) $guardscript`
+        success(guardcmd) || error("C-string guard-page child failed")
+    end
+    println("field metadata crosses the C boundary ✓")
+    # Schema-level metadata rides the C stream's struct-typed schema node
+    # (the C++/pyarrow convention for `schema.metadata`) in both directions.
+    smf, smd = fromjulia("x", Int64[1, 2])
+    smsch =
+        Schema(Field[smf]; metadata=["schema-k" => "schema-v", "dup" => "a", "dup" => "b"])
+    smref = Ref{CArrowArrayStream}()
+    GC.@preserve smref begin
+        smp = Base.unsafe_convert(Ptr{CArrowArrayStream}, smref)
+        export_stream!(smp, smsch, AC.RecordBatch[AC.RecordBatch(smsch, ArrayData[smd], 2)])
+        sms = from_c_stream(smp)
+        @assert collect(sms.schema.metadata) ==
+                ["schema-k" => "schema-v", "dup" => "a", "dup" => "b"]
+        smb = nextbatch!(sms)
+        @assert smb isa AC.RecordBatch
+        @assert collect(smb.schema.metadata) == collect(smsch.metadata)
+        @assert nextbatch!(sms) === nothing
+        release!(sms)
+        release!(smb.columns[1].owner::ForeignOwner)
+    end
+    _reap!()
+    # A schema without metadata imports as `nothing`, not an empty list.
+    plainsch = Schema(Field[smf])
+    plainref = Ref{CArrowArrayStream}()
+    GC.@preserve plainref begin
+        plainp = Base.unsafe_convert(Ptr{CArrowArrayStream}, plainref)
+        export_stream!(plainp, plainsch, AC.RecordBatch[])
+        plains = from_c_stream(plainp)
+        @assert plains.schema.metadata === nothing
+        @assert nextbatch!(plains) === nothing
+        release!(plains)
+    end
+    _reap!()
+    # Metadata is opaque binary data, including schema-only streams.
+    binary = String([0xff, 0x00, 0x80])
+    for binsch in (
+        Schema(Field[smf]; metadata=[binary => "v"]),
+        Schema(Field[smf]; metadata=["k" => binary]),
+        Schema(Field[Field("x", IntType(64, true); metadata=["k" => binary])]),
+    )
+        binref = Ref{CArrowArrayStream}()
+        GC.@preserve binref begin
+            binp = Base.unsafe_convert(Ptr{CArrowArrayStream}, binref)
+            export_stream!(binp, binsch, AC.RecordBatch[])
+            bins = from_c_stream(binp)
+            @assert isequal(bins.schema.metadata, binsch.metadata)
+            @assert isequal(bins.schema.fields[1].metadata, binsch.fields[1].metadata)
+            @assert nextbatch!(bins) === nothing
+            release!(bins)
+            @assert binref[].release == C_NULL
+        end
+        _reap!()
+    end
+    println("schema metadata crosses the C stream boundary ✓")
+
+    # ---- tables ----------------------------------------------------------
+
+    # The 54-column matrix pyarrow built (test/fixtures-cdata/make_matrix.py):
+    # every column crosses both interfaces, in both directions, with the
+    # element types and values of an IPC read of the same bytes.
+    matrixbytes = read(joinpath(@__DIR__, "fixtures-cdata", "matrix.arrows"))
+    tipc = Arrow.Table(matrixbytes)
+    @assert length(Tables.columnnames(tipc)) == 54
+    function sametable(t)
+        ok =
+            Tables.columnnames(t) == Tables.columnnames(tipc) &&
+            Arrow.getmetadata(t) == Arrow.getmetadata(tipc)
+        for (i, nm) in enumerate(Tables.columnnames(tipc))
+            a = Tables.getcolumn(tipc, i)
+            b = Tables.getcolumn(t, i)
+            eltype(a) == eltype(b) && isequal(collect(a), collect(b)) && continue
+            ok = false
+            println("   MISMATCH ", nm, ": ", eltype(b), " vs ", eltype(a))
+        end
+        return ok
+    end
+    # Import alone: the IPC batches go out through the column-level interface
+    # and come back as the IPC read of them, whole or one batch at a time. One
+    # batch builds every column as the IPC read of that batch does, down to the
+    # column type.
+    raw = readstream(matrixbytes)
+    rawschema = Schema(collect(Field, raw.corefields); metadata=raw.schema.metadata)
+    sref = Ref{CArrowArrayStream}()
+    GC.@preserve sref begin
+        p = Base.unsafe_convert(Ptr{CArrowArrayStream}, sref)
+        export_stream!(p, rawschema, raw.batches)
+        @assert sametable(Arrow.Table(p))
+        export_stream!(p, rawschema, raw.batches)
+        @assert [Tables.rowcount(t) for t in Arrow.Stream(p)] == [4, 3]
+    end
+    sp, ap = to_c_data(_batchfield(rawschema), _structarray(raw.batches[1]))
+    tfirst = Arrow.Table(sp, ap)
+    ipcfirst = iterate(Arrow.Stream(matrixbytes))[1]
+    for (i, nm) in enumerate(Tables.columnnames(ipcfirst))
+        a = Tables.getcolumn(ipcfirst, i)
+        b = Tables.getcolumn(tfirst, i)
+        @assert typeof(a) == typeof(b) && isequal(collect(a), collect(b)) nm
+    end
+    println("C data and C stream imports read as the IPC read of the same batches ✓")
+
+    sp, ap = to_c_data(tipc)
+    @assert unsafe_load(ap).n_children == 54
+    @assert sametable(Arrow.Table(sp, ap))
+    sref = Ref{CArrowArrayStream}()
+    GC.@preserve sref begin
+        p = Base.unsafe_convert(Ptr{CArrowArrayStream}, sref)
+        export_stream!(p, Arrow.Stream(matrixbytes))        # two batches, two partitions
+        @assert sametable(Arrow.Table(p))
+        export_stream!(p, Arrow.Stream(matrixbytes))
+        parts = collect(Arrow.Stream(p))
+        @assert [Tables.rowcount(t) for t in parts] == [4, 3]
+        joined = (;
+            (
+                nm => vcat(
+                    collect(Tables.getcolumn(parts[1], i)),
+                    collect(Tables.getcolumn(parts[2], i)),
+                ) for (i, nm) in enumerate(Tables.columnnames(parts[1]))
+            )...
+        )
+        for (i, nm) in enumerate(Tables.columnnames(tipc))
+            @assert isequal(joined[nm], collect(Tables.getcolumn(tipc, i))) nm
+            @assert eltype(Tables.getcolumn(parts[1], i)) ==
+                    eltype(Tables.getcolumn(tipc, i)) nm
+        end
+    end
+    println("the 54-column matrix crosses both interfaces both ways as an IPC read ✓")
+
+    # An exported table is built as `Arrow.write` builds it: the same fields,
+    # column types, and values as the IPC bytes, for plain Julia values too.
+    mixed = (
+        i=[1, 2, missing],
+        f=[1.5, 2.5, 3.5],
+        s=["a", missing, "ccc"],
+        d=[Dates.Date(2020, 1, 1), Dates.Date(2021, 2, 3), missing],
+        dt=[
+            Dates.DateTime(2020, 1, 1, 12),
+            Dates.DateTime(2021, 2, 3, 4, 5, 6),
+            Dates.DateTime(2022, 3, 4),
+        ],
+        v=[[1, 2], Int[], [3]],
+        nt=[(a=1, b="x"), (a=2, b="y"), (a=3, b="z")],
+        p=PooledArray(["lo", "hi", "lo"]),
+    )
+    twrite = Arrow.Table(take!(Arrow.tobuffer(mixed)))
+    sp, ap = to_c_data(mixed)
+    tc = Arrow.Table(sp, ap)
+    for (i, nm) in enumerate(Tables.columnnames(twrite))
+        a = Tables.getcolumn(twrite, i)
+        b = Tables.getcolumn(tc, i)
+        @assert eltype(a) == eltype(b) nm
+        @assert isequal(collect(a), collect(b)) nm
+        fa = getfield(twrite, :schema).fields[i]
+        fb = getfield(tc, :schema).fields[i]
+        @assert AC.typeequal(fa.type, fb.type) && fa.nullable == fb.nullable nm
+    end
+    @assert Tables.columnnames(tc) == Tables.columnnames(twrite)
+    # The writer's keywords mean what they mean for `Arrow.write`.
+    sp, ap = to_c_data(mixed; dictencode=[:s])
+    tk = Arrow.Table(sp, ap)
+    @assert getfield(tk, :schema).fields[3].type isa DictionaryType
+    @assert getfield(tk, :schema).fields[8].type isa DictionaryType
+    @assert isequal(collect(tk.s), ["a", missing, "ccc"])
+    sp, ap = to_c_data(mixed; stringview=true)
+    tk = Arrow.Table(sp, ap)
+    @assert (getfield(tk, :schema).fields[3].type::ViewType).utf8
+    @assert isequal(collect(tk.s), ["a", missing, "ccc"])
+    @assert try
+        to_c_data(mixed; nosuchkeyword=1)
+        false
+    catch e
+        e isa ArgumentError
+    end
+    @assert try
+        to_c_data(mixed; compress=:zstd)
+        false
+    catch e
+        e isa ArgumentError
+    end
+    println("exported tables match Arrow.write's construction ✓")
+
+    # Exports cross without copying: a Vector column's address and an
+    # Arrow.Table view column's address are what the consumer sees.
+    xs = collect(Int64, 1:100)
+    sp, ap = to_c_data((x=xs,))
+    child = unsafe_load(unsafe_load(unsafe_load(ap).children, 1))
+    @assert unsafe_load(child.buffers, 2) == Ptr{Cvoid}(pointer(xs))
+    @assert isequal(collect(Arrow.Table(sp, ap).x), xs)
+    tv = Arrow.Table(take!(Arrow.tobuffer((y=collect(1.0:100.0),))))
+    sp, ap = to_c_data(tv)
+    child = unsafe_load(unsafe_load(unsafe_load(ap).children, 1))
+    source = only(getfield(tv, :regions))
+    @assert UInt(source.ptr) <=
+            UInt(unsafe_load(child.buffers, 2)) <
+            UInt(source.ptr) + source.len
+    @assert isequal(collect(Arrow.Table(sp, ap).y), collect(1.0:100.0))
+    println("exports cross without copying ✓")
+
+    # A struct array with no rows is a table with no rows; a non-struct array
+    # is a one-column table; a table too large for one batch names the stream.
+    sp, ap = to_c_data((x=Int64[],))
+    @assert Tables.rowcount(Arrow.Table(sp, ap)) == 0
+    sp, ap = to_c_data((;))
+    @assert Tables.rowcount(Arrow.Table(sp, ap)) == 0
+    sp, ap = to_c_data(fromjulia("only", Int64[5, 6])...)
+    tone = Arrow.Table(sp, ap)
+    @assert Tables.columnnames(tone) == [:only] && collect(tone.only) == [5, 6]
+    # An empty first partition only fixes the schema, as for a stream.
+    sp, ap = to_c_data(Tables.partitioner([(x=Int64[],), (x=[1, 2],)]))
+    @assert collect(Arrow.Table(sp, ap).x) == [1, 2]
+    @assert try
+        to_c_data(Tables.partitioner([(x=[1],), (x=[2],)]))
+        false
+    catch e
+        e isa ArgumentError && occursin("export_stream!", e.msg)
+    end
+    sref2 = Ref{CArrowArrayStream}()
+    GC.@preserve sref2 begin
+        p = Base.unsafe_convert(Ptr{CArrowArrayStream}, sref2)
+        export_stream!(p, Tables.partitioner([(x=[1],), (x=[2],)]))
+        tp = Arrow.Table(p)
+        @assert collect(tp.x) == [1, 2]
+        @assert eltype(tp.x) == Union{Missing,Int}        # several partitions: nullable
+        export_stream!(p, (x=Int64[],))                    # no rows: no batches
+        @assert Tables.rowcount(Arrow.Table(p)) == 0
+    end
+    println("empty, one-column, and partitioned tables cross ✓")
+
+    # Imported tables read the producer's memory in place: `release!(table)`
+    # refuses further column access, and the producer's release runs once
+    # the table and its columns are garbage collected.
+    key = _released_import_key()
+    for _ = 1:10
+        _registered(key) || break
+        GC.gc(true)
+        yield()
+        _reap!()
+    end
+    @assert !_registered(key)
+    # Exporting a released table is refused; exporting a table and then
+    # releasing it keeps the export valid.
+    tr = Arrow.Table(take!(Arrow.tobuffer((x=[1, 2, 3],))))
+    sp, ap = to_c_data(tr)
+    release!(tr)
+    @assert collect(Arrow.Table(sp, ap).x) == [1, 2, 3]
+    @assert try
+        to_c_data(tr)
+        false
+    catch e
+        e isa InvalidStateException
+    end
+    println("release! of an imported table refuses access; memory follows the columns ✓")
+
+    # `Arrow.Stream(streamptr)` pulls one batch per iteration and is released
+    # like any stream: releasing it, or a table it yielded, stops iteration and
+    # column access, and columns already taken stay valid.
+    sref3 = Ref{CArrowArrayStream}()
+    GC.@preserve sref3 begin
+        p = Base.unsafe_convert(Ptr{CArrowArrayStream}, sref3)
+        export_stream!(p, Tables.partitioner([(x=[1, 2],), (x=[3],), (x=[4, 5, 6],)]))
+        cs = Arrow.Stream(p)
+        @assert Tables.columnnames(cs) == [:x]
+        @assert Tables.schema(cs).types == (Union{Missing,Int},)
+        @assert try
+            length(cs)
+            false
+        catch e
+            e isa ArgumentError
+        end
+        first_table, state = iterate(cs)
+        firstx = first_table.x
+        @assert collect(firstx) == [1, 2]
+        release!(cs)
+        @assert try
+            iterate(cs, state)
+            false
+        catch e
+            e isa InvalidStateException
+        end
+        @assert try
+            first_table.x
+            false
+        catch e
+            e isa InvalidStateException
+        end
+        @assert collect(firstx) == [1, 2]
+        export_stream!(p, Tables.partitioner([(x=[1, 2],), (x=[3],)]))
+        cs = Arrow.Stream(p; stringtype=String)
+        first_table, state = iterate(cs)
+        release!(first_table)
+        @assert try
+            iterate(cs, state)
+            false
+        catch e
+            e isa InvalidStateException
+        end
+        export_stream!(p, Tables.partitioner([(x=[1, 2],), (x=[3],)]))
+        @assert [collect(t.x) for t in Arrow.Stream(p; stringtype=String)] == [[1, 2], [3]]
+        @assert try
+            Arrow.Stream(p; nosuch=1)
+            false
+        catch e
+            e isa ArgumentError && occursin("stringtype, ntasks, and limits", e.msg)
+        end
+        export_stream!(p, (x=[1, 2],))
+        @assert try
+            Arrow.Table(p; select=[:x])
+            false
+        catch e
+            e isa ArgumentError && occursin("select", e.msg)
+        end
+        @assert sref3[].release != C_NULL               # a refused keyword moves nothing
+        release!(Arrow.Table(p))
+    end
+    println("Arrow.Stream over a C stream pulls one batch at a time ✓")
+
+    # `deepcopy` of imported data shares its ownership: after the source is
+    # released the copy's reads fail cleanly, and releasing the copy is inert.
+    dcf, dcd = fromjulia("deep", Int64[1, 2, 3])
+    sp, ap = to_c_data(dcf, dcd)
+    dkey = _exportkey(ap)
+    dcf2, dcd2 = from_c_data(sp, ap)
+    dcopy = deepcopy(dcd2)
+    @assert materialize(dcf2, dcopy) == [1, 2, 3]
+    release!(dcd2.owner::ForeignOwner)
+    @assert try
+        materialize(dcf2, dcopy)
+        false
+    catch e
+        e isa InvalidStateException
+    end
+    release!(dcopy.owner::ForeignOwner)
+    _reapreleased!()
+    @assert !_registered(dkey)
+    println("deepcopy of imported data shares its owner ✓")
+
+    # A vector exported zero-copy and then resized: the consumer keeps reading
+    # the bytes it was given, because the export roots the vector's storage,
+    # not the vector. Julia 1.10 has no separate storage object to root.
+    if VERSION >= v"1.11"
+        resized = collect(Int64, 1:1000)
+        resizedf, resizedd = fromjulia("resized", resized)
+        sp, ap = to_c_data(resizedf, resizedd)
+        rkey = _exportkey(ap)
+        resizedf2, resizedd2 = from_c_data(sp, ap)
+        @assert AC.sliceptr(resizedd2.buffers[2]) == Ptr{UInt8}(pointer(resized))
+        storage = WeakRef(AC._storageroot(resized))
+        resize!(resized, 1_000_000)
+        resized = nothing
+        resizedd = nothing
+        GC.gc(true)
+        @assert storage.value !== nothing
+        @assert materialize(Int64, resizedf2, resizedd2) == 1:1000
+        release!(resizedd2.owner::ForeignOwner)
+        _reapreleased!()
+        @assert !_registered(rkey)
+        println("resizing an exported vector keeps the consumer's bytes alive ✓")
+    end
+
+    childscript = joinpath(@__DIR__, "cdata_stress_child.jl")
+    stresscmd = `$(Base.julia_cmd()) --startup-file=no --threads=4 --project=$(Base.active_project()) $childscript`
+    success(stresscmd) || error("threaded C Data stress failed")
+    println("threaded C Data stress passed in a four-thread child ✓")
+
+    println()
+    println("C Data ownership and round-trip checks passed.")
+end
diff --git a/test/cdata_stress_child.jl b/test/cdata_stress_child.jl
new file mode 100644
index 00000000..574837c6
--- /dev/null
+++ b/test/cdata_stress_child.jl
@@ -0,0 +1,26 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Four-thread child the C Data battery re-execs for its concurrency stress
+# (a fresh process so thread count and lifecycle state start clean).
+module CdataStressChild
+
+include(joinpath(@__DIR__, "support", "CDataStressSupport.jl"))
+import .CDataStressSupport
+
+CDataStressSupport.run()
+
+end # module
diff --git a/test/cloudstore_tests.jl b/test/cloudstore_tests.jl
new file mode 100644
index 00000000..01552607
--- /dev/null
+++ b/test/cloudstore_tests.jl
@@ -0,0 +1,107 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The CloudStore.jl extension end to end against a local S3-compatible
+# server (CloudBaseTest's Minio harness): a `CloudStore.Object` is an
+# `Arrow.AbstractArrowSource`, so `Arrow.Table(obj; scan=…)` reads through
+# HTTP Range requests, and the whole-object paths agree with in-memory reads.
+
+module CloudStoreTests
+
+using Test
+using Tables
+using Arrow
+using CloudStore
+using CloudBaseTest: Minio
+
+# Counts the requests a source receives.
+struct CountedSource{S} <: Arrow.AbstractArrowSource
+    inner::S
+    requests::Threads.Atomic{Int}
+end
+CountedSource(inner) = CountedSource(inner, Threads.Atomic{Int}(0))
+Arrow.sourcelength(s::CountedSource) = Arrow.sourcelength(s.inner)
+Arrow.concurrentreads(s::CountedSource) = Arrow.concurrentreads(s.inner)
+function Arrow.readrange(s::CountedSource, off, len)
+    Threads.atomic_add!(s.requests, 1)
+    return Arrow.readrange(s.inner, off, len)
+end
+
+@testset "CloudStore extension" begin
+    ext = Base.get_extension(Arrow, :ArrowCloudStoreExt)
+    @test ext !== nothing
+    part1 = (a=collect(Int64, 1:1000), b=["v$i" for i = 1:1000], c=rand(1000))
+    part2 = (a=collect(Int64, 1001:2000), b=["v$i" for i = 1001:2000], c=rand(1000))
+    fio = IOBuffer()
+    Arrow.write(fio, Tables.partitioner([part1, part2]); file=true)
+    filebytes = take!(fio)
+    sio = IOBuffer()
+    Arrow.write(sio, Tables.partitioner([part1, part2]); file=false)
+    streambytes = take!(sio)
+    Minio.with() do conf
+        credentials, bucket = conf.credentials, conf.store
+        CloudStore.put(bucket, "t.arrow", filebytes; credentials=credentials)
+        CloudStore.put(bucket, "t.arrows", streambytes; credentials=credentials)
+        obj = CloudStore.Object(bucket, "t.arrow"; credentials=credentials)
+        @test Arrow.sourcelength(ext.CloudObjectSource(obj)) == length(filebytes)
+        # one range, byte-exact against the object; a bounded concurrency
+        src = ext.CloudObjectSource(obj)
+        @test Arrow.readrange(src, 8, 16) == filebytes[9:24]
+        @test Arrow.readrange(src, length(filebytes) - 6, 6) == filebytes[(end - 5):end]
+        @test Arrow.readrange(src, 0, 0) == UInt8[]
+        @test Arrow.concurrentreads(src) == ext.CONCURRENT_RANGE_READS > 1
+        # a projected, windowed scan over the object
+        t = Arrow.Table(obj; scan=Tables.Scan(select=(:b,), limit=3, offset=1500))
+        @test Tables.columnnames(t) == [:b]
+        @test t.b == ["v1501", "v1502", "v1503"]
+        # a filter that keeps rows of the second batch only
+        t2 = Arrow.Table(obj; scan=Tables.Scan(select=(:a,), filter=Tables.col(:a) > 1990))
+        @test t2.a == collect(1991:2000)
+        # whole-object reads agree with the in-memory reads
+        full = Arrow.Table(obj)
+        mem = Arrow.Table(filebytes)
+        @test Tables.columnnames(full) == Tables.columnnames(mem)
+        @test full.a == mem.a && full.b == mem.b && full.c == mem.c
+        sobj = CloudStore.Object(bucket, "t.arrows"; credentials=credentials)
+        st = Arrow.Table(sobj)
+        @test st.a == mem.a && st.b == mem.b
+        @test [length(batch.a) for batch in Arrow.Stream(sobj)] == [1000, 1000]
+        @test [length(batch.a) for batch in Arrow.Stream(obj)] == [1000, 1000]
+        # Over a 9.6 MB file: a whole read is the tail plus two 8 MiB-bound
+        # ranges; a Stream is the tail plus one range per batch.
+        big = Tables.partitioner([(n=collect(Int64, 1:600_000),) for _ = 1:2])
+        bigbytes = take!(Arrow.write(IOBuffer(), big; file=true))
+        CloudStore.put(bucket, "big.arrow", bigbytes; credentials=credentials)
+        bigobj = CloudStore.Object(bucket, "big.arrow"; credentials=credentials)
+        counted = CountedSource(ext.CloudObjectSource(bigobj))
+        @test length(Arrow.Table(counted).n) == 1_200_000
+        @test counted.requests[] == 3
+        counted = CountedSource(ext.CloudObjectSource(bigobj))
+        @test [b.n[end] for b in Arrow.Stream(counted)] == [600_000, 600_000]
+        @test counted.requests[] == 3
+        # A handle is pinned to the object version it was made from: after the
+        # key is overwritten, its next range read fails (If-Match) rather than
+        # mixing bytes of two versions across request rounds.
+        stale = ext.CloudObjectSource(obj)
+        CloudStore.put(bucket, "t.arrow", streambytes; credentials=credentials)
+        @test_throws Exception Arrow.readrange(stale, 8, 16)
+        @test_throws Exception Arrow.Table(obj; scan=Tables.Scan(select=(:a,)))
+        fresh = CloudStore.Object(bucket, "t.arrow"; credentials=credentials)
+        @test Arrow.Table(fresh).a == mem.a
+    end
+end
+
+end # module
diff --git a/test/columns_tests.jl b/test/columns_tests.jl
new file mode 100644
index 00000000..4c3ddc42
--- /dev/null
+++ b/test/columns_tests.jl
@@ -0,0 +1,1173 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Read-side column construction for flat layouts.
+
+using Test, Arrow, Tables, DataAPI, Dates, DataDecimals, Durations, PooledArrays
+using DataStrings: DataString, DataBytes, StringVector, BytesVector
+
+# A table sink that takes DataAPI metadata, as a DataFrame does.
+struct _MetaSink
+    columns::NamedTuple
+    metadata::Dict{String,Any}
+    colmetadata::Dict{Symbol,Dict{String,Any}}
+end
+_MetaSink(columns) = _MetaSink(columns, Dict{String,Any}(), Dict{Symbol,Dict{String,Any}}())
+DataAPI.metadatasupport(::Type{_MetaSink}) = (read=true, write=true)
+DataAPI.colmetadatasupport(::Type{_MetaSink}) = (read=true, write=true)
+DataAPI.metadata!(s::_MetaSink, key::AbstractString, value; style) =
+    (s.metadata[key]=value; s)
+DataAPI.colmetadata!(s::_MetaSink, col::Symbol, key::AbstractString, value; style) =
+    (get!(Dict{String,Any}, s.colmetadata, col)[key]=value; s)
+isdefined(Main, :rmmapped) || include(joinpath(@__DIR__, "support", "mapped.jl"))
+
+struct ColumnsBytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::ColumnsBytesSource) = length(s.data)
+Arrow.readrange(s::ColumnsBytesSource, off, len) = s.data[(off + 1):(off + len)]
+
+# Bytes `f(x)` allocates once compiled, measured inside a function so the
+# call is not a dynamic one.
+allocationsof(f, x) = (f(x); @allocated f(x))
+# The fewest bytes `f()` allocates over three calls: a collection that runs
+# finalizers or other tasks during one measurement adds to that one only.
+fewestbytes(f) = minimum(_ -> (@allocated f()), 1:3)
+# Whether column buffer `b` is `bytes`' own storage. From Julia 1.11 a column
+# over a byte vector holds a vector of its own over the same `Memory`.
+_samebytes(b, bytes) = b === bytes || (VERSION >= v"1.11" && b.ref.mem === bytes.ref.mem)
+# Bytes, and allocations, of one call. `@allocated` or `@allocations` written in
+# the testset below would make Julia compile the whole testset as one function
+# before running it, which takes minutes; it measures through these instead.
+callbytes(f, args...; kwargs...) = @allocated f(args...; kwargs...)
+callallocations(f, args...) = @allocations f(args...)
+
+function arrowbytes(table; kw...)
+    io = IOBuffer()
+    Arrow.write(io, table; kw...)
+    return take!(io)
+end
+
+# Reads of a mapped file run in their own frame, so no temporary outlives
+# them and garbage collection can unmap the file before it is deleted.
+function mappedviews(path, n)
+    # Columns outlive their table: drop it and collect garbage.
+    x = Arrow.Table(path; mmap=true).x
+    s = Arrow.Table(path; mmap=true).s
+    for _ = 1:3
+        GC.gc(true)
+    end
+    @test sum(x) == n * (n + 1) ÷ 2 && s[n] == string(n)
+    # Release ends the table, not its taken columns.
+    t = Arrow.Table(path; mmap=true)
+    y = t.x
+    Arrow.release!(t)
+    @test_throws InvalidStateException t.x
+    @test_throws InvalidStateException copy(t)
+    GC.gc(true)
+    @test y[end] == n
+    # Replacing a file that live columns map keeps the old contents (Windows
+    # too: the writer renames a new file over the mapped one).
+    Arrow.write(path, Arrow.Table(path; mmap=true))
+    Arrow.write(path, (x=collect((-n):-1),); file=true)
+    GC.gc(true)
+    @test x[1] == 1 && y[1] == 1 && Arrow.Table(path).x[1] == -n
+    return nothing
+end
+
+function mappedentrypoints(tbl, bytes, path)
+    for t in (
+        Arrow.Table(bytes),
+        Arrow.Table(IOBuffer(bytes)),
+        Arrow.Table(path; mmap=true),
+        Arrow.Table(path; mmap=false),
+        only(collect(Arrow.Stream(bytes))),
+        only(collect(Arrow.Stream(path; mmap=true))),
+    )
+        @test t.x isa Arrow.Primitive && isequal(collect(t.x), tbl.x)
+        @test t.s isa StringVector && t.s == tbl.s
+        @test t.d isa Arrow.Primitive && t.d == tbl.d
+    end
+    return nothing
+end
+
+@testset "column reads" begin
+    @testset "decimals read in bulk, as stored" begin
+        n = 100_000
+        for (P, S, T) in
+            ((9, 2, Int32), (18, 3, Int64), (38, 4, Int128), (76, 5, DataDecimals.Int256))
+            D = Decimal{P,S,T}
+            vals = [reinterpret(D, T(i) * T(7) - T(3)) for i = 1:n]
+            nullable = Union{Missing,D}[isodd(i) ? vals[i] : missing for i = 1:n]
+            for col in (vals, nullable)
+                # A file of each Arrow width (Arrow.write writes decimal128 or
+                # decimal256; other writers write decimal32/64 too).
+                t32 = Arrow.AC.DecimalType(P, S, 8sizeof(T))
+                present = [x !== missing for x in col]
+                data = T[x === missing ? zero(T) : reinterpret(T, x) for x in col]
+                validity =
+                    col === nullable ? Arrow.AC._bitmapbuffer(present) :
+                    Arrow.AC.BufferSlice()
+                d = Arrow.AC.ArrayData(
+                    t32,
+                    n,
+                    [validity, Arrow.AC._databuffer(data)];
+                    nullcount=count(!, present),
+                )
+                sch = Arrow.AC.Schema([Arrow.AC.Field("d", t32; nullable=col === nullable)])
+                bytes = Arrow.writefile(sch, [Arrow.AC.RecordBatch(sch, [d], n)])
+                t = Arrow.Table(bytes)
+                @test eltype(t.d) == eltype(col)
+                @test isequal(collect(t.d), col)
+                # One bulk copy per column: no allocation per value.
+                @test callallocations(Arrow.Table, bytes) < 10_000
+            end
+        end
+        # A decimal no `Decimal` type holds (a negative scale, or a scale above
+        # the precision) is a view of its storage: integers, or the stored bytes
+        # at 128 and 256 bits. Nested in a list, it reads as typed rows.
+        AC = Arrow.AC
+        bytesof(x) = collect(reinterpret(UInt8, [x]))
+        lt = AC.ListType(false)
+        for (t, raw) in (
+            (AC.DecimalType(5, -1, 32), Int32[99_999, -7]),
+            (AC.DecimalType(12, -3, 64), Int64[-999_999_999_999, 0]),
+            (AC.DecimalType(10, -2, 128), Int128[123, -5]),
+            (AC.DecimalType(2, 4, 256), DataDecimals.Int256[1, -1]),
+        )
+            want = eltype(raw) <: Union{Int32,Int64} ? raw : bytesof.(raw)
+            df = AC.Field("d", t; nullable=false)
+            dd = AC.ArrayData(t, 2, [AC.BufferSlice(), AC._databuffer(raw)]; nullcount=0)
+            lf = AC.Field(
+                "l",
+                lt;
+                nullable=false,
+                children=[AC.Field("item", t; nullable=false)],
+            )
+            offsets = AC._databuffer(Int32[0, 2, 2])
+            ld =
+                AC.ArrayData(lt, 2, [AC.BufferSlice(), offsets]; children=[dd], nullcount=0)
+            sch = AC.Schema([df, lf])
+            tbl = Arrow.Table(Arrow.writefile(sch, [AC.RecordBatch(sch, [dd, ld])]))
+            @test tbl.d isa Arrow.Primitive && tbl.d == want
+            @test tbl.l[1] isa Arrow.ListValue && tbl.l[1] == want && isempty(tbl.l[2])
+            back = Arrow.readfile(take!(Arrow.write(IOBuffer(), tbl; file=true)))
+            @test [f.type for f in back.schema.fields] == [t, lt]
+            @test only(back.schema.fields[2].children).type == t
+            @test Arrow.Table(back).d == want
+        end
+    end
+
+    @testset "16-byte values read in place at any 8-byte alignment" begin
+        # pyarrow aligns buffers to 8 bytes only: read each file from a
+        # 16-byte boundary and from 8 bytes past one, so that one of the two
+        # places its 16-byte values off their natural alignment. 128-bit
+        # decimals and Polars' 128-bit integers are views either way.
+        n = 10_000
+        vals = [reinterpret(Decimal{15,2,Int128}, Int128(i) * 7) for i = 1:n]
+        ints = Int128.(1:n) .* typemax(Int64)
+        AC = Arrow.AC
+        f = AC.Field("i", AC.IntType(128, true); nullable=false)
+        d = AC.ArrayData(f.type, n, [AC.BufferSlice(), AC._databuffer(ints)]; nullcount=0)
+        sch = AC.Schema([f])
+        for (bytes, col, want) in (
+            (arrowbytes((d=vals,)), :d, vals),
+            (Arrow.writefile(sch, [AC.RecordBatch(sch, [d])]), :i, ints),
+        )
+            holder = Vector{UInt8}(undef, length(bytes) + 8)
+            for shift in (0, 8)
+                GC.@preserve holder begin
+                    shifted = unsafe_wrap(Array, pointer(holder) + shift, length(bytes))
+                    copyto!(shifted, bytes)
+                    @test UInt(pointer(shifted)) % 16 == shift
+                    t = Arrow.Table(shifted)
+                    c = Tables.getcolumn(t, col)
+                    @test c isa Arrow.Primitive && c == want
+                    @test fewestbytes(() -> Arrow.Table(shifted)) < 100_000
+                    @test copy(c) == want && sum(c) == sum(want)
+                    @test c .+ c == want .+ want
+                end
+            end
+        end
+    end
+
+    @testset "flat columns are read-only views" begin
+        cols = (
+            i=Int32[1, -2, 3],
+            f=Union{Missing,Float64}[1.5, missing, -0.0],
+            b=Union{Missing,Bool}[true, missing, false],
+            d=[Date(2024, 1, 1), Date(1969, 12, 31), Date(2000, 2, 29)],
+            t=[Time(0), Time(23, 59, 59, 999), Time(12)],
+            ts=[DateTime(2024, 1, 1, 12), DateTime(1970), DateTime(1900, 3, 4)],
+            dur=Union{Missing,Millisecond}[Millisecond(5), missing, Millisecond(-7)],
+            dec=[reinterpret(Decimal{10,2,Int64}, Int64(k)) for k in (125, -350, 0)],
+            iv=[
+                Durations.Duration(1, 2, 3),
+                Durations.Duration(0, 0, 0),
+                Durations.Duration(-1, 5, 7),
+            ],
+            u=UInt8[0x00, 0xff, 0x7f],
+        )
+        bytes = arrowbytes(cols)
+        t = Arrow.Table(bytes)
+        for (nm, want) in pairs(cols)
+            col = Tables.getcolumn(t, nm)
+            @test col isa Arrow.ArrowVector
+            @test isequal(collect(col), collect(want))
+            @test_throws ErrorException col[1] = col[2]
+            # push! and append! say so too (they resize first).
+            @test_throws ErrorException push!(col, col[1])
+            @test_throws ErrorException append!(col, col)
+            owned = copy(col)
+            @test owned isa Vector && isequal(owned, collect(col))
+        end
+        @test t.ts isa Arrow.Primitive{Durations.Timestamp{Millisecond}}
+        @test t.b isa Arrow.BoolVector{Union{Missing,Bool}}
+        # Strings and binary are DataStrings columns; `stringtype=String` copies.
+        sb = arrowbytes((s=Union{Missing,String}["a", missing, "a much longer string"],))
+        st = Arrow.Table(sb)
+        @test st.s isa StringVector{Union{Missing,DataString}}
+        @test isequal(st.s, ["a", missing, "a much longer string"])
+        binvalues = [UInt8[1, 2], UInt8[], collect(0x00:0x20)]
+        bf = Arrow.AC.Field("bin", Arrow.AC.BinaryType(false); nullable=false)
+        bd = Arrow.AC.ArrayData(
+            bf.type,
+            3,
+            [
+                Arrow.AC.BufferSlice(),
+                Arrow.AC._databuffer(Int32[0, 2, 2, 35]),
+                Arrow.AC._databuffer(reduce(vcat, binvalues)),
+            ];
+            nullcount=0,
+        )
+        bsch = Arrow.AC.Schema([bf])
+        bin = Arrow.Table(Arrow.writestream(bsch, [Arrow.AC.RecordBatch(bsch, [bd])])).bin
+        @test bin isa BytesVector{DataBytes} && bin == binvalues
+        ss = Arrow.Table(sb; stringtype=String)
+        @test ss.s isa Vector{Union{Missing,String}}
+        @test isequal(ss.s, ["a", missing, "a much longer string"])
+        @test_throws ArgumentError Arrow.Table(sb; stringtype=Symbol)
+        # Null columns.
+        @test Arrow.Table(arrowbytes((m=[missing, missing],))).m isa Vector{Missing}
+    end
+
+    @testset "multi-batch columns chain per-batch views" begin
+        parts = Tables.partitioner([
+            (x=Int64[1, 2], s=["a", "bb"], c=PooledArray(["u", "v"])),
+            (x=Int64[3], s=["a fairly long string value"], c=PooledArray(["v"])),
+        ])
+        for file in (true, false)
+            t = Arrow.Table(arrowbytes(parts; file=file))
+            # Several partitions declare every field nullable.
+            @test t.x isa Arrow.ChainedVector{Union{Missing,Int64},<:Arrow.Primitive}
+            @test t.x == [1, 2, 3] &&
+                  sum(t.x) == 6 &&
+                  copy(t.x) isa Vector{Union{Missing,Int64}}
+            # One StringVector spans every batch.
+            @test t.s isa StringVector && t.s == ["a", "bb", "a fairly long string value"]
+            @test collect(t.c) == ["u", "v", "v"]
+        end
+        # A partition with no rows adds no record batch.
+        noparts = Tables.partitioner([(x=Int8[], b=Bool[]), (x=Int8[], b=Bool[])])
+        @test isempty(collect(Arrow.Stream(arrowbytes(noparts; file=false))))
+        # Empty batches (other writers write them) chain to a vector with no
+        # chunks; scans still slice it.
+        xf, xd = Arrow.AC.fromjulia("x", Int8[])
+        bf, bd = Arrow.AC.fromjulia("b", Bool[])
+        esch = Arrow.AC.Schema([
+            Arrow.AC.Field("x", xf.type; nullable=true),
+            Arrow.AC.Field("b", bf.type; nullable=true),
+        ])
+        ebatch() = Arrow.AC.RecordBatch(esch, [xd, bd], 0)
+        empty = Arrow.writestream(esch, [ebatch(), ebatch()])
+        @test length(collect(Arrow.Stream(empty))) == 2
+        for source in (empty, ColumnsBytesSource(empty))
+            s = Arrow.Table(source; scan=Tables.Scan())
+            @test isempty(s.x) && eltype(s.x) == Union{Missing,Int8} && isempty(s.b)
+        end
+        t = Arrow.Table(empty)
+        @test t.x[Int[]] == Int8[] && similar(t.x, 2) isa Vector{Union{Missing,Int8}}
+    end
+
+    @testset "dictionary columns expose their encoding" begin
+        pool = PooledArray(Union{Missing,String}["lo", "hi", missing, "lo", "hi"])
+        t = Arrow.Table(arrowbytes((c=pool,)))
+        c = t.c
+        @test c isa Arrow.DictEncoded
+        @test isequal(collect(c), collect(pool))
+        refs, rp = DataAPI.refarray(c), DataAPI.refpool(c)
+        @test all(isequal(rp[refs[i]], c[i]) for i in eachindex(c))
+        @test firstindex(rp) == 0 && rp[0] === missing
+        @test DataAPI.levels(c) == ["lo", "hi"]
+        owned = copy(c)
+        @test owned isa PooledArray && isequal(owned, collect(c))
+        owned[1] = "new"
+        @test owned[1] == "new" && c[1] == "lo"
+    end
+
+    @testset "rows of a dictionary column keep the encoding" begin
+        cats = Union{Missing,String}["b", "a", "b", "c", missing, "a", "c"]
+        whole = arrowbytes((c=PooledArray(cats),))
+        batches = arrowbytes(
+            Tables.partitioner([(c=PooledArray(cats[1:3]),), (c=PooledArray(cats[4:7]),)]),
+        )
+        for bytes in (whole, batches)
+            c = Arrow.Table(bytes).c
+            mask = [x === "a" for x in cats]
+            for rows in
+                ([1, 3, 4], 2:5, [7, 1, 5], Int32[7, 1, 5], 1:2:7, mask, BitVector(mask))
+                sub = c[rows]
+                @test sub isa PooledArray && isequal(sub, cats[rows])
+                # The dictionary's categories, in its order, unused ones too.
+                @test collect(skipmissing(DataAPI.refpool(sub))) == ["b", "a", "c"]
+            end
+            @test c[[2]] == ["a"] && !(c[[2]] isa Arrow.DictEncoded)
+            @test_throws BoundsError c[[8]]
+            @test_throws BoundsError c[Int32[8]]
+        end
+        # A copy of a column with no rows keeps its categories.
+        vf, vd = Arrow.AC.fromjulia("v", ["x", "y"])
+        dt = Arrow.AC.DictionaryType(Arrow.AC.IntType(8, true), vf.type, false)
+        dd = Arrow.AC.ArrayData(
+            dt,
+            0,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int8[])];
+            dictionary=vd,
+            nullcount=0,
+        )
+        df = Arrow.AC.Field(
+            "c",
+            dt;
+            nullable=false,
+            children=collect(Arrow.AC.Field, vf.children),
+        )
+        sch = Arrow.AC.Schema([df])
+        c = Arrow.Table(Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [dd], 0)])).c
+        @test isempty(c) && copy(c).pool == ["x", "y"]
+    end
+
+    @testset "run-end encoded columns read lazily" begin
+        rf, rd = Arrow.AC.fromjulia("run_ends", Int32[2, 5])
+        vf, vd = Arrow.AC.fromjulia("values", Int64[7, 9])
+        ree = Arrow.AC.RunEndEncodedType()
+        f = Arrow.AC.Field("r", ree; nullable=false, children=[rf, vf])
+        d = Arrow.AC.ArrayData(
+            ree,
+            5,
+            Arrow.AC.BufferSlice[];
+            children=[rd, vd],
+            nullcount=0,
+        )
+        sch = Arrow.AC.Schema([f])
+        t = Arrow.Table(Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d])]))
+        @test t.r isa Arrow.RunEndEncoded{Int64}
+        @test t.r == [7, 7, 9, 9, 9] && copy(t.r) == [7, 7, 9, 9, 9]
+    end
+
+    @testset "time-of-day values outside a day name the column" begin
+        f = Arrow.AC.Field("late", Arrow.AC.TimeType(Arrow.AC.SECOND, 32); nullable=false)
+        d = Arrow.AC.ArrayData(
+            f.type,
+            1,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int32[86_400])];
+            nullcount=0,
+        )
+        sch = Arrow.AC.Schema([f])
+        bytes = Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d])])
+        err = try
+            Arrow.Table(bytes)
+        catch e
+            e
+        end
+        @test err isa Arrow.ValidationError && occursin("\"late\"", err.msg)
+        # The error names a scan that reads the stored values as periods.
+        @test occursin("Tables.Scan(select=(:late => Dates.Second,))", err.msg)
+        ids = Arrow.AC.Field("id", Arrow.AC.IntType(64, true); nullable=false)
+        idd = Arrow.AC.ArrayData(
+            ids.type,
+            2,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[1, 2])];
+            nullcount=0,
+        )
+        d2 = Arrow.AC.ArrayData(
+            f.type,
+            2,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int32[86_400, 5])];
+            nullcount=0,
+        )
+        sch2 = Arrow.AC.Schema([f, ids])
+        stream = Arrow.writestream(sch2, [Arrow.AC.RecordBatch(sch2, [d2, idd])])
+        file = Arrow.writefile(sch2, [Arrow.AC.RecordBatch(sch2, [d2, idd])])
+        for src in (stream, file, ColumnsBytesSource(file))
+            t = Arrow.Table(src; scan=Tables.Scan(select=(:late => Second,)))
+            @test t.late == [Second(86_400), Second(5)]
+            t = Arrow.Table(src; scan=Tables.Scan(select=(:late => Millisecond, :id)))
+            @test t.late == [Millisecond(86_400_000), Millisecond(5000)] && t.id == [1, 2]
+            t = Arrow.Table(
+                src;
+                scan=Tables.Scan(select=(:late => Second,), filter=Tables.col(:id) > 1),
+            )
+            @test t.late == [Second(5)]
+        end
+    end
+
+    @testset "raw type overrides apply to their own outputs" begin
+        tbl = (t=[Time(1), Time(2), Time(3)], s=[:a, :b, :c], x=[1, 2, 3])
+        file = arrowbytes(tbl; file=true)
+        ns(h) = Nanosecond(Hour(h))
+        eq(c, v) = Arrow.colcmp(==, Arrow.col(c), v)
+        for src in (arrowbytes(tbl), file, ColumnsBytesSource(file))
+            # Another output of the same column reads its public values.
+            t = Arrow.Table(
+                src;
+                select=[:t, :t => Nanosecond => :tn, :s, :s => String => :s2],
+            )
+            @test t.t == tbl.t && eltype(t.t) == Time && t.tn == ns.(1:3)
+            @test t.s == tbl.s && t.s2 == ["a", "b", "c"]
+            back = Arrow.Table(arrowbytes(t))
+            @test back.t == tbl.t && back.s == tbl.s
+            t = Arrow.Table(src; select=[:t => Nanosecond => :tn, :t], limit=2)
+            @test t.tn == ns.(1:2) && t.t == tbl.t[1:2]
+            # A filter compares public values.
+            t = Arrow.Table(src; select=[:t => Nanosecond], filter=eq(:t, Time(2)))
+            @test t.t == [ns(2)]
+            gt = Arrow.colcmp(>, Arrow.col(:t), Time(1))
+            @test Arrow.Table(src; select=[:t => Nanosecond], filter=gt).t == ns.(2:3)
+            t = Arrow.Table(src; select=[:x, :s => String], filter=eq(:s, :b))
+            @test t.x == [2] && t.s == ["b"]
+            @test isempty(Arrow.Table(src; select=[:s => String], filter=eq(:s, "b")).s)
+            b = only(Arrow.Stream(src; select=[:s => String], filter=eq(:s, :b)))
+            @test b.s == ["b"]
+        end
+    end
+
+    @testset "fixed-shape tensors read as arrays" begin
+        AC = Arrow.AC
+        meta(json) = [
+            "ARROW:extension:name" => "arrow.fixed_shape_tensor",
+            "ARROW:extension:metadata" => json,
+        ]
+        cf, cd = AC.fromjulia("item", Int32.(0:11))
+        cf2, cd2 = AC.fromjulia("item", Int32.(0:11))
+        tf = AC.Field(
+            "t",
+            AC.FixedSizeListType(6);
+            nullable=true,
+            metadata=meta("{\"shape\":[2,3]}"),
+            children=[cf],
+        )
+        pf = AC.Field(
+            "p",
+            AC.FixedSizeListType(6);
+            nullable=true,
+            metadata=meta("{\"shape\":[2,3],\"permutation\":[1,0]}"),
+            children=[cf2],
+        )
+        td = AC.ArrayData(AC.FixedSizeListType(6), 2, [AC.BufferSlice()]; children=[cd])
+        pd = AC.ArrayData(AC.FixedSizeListType(6), 2, [AC.BufferSlice()]; children=[cd2])
+        sch = AC.Schema([tf, pf])
+        bytes = Arrow.writestream(sch, [AC.RecordBatch(sch, [td, pd], 2)])
+        t = Arrow.Table(bytes)
+        # Row-major storage over the physical shape [2, 3].
+        @test eltype(t.t) == Union{Missing,Matrix{Int32}}
+        @test t.t[2] == Int32[6 7 8; 9 10 11]
+        # Logical dimension 1 is physical dimension 2.
+        @test t.p[1] == Int32[0 3; 1 4; 2 5]
+        # A rewrite stores the rows back in row-major order.
+        again = Arrow.Table(arrowbytes(t))
+        @test isequal(collect(again.t), collect(t.t)) &&
+              isequal(collect(again.p), collect(t.p))
+    end
+
+    @testset "views keep their memory alive" begin
+        n = 1_000_000
+        path = tempname()
+        try
+            Arrow.write(path, (x=collect(1:n), s=string.(1:n)); file=true)
+            mappedviews(path, n)
+        finally
+            rmmapped(path)
+        end
+        @test Arrow._MMAP_DEFAULT == !Sys.iswindows()
+        # Tasks read columns whose table is gone while collections run.
+        bytes = arrowbytes(Tables.partitioner([(v=collect(1:1000) .+ k,) for k = 0:3]))
+        cols = [Arrow.Table(copy(bytes)).v for _ = 1:4]
+        tasks = [errormonitor(Threads.@spawn begin
+            total = 0
+            for _ = 1:200
+                total += sum(col)
+                yield()
+            end
+            total
+        end) for col in cols]
+        for _ = 1:20
+            GC.gc(false)
+            yield()
+        end
+        @test all(fetch(t) == 200 * sum(cols[1]) for t in tasks)
+    end
+
+    @testset "every read entry point gives the same views" begin
+        tbl = (
+            x=Union{Missing,Int64}[1, missing, 3],
+            s=["a", "b", "c"],
+            d=[Date(2024), Date(2025), Date(2026)],
+        )
+        for file in (true, false)
+            bytes = arrowbytes(tbl; file=file)
+            path = tempname()
+            write(path, bytes)
+            try
+                mappedentrypoints(tbl, bytes, path)
+                # Scans give the element types of a full read.
+                full = Arrow.Table(bytes)
+                for source in (bytes, ColumnsBytesSource(bytes))
+                    for scan in (
+                        Tables.Scan(select=(:s, :x)),
+                        Tables.Scan(filter=Tables.colcmp(>, Tables.col(:x), 1)),
+                        Tables.Scan(filter=Tables.colcmp(==, Tables.col(:x), 99)),
+                    )
+                        st = Arrow.Table(source; scan=scan)
+                        for nm in Tables.columnnames(st)
+                            @test eltype(Tables.getcolumn(st, nm)) ==
+                                  eltype(Tables.getcolumn(full, nm))
+                        end
+                    end
+                end
+            finally
+                rmmapped(path)
+            end
+        end
+    end
+
+    @testset "a scan that only selects reads as a full read does" begin
+        part = (x=collect(1:3), s=["a", "b", "c"], d=Date.(2020:2022))
+        bytes = arrowbytes(Tables.partitioner([part, part]); file=true)
+        full = Arrow.Table(bytes)
+        st = Arrow.Table(bytes; scan=Tables.Scan(select=(:d, :s, :x)))
+        for nm in (:x, :s, :d)
+            @test typeof(Tables.getcolumn(st, nm)) == typeof(Tables.getcolumn(full, nm))
+            @test Tables.getcolumn(st, nm) == Tables.getcolumn(full, nm)
+        end
+        # A temporal filter runs on the stored integers and returns dates.
+        filter = Tables.colcmp(>=, Tables.col(:d), Date(2021))
+        ft = Arrow.Table(bytes; scan=Tables.Scan(filter=filter))
+        @test ft.d == Date.([2021, 2022, 2021, 2022]) && ft.x == [2, 3, 2, 3]
+        # Selecting views allocates independently of the file's size.
+        large = arrowbytes((a=collect(1:2_000_000), b=rand(2_000_000)); file=true)
+        sel = Tables.Scan(select=(:a,))
+        Arrow.Table(large; scan=sel)
+        @test callbytes(Arrow.Table, large; scan=sel) < 200_000
+    end
+
+    @testset "fixed-size binary wider than 256 bytes reads as DataBytes" begin
+        AC = Arrow.AC
+        for (w, T) in ((256, NTuple{256,UInt8}), (300, Arrow.DataStrings.DataBytes))
+            data = UInt8[i % 251 for i = 1:(3w)]
+            t = AC.FixedSizeBinaryType(w)
+            f = AC.Field("b", t; nullable=true)
+            valid = AC._bitmapbuffer(Bool[true, false, true])
+            d = AC.ArrayData(t, 3, [valid, AC._databuffer(data)]; nullcount=1)
+            s = AC.Schema([f])
+            tbl = Arrow.Table(Arrow.writestream(s, [AC.RecordBatch(s, [d], 3)]))
+            @test eltype(tbl.b) == Union{Missing,T}
+            @test tbl.b[2] === missing && collect(tbl.b[3]) == data[(2w + 1):(3w)]
+            # A rewrite keeps the fixed-size layout.
+            again = Arrow.Table(arrowbytes(tbl))
+            @test isequal(again.b, tbl.b) && getfield(again, :schema).fields[1].type == t
+        end
+    end
+
+    @testset "nested columns read as typed rows" begin
+        Row = Arrow.ListValue
+        tbl = (
+            l=Union{Missing,Vector{Int64}}[[1, 2], missing, Int64[]],
+            ls=[["a"], String[], ["b", "c"]],
+            st=[(a=1, b="x"), (a=2, b="y"), (a=3, b="z")],
+            m=[Dict("k" => 1), Dict{String,Int64}(), Dict("p" => 2)],
+            t=[(Int16(1), Int16(2)), (Int16(3), Int16(4)), (Int16(5), Int16(6))],
+            ll=[[[1], [2, 3]], Vector{Int64}[], [Int64[]]],
+        )
+        t = Arrow.Table(arrowbytes(tbl))
+        @test eltype(t.l) == Union{Missing,Row{Int64}}
+        @test isequal(collect(t.l), tbl.l)
+        @test eltype(t.ls) == Row{DataString} && t.ls == tbl.ls
+        @test eltype(t.st) == @NamedTuple{a::Int64, b::DataString} && t.st == tbl.st
+        @test eltype(t.m) == Arrow.MapValue{DataString,Int64}
+        @test t.m == tbl.m
+        # The element type alone fixes how children are stored: strings in a
+        # StringVector, fixed-width values in a Primitive view, structs lazily
+        # in a StructVector, maps as key and value columns, so no value is boxed.
+        @test t.ls isa Arrow.ListVector && t.ls.values isa StringVector{DataString}
+        @test t.st isa Arrow.StructVector &&
+              t.st.children[1] isa Arrow.Primitive{Int64,Int64,Nothing} &&
+              t.st.children[2] isa StringVector{DataString}
+        @test t.m isa Arrow.MapVector && t.m.keys isa StringVector{DataString}
+        @test t.ll.values isa Arrow.ListVector{Row{Int64}}
+        @test eltype(t.t) == NTuple{2,Int16} && t.t == tbl.t
+        @test eltype(t.ll) == Row{Row{Int64}} && t.ll == tbl.ll
+        # Rows outlive their table; copies hold rows as their own vectors.
+        row = Arrow.Table(arrowbytes(tbl)).l[1]
+        GC.gc(true)
+        @test row == [1, 2]
+        err = @test_throws ArgumentError push!(row, 3)
+        @test err.value.msg ==
+              "an Arrow.ListValue is read-only; copy(x) gives a Vector that can change"
+        @test copy(t.l) isa Vector{Union{Missing,Vector{Int64}}} &&
+              isequal(copy(t.l), tbl.l)
+        @test copy(t.m) isa Vector{Dict{DataString,Int64}} &&
+              copy(t.st) isa Vector{@NamedTuple{a::Int64,b::DataString}}
+        # Several batches chain, and copy the same way.
+        two = Arrow.Table(arrowbytes(Tables.partitioner([tbl, tbl]); file=true))
+        @test isequal(collect(two.l), [tbl.l; tbl.l]) && two.st == [tbl.st; tbl.st]
+        @test copy(two.l) isa Vector && all(r -> r === missing || r isa Vector, copy(two.l))
+        # A struct row's fixed-size binary field is an `NTuple`, and the
+        # struct rewrites from it.
+        ids = Arrow.Table(arrowbytes((s=[(id=ntuple(UInt8, 16), n=1), missing],)))
+        @test eltype(ids.s) == Union{Missing,@NamedTuple{id::NTuple{16,UInt8},n::Int64}}
+        @test isequal(Arrow.Table(arrowbytes(ids)).s, ids.s)
+        # So does a read fixed-size binary column on its own.
+        fsb = Arrow.Table(arrowbytes((id=[ntuple(UInt8, 16)],))).id
+        @test Arrow.Table(arrowbytes((id=fsb,))).id == [ntuple(UInt8, 16)]
+        # Scans give the full read's rows.
+        st = Arrow.Table(arrowbytes(tbl); scan=Tables.Scan(select=(:st, :l)))
+        @test typeof(st.st) == typeof(t.st) && typeof(st.l) == typeof(t.l)
+        # Unions are a small Union of their children's types.
+        U = Union{Int64,String}
+        u = Arrow.Table(arrowbytes((u=U[1, "two"],))).u
+        @test eltype(u) == Union{Int64,DataString} && u == [1, "two"]
+        # A map's entries start at the entries struct's own offset.
+        AC = Arrow.AC
+        kf, kd = AC.fromjulia("key", ["a", "b", "c"])
+        vf, vd = AC.fromjulia("value", Int64[1, 2, 3])
+        ef = AC.Field("entries", AC.StructType(); nullable=false, children=[kf, vf])
+        ed = AC.ArrayData(
+            AC.StructType(),
+            2,
+            [AC.BufferSlice()];
+            offset=1,
+            children=[kd, vd],
+        )
+        mf = AC.Field("m", AC.MapType(false); nullable=false, children=[ef])
+        md = AC.ArrayData(
+            AC.MapType(false),
+            1,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 2])];
+            children=[ed],
+        )
+        ctx = Arrow._ViewContext(DataString, nothing)
+        @test collect.(Arrow._viewcolumn(mf, AC.ArrayData[md], ctx)) ==
+              [["b" => 2, "c" => 3]]
+        # Long fixed-size lists read as views; wide or duplicate-named
+        # structs keep `Pair` rows.
+        long = Arrow.Table(arrowbytes((x=[ntuple(Int64, 65)],))).x
+        @test eltype(long) == Row{Int64} && long[1] == 1:65
+        wide = NamedTuple{Tuple(Symbol(:f, k) for k = 1:65)}(Tuple(1:65))
+        @test Arrow.Table(arrowbytes((w=[wide],))).w[1] isa AbstractVector{<:Pair}
+        # Rows of 32 or more fields build without boxing each value.
+        nt = NamedTuple{Tuple(Symbol(:f, k) for k = 1:40)}(Tuple(1:40))
+        bytes = arrowbytes((s=fill(nt, 10_000),))
+        @test Arrow.Table(bytes).s[end] === nt
+        @test callbytes(Arrow.Table, bytes) < 2 * 10_000 * sizeof(nt)
+        # Fixed-size lists of nullable values read as `ListValue`s: a tuple type
+        # with `Missing` in it is abstract, so its rows would be boxed and a
+        # rewrite would see up to 2^N runtime types.
+        vals = Union{Missing,Int16}[
+            (r >> k) & 1 == 1 ? missing : Int16(4r + k) for r = 0:15 for k = 0:3
+        ]
+        cf, cd = AC.fromjulia("item", vals)
+        ff = AC.Field("f", AC.FixedSizeListType(4); nullable=false, children=[cf])
+        fd = AC.ArrayData(AC.FixedSizeListType(4), 16, [AC.BufferSlice()]; children=[cd])
+        fs = AC.Schema([ff])
+        f4 = Arrow.Table(Arrow.writestream(fs, [AC.RecordBatch(fs, [fd], 16)]))
+        @test eltype(f4.f) == Row{Union{Missing,Int16}}
+        @test isequal(reduce(vcat, f4.f), vals)
+        @test isequal(Arrow.Table(arrowbytes(f4)).f, f4.f)
+        # List views gather their rows' values, so rows may overlap or come
+        # in any order.
+        cf, cd = AC.fromjulia("item", ["a", "b", "c", "a longer value"])
+        vf = AC.Field("v", AC.ListViewType(false); nullable=true, children=[cf])
+        vd = AC.ArrayData(
+            AC.ListViewType(false),
+            3,
+            [
+                AC._databuffer(UInt8[0b101]),
+                AC._databuffer(Int32[2, 0, 0]),
+                AC._databuffer(Int32[2, 1, 3]),
+            ];
+            children=[cd],
+            nullcount=1,
+        )
+        vs = AC.Schema([vf])
+        lv = Arrow.Table(Arrow.writestream(vs, [AC.RecordBatch(vs, [vd], 3)])).v
+        @test eltype(lv) == Union{Missing,Row{DataString}}
+        @test isequal(collect(lv), [["c", "a longer value"], missing, ["a", "b", "c"]])
+        # Fixed-size lists of no values read as empty tuples.
+        cf, cd = AC.fromjulia("item", Int64[])
+        zf = AC.Field("z", AC.FixedSizeListType(0); nullable=false, children=[cf])
+        zd = AC.ArrayData(AC.FixedSizeListType(0), 2, [AC.BufferSlice()]; children=[cd])
+        zs = AC.Schema([zf])
+        z = Arrow.Table(Arrow.writestream(zs, [AC.RecordBatch(zs, [zd], 2)])).z
+        @test eltype(z) == Tuple{} && z == [(), ()]
+        # Nesting deeper than 8 levels keeps the materializing path: a row
+        # type grows with every level, and so does its compile time.
+        nest(x, k) = k == 0 ? x : nest([x], k - 1)
+        deep8 = Arrow.Table(arrowbytes((x=[nest([1], 7)],))).x
+        deep9 = Arrow.Table(arrowbytes((x=[nest([1], 8)],))).x
+        @test eltype(deep8) <: Row && deep8 == [nest([1], 7)]
+        @test !(eltype(deep9) <: Row) && deep9 == [nest([1], 8)]
+    end
+
+    @testset "map rows look keys up and keep every entry" begin
+        pairs = [["a" => 1, "b" => 2, "a" => 3], Pair{String,Int64}[]]
+        t = Arrow.Table(arrowbytes((m=pairs, d=[Dict("x" => 1.5), Dict{String,Float64}()])))
+        row = t.m[1]
+        @test row isa AbstractDict{DataString,Int64}
+        # Entries in stored order, duplicate keys kept.
+        @test length(row) == 3 && collect(row) == pairs[1]
+        @test keys(row) == ["a", "b", "a"] && values(row) == [1, 2, 3]
+        @test keys(row) isa Arrow.ListValue{DataString}
+        # Lookups take the last entry with the key, as Dict(row) does.
+        @test row["a"] == 3 && row["b"] == 2
+        @test get(row, "a", 0) == 3 && get(row, "zz", 0) == 0
+        @test haskey(row, "b") && !haskey(row, "zz")
+        @test_throws KeyError row["zz"]
+        @test Dict(row) == Dict("a" => 3, "b" => 2)
+        @test copy(row) == Dict("a" => 3, "b" => 2) && copy(row) isa Dict{DataString,Int64}
+        @test get(() -> 0, row, "zz") == 0
+        err = @test_throws ArgumentError row["z"] = 1
+        @test err.value.msg ==
+              "an Arrow.MapValue is read-only; copy(x) gives a Dict that can change"
+        @test_throws ArgumentError push!(row, "z" => 1)
+        @test_throws ArgumentError empty!(row)
+        @test isempty(t.m[2]) && length(t.m[2]) == 0
+        # Maps compare as dictionaries, as Arrow 2.x's Dict rows did.
+        @test t.d == [Dict("x" => 1.5), Dict{String,Float64}()]
+        @test t.d[1]["x"] == 1.5
+        # They write back as maps, entries in order.
+        back = Arrow.Table(arrowbytes(t))
+        @test collect(back.m[1]) == pairs[1] && back.d == t.d
+    end
+
+    @testset "list and map values print their values in cells" begin
+        t = Arrow.Table(
+            arrowbytes((
+                l=Union{Missing,Vector{Union{Missing,Int64}}}[[1, missing], missing],
+                m=[Dict("a" => 1), Dict("b" => 2)],
+            )),
+        )
+        compact(x) = sprint(show, x; context=:compact => true)
+        @test compact(t.l[1]) == "[1, missing]"
+        @test compact(t.m[1]) == "Dict(\"a\"=>1)"
+        # As elements of a vector, too (a DataFrame cell prints so).
+        @test endswith(sprint(show, [t.l[1]]), "[[1, missing]]")
+        @test occursin("Dict(\"a\" => 1)", sprint(show, MIME"text/plain"(), t.m))
+        # On their own they print as Base prints vectors and dictionaries.
+        @test sprint(show, t.l[1]) == "Union{Missing, Int64}[1, missing]"
+        @test startswith(sprint(show, t.m[1]), "Arrow.MapValue{")
+        # A long map prints its first ten entries under :limit.
+        big = Arrow.Table(arrowbytes((m=[Dict(string(i) => i for i = 1:12)],))).m[1]
+        shown = sprint(show, big; context=(:compact => true, :limit => true))
+        @test endswith(shown, ", …)") && count("=>", shown) == 10
+    end
+
+    @testset "nested children of union or run-end encoded values" begin
+        # A union of row types is a union column's values: stored as a Vector.
+        U = Union{Vector{Int64},Vector{Bool}}
+        t = Arrow.Table(arrowbytes((c=[U[[1], [true]], U[]],)))
+        @test isequal(t.c, [[[1], [true]], []])
+        NT = Union{@NamedTuple{a::Int64},@NamedTuple{b::String}}
+        t = Arrow.Table(arrowbytes((c=[NT[(a=1,), (b="x",)]],)))
+        @test t.c[1][1] == (a=1,) && t.c[1][2] == (b="x",)
+        t = Arrow.Table(arrowbytes((m=[Dict{String,U}("a" => [1], "b" => [true])],)))
+        @test Dict(t.m[1]) == Dict("a" => [1], "b" => [true])
+        # Run-end encoded list, struct, and map values inside a list.
+        ree = Arrow.AC.RunEndEncodedType()
+        lt = Arrow.AC.ListType(false)
+        offsets = Arrow.AC._databuffer(Int32[0, 3, 3, 6])
+        same(a, b) = isequal(a isa Arrow.MapValue ? Dict(a) : a, b)
+        for values in (
+            Union{Missing,Vector{Int64}}[[1, 2], missing, [3]],
+            Union{Missing,@NamedTuple{p::Int64,q::String}}[
+                (p=1, q="a"),
+                missing,
+                (p=3, q="c"),
+            ],
+            [Dict("k" => 1), Dict{String,Int64}(), Dict("j" => 2)],
+        )
+            rf, rd = Arrow.AC.fromjulia("run_ends", Int32[2, 3, 6])
+            src = Arrow.readstream(arrowbytes((values=values,); file=false))
+            vf, vd =
+                only(Arrow.AC.schema(src).fields), only(Arrow.AC.nextbatch!(src).columns)
+            ef = Arrow.AC.Field("item", ree; nullable=true, children=[rf, vf])
+            ed = Arrow.AC.ArrayData(ree, 6, Arrow.AC.BufferSlice[]; children=[rd, vd])
+            f = Arrow.AC.Field("l", lt; nullable=false, children=[ef])
+            d = Arrow.AC.ArrayData(lt, 3, [Arrow.AC.BufferSlice(), offsets]; children=[ed])
+            sch = Arrow.AC.Schema([f])
+            t = Arrow.Table(Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d])]))
+            runs = values[[1, 1, 2, 3, 3, 3]]
+            @test all(same.(t.l[1], runs[1:3])) && isempty(t.l[2])
+            @test all(same.(t.l[3], runs[4:6]))
+        end
+    end
+
+    @testset "nested rows read without boxing their values" begin
+        n = 100_000
+        tbl = (
+            st=[(a=i, b=string("s", i)) for i = 1:n],
+            ls=[[string(i), "x"] for i = 1:n],
+            m=[Dict(string(i) => i) for i = 1:n],
+        )
+        bytes = arrowbytes(tbl)
+        Arrow.Table(bytes)
+        # A boxed child value or row would cost an allocation each.
+        @test callallocations(Arrow.Table, bytes) < 5_000
+        t = Arrow.Table(bytes)
+        bsum(st) = sum(r -> ncodeunits(r.b), st)
+        lsum(ls) = sum(r -> sum(ncodeunits, r), ls)
+        # Rows build without allocating once compiled (older Julia and coverage
+        # builds do not always inline far enough for that).
+        if VERSION >= v"1.12" && Base.JLOptions().code_coverage == 0
+            @test allocationsof(bsum, t.st) == 0 && allocationsof(lsum, t.ls) == 0
+        end
+        @test t.st[end] == tbl.st[end] &&
+              t.ls[2] == ["2", "x"] &&
+              collect(t.m[3]) == ["3" => 3]
+    end
+
+    @testset "fixed-width nested children and list offsets view the data read" begin
+        n = 200_000
+        tbl = (
+            l=[[i, i + 1, i + 2, i + 3] for i = 1:n],
+            st=[(a=Int32(i), c=i / 2) for i = 1:n],
+            m=[Dict(i => float(i)) for i = 1:n],
+        )
+        path = tempname()
+        Arrow.write(path, tbl)
+        Arrow.Table(path; mmap=true)
+        # Copies of the 4n list values, the struct fields, the map entries, or
+        # the list and map offsets would allocate 4 bytes or more each.
+        @test fewestbytes(() -> Arrow.Table(path; mmap=true)) < 2n
+        t = Arrow.Table(path; mmap=true)
+        @test t.l.offsets isa Vector{Int32} && t.m.offsets isa Vector{Int32}
+        @test t.l == tbl.l && t.st == tbl.st && collect(t.m[5]) == [5 => 5.0]
+        # A rewrite reads the stored offsets.
+        @test Arrow.Table(arrowbytes(t)).l == tbl.l
+        # Rows keep the mapping they view alive.
+        row, st, entry = t.l[7], t.st, t.m[9]
+        Arrow.release!(t)
+        t = nothing
+        GC.gc(true)
+        GC.gc(true)
+        @test row == [7, 8, 9, 10] && st[n] == tbl.st[n] && collect(entry) == [9 => 9.0]
+        row = st = entry = nothing
+        rmmapped(path)
+    end
+
+    @testset "an uncompressed open allocates independently of its size" begin
+        small = arrowbytes((a=collect(1:1_000), b=rand(1_000)))
+        large = arrowbytes((a=collect(1:2_000_000), b=rand(2_000_000)))
+        Arrow.Table(small)
+        Arrow.Table(large)
+        @test callbytes(Arrow.Table, large) < callbytes(Arrow.Table, small) + 100_000
+    end
+
+    @testset "Arrow.read copies once into owned columns" begin
+        bytes = arrowbytes((
+            x=[1, 2, 3],
+            c=PooledArray(["a", "b", "a"]),
+            l=[[1], [2, 3], Int[]],
+        ))
+        nt = Arrow.read(bytes, Tables.columntable)
+        @test nt.x isa Vector{Int64} && nt.x == [1, 2, 3]
+        @test nt.c isa PooledArray && nt.c == ["a", "b", "a"]
+        @test nt.l == [[1], [2, 3], Int[]]
+        @test_throws ArgumentError Arrow.read(bytes)
+    end
+
+    @testset "Arrow.read gives a sink the file and column metadata" begin
+        bytes = take!(
+            Arrow.write(
+                IOBuffer(),
+                (a=[1, 2], b=["x", "y"]);
+                metadata=Dict("owner" => "me"),
+                colmetadata=Dict(:a => Dict("unit" => "m")),
+            ),
+        )
+        # A sink that takes DataAPI metadata, as a DataFrame does.
+        got = Arrow.read(bytes, cols -> _MetaSink(Tables.columntable(cols)))
+        @test got.columns.a == [1, 2]
+        @test got.metadata == Dict("owner" => "me")
+        @test got.colmetadata == Dict(:a => Dict("unit" => "m"))
+        # Other sinks get the columns as before.
+        @test Arrow.read(bytes, Tables.columntable).b == ["x", "y"]
+    end
+
+    @testset "reads give the same columns for any ntasks" begin
+        n = 150_000   # string columns span several chunks of rows
+        word(i) = i % 7 == 0 ? "" : repeat(string(i, base=36), 1 + i % 5)
+        part(r) = (
+            x=collect(Int64, r),
+            f=[isodd(i) ? missing : i / 2 for i in r],
+            s=[i % 11 == 0 ? missing : word(i) for i in r],
+            v=[word(i) for i in r],
+            b=[Vector{UInt8}(word(i)) for i in r],
+            c=PooledArray([isodd(i) ? "odd" : "even" for i in r]),
+            d=[reinterpret(Decimal{20,2,Int128}, Int128(i)) for i in r],
+            t=[Date(2000) + Day(i % 1000) for i in r],
+            q=[isodd(i) for i in r],
+        )
+        parts = Tables.partitioner([part(1:n), part((n + 1):(2n)), part(1:0)])
+        same(a, b) = typeof(a) == typeof(b) && isequal(collect(a), collect(b))
+        for (file, compress) in
+            ((true, nothing), (true, :zstd), (true, :lz4), (false, :zstd))
+            bytes = arrowbytes(parts; file=file, compress=compress, stringview=false)
+            views = arrowbytes(parts; file=file, compress=compress, stringview=true)
+            for src in (bytes, views), stringtype in (DataString, String)
+                one = Arrow.Table(src; ntasks=1, stringtype=stringtype)
+                for ntasks in (2, 5)
+                    t = Arrow.Table(src; ntasks=ntasks, stringtype=stringtype)
+                    @test all(
+                        same(Tables.getcolumn(t, nm), Tables.getcolumn(one, nm)) for
+                        nm in Tables.columnnames(one)
+                    )
+                end
+                for (b1, b5) in
+                    zip(Arrow.Stream(src; ntasks=1), Arrow.Stream(src; ntasks=5))
+                    @test all(
+                        same(Tables.getcolumn(b5, nm), Tables.getcolumn(b1, nm)) for
+                        nm in Tables.columnnames(b1)
+                    )
+                end
+                scan = Tables.Scan(select=(:s, :x, :c))
+                @test all(
+                    same(
+                        Tables.getcolumn(Arrow.Table(src; scan=scan, ntasks=5), nm),
+                        Tables.getcolumn(Arrow.Table(src; scan=scan, ntasks=1), nm),
+                    ) for nm in (:s, :x, :c)
+                )
+            end
+        end
+        @test_throws ArgumentError Arrow.Table(arrowbytes(part(1:3)); ntasks=0)
+        @test_throws ArgumentError Arrow.Stream(arrowbytes(part(1:3)); ntasks=-1)
+    end
+
+    @testset "a stream-format scan builds only the columns it needs" begin
+        tbl = (x=collect(1:6), s=["a", "b", "c", "d", "e", "f"], y=collect(6:-1:1))
+        bytes = arrowbytes(tbl; file=false)
+        t = Arrow.Table(bytes; scan=Tables.Scan(select=(:s,), filter=Tables.col(:y) > 3))
+        @test Tables.columnnames(t) == [:s] && t.s == ["a", "b", "c"]
+        t = Arrow.Table(bytes; scan=Tables.Scan(select=(:y, :s), limit=2))
+        @test t.y == [6, 5] && t.s == ["a", "b"]
+        # A scan that only selects gives the full read's columns.
+        full = Arrow.Table(bytes)
+        t = Arrow.Table(bytes; scan=Tables.Scan(select=(:s, :x)))
+        @test typeof(t.s) == typeof(full.s) && typeof(t.x) == typeof(full.x)
+        @test t.s == tbl.s && t.x == tbl.x
+    end
+
+    @testset "string columns build when first taken" begin
+        n = 100_000
+        strs = [string("value number ", i) for i = 1:n]
+        bytes = arrowbytes((s=strs, x=collect(1:n)))
+        Arrow.Table(bytes)
+        # Opening the table builds no string column (its payloads are 16n bytes).
+        @test fewestbytes(() -> Arrow.Table(bytes)) < 16n ÷ 4
+        t = Arrow.Table(bytes)
+        @test Tables.schema(t).types == (DataString, Int64)
+        # Tasks that ask at once get the one built column.
+        cols = fetch.([Threads.@spawn(t.s) for _ = 1:8])
+        @test all(c -> c === cols[1], cols) && cols[1] isa StringVector
+        @test cols[1] == strs && t.s === cols[1] && t[1] === cols[1]
+        @test copy(Arrow.Table(bytes)).s == strs
+        @test Arrow.read(bytes, Tables.columntable).s == strs
+        # A scan that only selects builds them the same way.
+        Arrow.Table(bytes; select=[:x, :s])
+        @test fewestbytes(() -> Arrow.Table(bytes; select=[:x, :s])) < 16n ÷ 4
+        @test Arrow.Table(bytes; select=[:s]).s == strs
+        @test Arrow.Table(bytes; stringtype=String).s == strs
+        # The read's allowance is charged when the table opens.
+        @test_throws Arrow.AllocationLimitError Arrow.Table(
+            bytes;
+            limits=Arrow.Limits(max_total_allocated_bytes=16n ÷ 2),
+        )
+        # A released table builds nothing more.
+        released = Arrow.Table(bytes)
+        Arrow.release!(released)
+        @test_throws InvalidStateException released.s
+    end
+
+    @testset "string columns keep decompressed data without a copy" begin
+        strs = [string(repeat("x", 100), i) for i = 1:100_000]
+        data = sum(ncodeunits, strs)
+        for compress in (:zstd, :lz4), stringview in (false, true)
+            bytes = arrowbytes((s=strs,); compress=compress, stringview=stringview)
+            @test Arrow.Table(bytes).s == strs
+            # The decompressed data plus 16-byte payloads once the column is
+            # built; a copy adds `data` more.
+            @test fewestbytes(() -> Arrow.Table(bytes).s) < data + 4_000_000
+        end
+    end
+
+    @testset "string columns reference the source's bytes in place" begin
+        n = 50_000
+        strs = [
+            i % 3 == 0 ? missing :
+            string("value number ", i, i % 2 == 0 ? " and more" : "") for i = 1:n
+        ]
+        viewbytes = sum(x -> x === missing || ncodeunits(x) <= 12 ? 0 : ncodeunits(x), strs)
+        for stringview in (false, true), compress in (nothing, :lz4)
+            bytes = arrowbytes((s=strs, x=collect(1:n)); stringview, compress)
+            t = Arrow.Table(bytes)
+            @test isequal(t.s, strs)
+            # Uncompressed, the column's data buffer is the byte vector itself,
+            # and building it allocates its payloads alone.
+            compress === nothing && @test any(b -> _samebytes(b, bytes), t.s.buffers)
+            compress === nothing &&
+                @test fewestbytes(() -> Arrow.Table(bytes).s) < 16n + 16n ÷ 4
+            path = joinpath(mktempdir(), "s.arrow")
+            write(path, bytes)
+            mapped = Arrow.Table(path)
+            @test isequal(mapped.s, strs)
+            compress === nothing &&
+                @test any(b -> length(b) == filesize(path), mapped.s.buffers)
+            # Copies own their bytes: only the view strings', in column order.
+            c = copy(t)
+            @test isequal(c.s, strs) && !any(b -> _samebytes(b, bytes), c.s.buffers)
+            @test sum(length, c.s.buffers) == viewbytes
+            owned = Arrow.read(bytes, Tables.columntable).s
+            @test isequal(owned, strs) && !any(b -> _samebytes(b, bytes), owned.buffers)
+            # A filtered scan gives the same kind of column, owning just its
+            # rows' bytes.
+            f = Arrow.Table(bytes; filter=Arrow.col(:x) > n ÷ 2)
+            @test f.s isa StringVector && isequal(f.s, strs[(n ÷ 2 + 1):end])
+            @test !any(b -> _samebytes(b, bytes), f.s.buffers)
+            @test sum(length, f.s.buffers) == sum(
+                x -> x === missing || ncodeunits(x) <= 12 ? 0 : ncodeunits(x),
+                strs[(n ÷ 2 + 1):end],
+            )
+            @test isequal(copy(f).s, strs[(n ÷ 2 + 1):end])
+        end
+        # A filtered column of several batches joins the batches' buffers.
+        parts = Tables.partitioner([
+            (s=strs[1:(n ÷ 2)], x=collect(1:(n ÷ 2))),
+            (s=strs[(n ÷ 2 + 1):end], x=collect((n ÷ 2 + 1):n)),
+        ])
+        bytes = arrowbytes(parts)
+        f = Arrow.Table(bytes; filter=Arrow.col(:x) > n ÷ 4)
+        @test f.s isa StringVector && isequal(f.s, strs[(n ÷ 4 + 1):end])
+        @test isequal(copy(f).s, strs[(n ÷ 4 + 1):end])
+        # The strings of a copied dictionary pool own their bytes.
+        pooled =
+            arrowbytes((p=PooledArray([isodd(i) ? "a long category" : "b" for i = 1:100]),))
+        pool = DataAPI.refpool(copy(Arrow.Table(pooled).p))
+        @test pool == ["a long category", "b"]
+        @test !any(x -> x.data === pooled, pool)
+        # Nested strings are copied as they are read, so a copied row owns its
+        # strings without a copy of its own.
+        nested = arrowbytes((l=[["abcdefghijklmnop", "q"]],))
+        tn = Arrow.Table(nested)
+        @test !any(b -> b === nested, tn.l.values.buffers)
+        @test copy(tn.l[1]) == ["abcdefghijklmnop", "q"]
+    end
+
+    @testset "columns of several batches copy and broadcast by batch" begin
+        part(r) = (
+            x=collect(Int64, r),
+            n=[iseven(i) ? missing : i for i in r],
+            c=PooledArray([string("k", i % 3) for i in r]),
+            s=[string(i) for i in r],
+        )
+        parts = Tables.partitioner([part(1:5), part(6:6), part(7:12)])
+        for file in (true, false)
+            t = Arrow.Table(arrowbytes(parts; file=file))
+            @test t.x isa Arrow.ChainedVector
+            owned = copy(t)
+            @test owned.x isa Vector{Union{Missing,Int64}} && owned.x == 1:12
+            @test owned.n isa Vector{Union{Missing,Int64}} && isequal(owned.n, t.n)
+            # Dictionary batches (shared, delta, or replaced pools) give one PooledArray.
+            @test owned.c isa PooledArray && owned.c == [string("k", i % 3) for i = 1:12]
+            @test owned.s == string.(1:12)
+            nt = Arrow.read(arrowbytes(parts; file=file), Tables.columntable)
+            @test nt.x isa Vector && nt.c isa PooledArray && !(nt.s isa Arrow.ChainedVector)
+            # Broadcasts give what they give over a Vector of the same values.
+            v = collect(t.x)
+            n = collect(t.n)
+            for (got, want) in (
+                (t.x .+ 1, v .+ 1),
+                (t.x .> 6, v .> 6),
+                (t.n .* 2, n .* 2),
+                (coalesce.(t.n, 0), coalesce.(n, 0)),
+                (Float64.(t.x), Float64.(v)),
+            )
+                @test typeof(got) == typeof(want) && isequal(got, want)
+            end
+            @test t.x .+ t.x .* collect(1:12) == v .+ v .* (1:12)
+            @test isequal(t.x .+ t.n, v .+ collect(t.n))
+            @test t.x .+ [10] == v .+ 10 && t.x .+ Ref(1) == v .+ 1
+            @test string.(t.s, "!") == string.(1:12, "!")
+            dest = zeros(Int, 12)
+            dest .= t.x .* 2
+            @test dest == 2 .* (1:12)
+            @test t.x .+ Tuple(1:12) == 2 .* (1:12)
+            @test (t.x .+ (1:12)') == v .+ (1:12)'
+        end
+    end
+
+    @testset "parallel work keeps nothing alive once it returns" begin
+        # A finished task can stay reachable (a thread keeps the last task it
+        # ran), so the work function, and a read's data it captures, must not
+        # be reachable from it. `run!` must not inline: a caller's stack slot
+        # would keep `data` alive on its own.
+        @noinline function run!(ref)
+            data = zeros(UInt8, 10)
+            ref[] = WeakRef(data)
+            Arrow._foreach((i, _) -> (data[i]=0x01; nothing), 10, 4)
+            return nothing
+        end
+        retained = map(1:10) do _
+            ref = Ref{WeakRef}()
+            run!(ref)
+            for _ = 1:3
+                GC.gc(true)
+            end
+            ref[].value !== nothing
+        end
+        @test !any(retained)
+    end
+
+    @testset "parallel work reports the first failing item" begin
+        for ntasks in (1, 3, 8)
+            ran = zeros(Int, 20)
+            err = try
+                Arrow._foreach(20, ntasks) do i, w
+                    @test 1 <= w <= min(20, ntasks)
+                    ran[i] += 1
+                    i in (6, 9, 14) && error("item $i")
+                end
+                nothing
+            catch e
+                e
+            end
+            @test err isa ErrorException && err.msg == "item 6"
+            # Every item before the first failure ran exactly once.
+            @test all(==(1), ran[1:6]) && all(<=(1), ran)
+            ran .= 0
+            Arrow._foreach((i, w) -> (ran[i] += 1), 20, ntasks)
+            @test all(==(1), ran)
+        end
+    end
+end
diff --git a/test/compat_tests.jl b/test/compat_tests.jl
new file mode 100644
index 00000000..ba8daa38
--- /dev/null
+++ b/test/compat_tests.jl
@@ -0,0 +1,626 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+using Test
+using Dates
+using Tables
+using Arrow
+using ArrowTypes
+import DataAPI
+import Durations
+import UUIDs
+using PooledArrays: PooledArray
+import FileIO
+import FilePathsBase
+
+const AC = Arrow.ArrowCore
+
+# Objects that `open` accepts, as FilePathsBase paths and AWSS3's `S3Path` are:
+# one opens a local file (an IOStream), the other hands out an IO it holds.
+struct OpenableFile
+    path::String
+end
+Base.open(f::OpenableFile, mode::AbstractString) = open(f.path, mode)
+struct OpenableIO
+    io::IO
+end
+Base.open(x::OpenableIO, ::AbstractString) = x.io
+
+# Bytes allocated by a second call of `f` (the first compiles it).
+allocatedby(f) = (f(); @allocated f())
+
+# The Arrow 2.x compatibility surface: the exported ArrowTypes binding, the
+# getmetadata accessor, tobuffer, the curried write, the removed-keyword
+# warnings, and the typed scan overrides the migration guide recommends. The
+# ArrowTimeZonesExt tests run in a child process so this process never loads
+# TimeZones and keeps testing naive reads.
+
+@testset "Arrow 2.x compat surface" begin
+    @testset "ArrowTypes is exported" begin
+        @test :ArrowTypes in names(Arrow)
+        @test Arrow.ArrowTypes === ArrowTypes
+    end
+
+    @testset "getmetadata" begin
+        tbl = (; a=[1, 2])
+        io = IOBuffer()
+        Arrow.write(io, tbl; metadata=("k" => "v", "k2" => "v2"))
+        t = Arrow.Table(take!(io))
+        @test Arrow.getmetadata(t) == Dict("k" => "v", "k2" => "v2")
+        io = IOBuffer()
+        Arrow.write(io, tbl)
+        bare = Arrow.Table(take!(io))
+        @test Arrow.getmetadata(bare) === nothing
+        # Arrow 2.x returned `nothing` for any other object; callers pass
+        # `metadata=Arrow.getmetadata(table)` for arbitrary write inputs.
+        @test Arrow.getmetadata(bare.a) === nothing
+        @test Arrow.getmetadata([(a=1,), (a=2,)]) === nothing
+        @test Arrow.getmetadata(tbl) === nothing
+    end
+
+    @testset "FileIO load and save" begin
+        dir = mktempdir()
+        path = joinpath(dir, "fileio.arrow")
+        tbl = (a=[1, 2], s=["x", "y"])
+        @test FileIO.save(path, tbl) === nothing
+        t = FileIO.load(path)
+        @test t isa Arrow.Table && t.a == tbl.a && t.s == tbl.s
+        @test FileIO.load(path; select=[:s]).s == tbl.s
+        FileIO.save(path, (a=[3],); compress=:zstd)
+        @test FileIO.load(path).a == [3]
+        # A FileIO stream (an IO) writes the stream format and reads it back.
+        io = IOBuffer()
+        FileIO.save(FileIO.Stream{FileIO.format"Arrow"}(io, path), tbl)
+        seekstart(io)
+        @test FileIO.load(FileIO.Stream{FileIO.format"Arrow"}(io, path)).a == tbl.a
+    end
+
+    @testset "unsupported sources name the supported kinds" begin
+        bytes = take!(Arrow.tobuffer((; a=[1])))
+        err = @test_throws ArgumentError Arrow.Table([bytes, bytes])
+        @test occursin("one IPC source", err.value.msg)
+        @test_throws ArgumentError Arrow.Stream(view(bytes, 1:length(bytes)))
+    end
+
+    @testset "objects that open accepts read and write as paths do" begin
+        dir = mktempdir()
+        tbl = (; a=collect(1:1_000_000))
+        for (k, P) in enumerate((FilePathsBase.Path, OpenableFile))
+            at(name) = P(joinpath(dir, "$k-$name.arrow"))
+            p = at("write")
+            @test Arrow.write(p, tbl) === p
+            @test open(io -> Base.read(io, 6), p, "r") == b"ARROW1"
+            @test Arrow.Table(p).a == tbl.a
+            @test Arrow.Table(p; mmap=false).a == tbl.a
+            @test only(collect(Arrow.Stream(p))).a == tbl.a
+            @test Arrow.read(p, Tables.columntable).a == tbl.a
+            # A stream-format file streams batch by batch, as a path does.
+            p = at("stream")
+            Arrow.write(p, Tables.partitioner(((; a=[1]), (; a=[2]))); file=false)
+            s = Arrow.Stream(p)
+            @test getfield(s, :src) isa Arrow._StreamReader
+            @test [b.a for b in s] == [[1], [2]]
+            p = at("curried")
+            @test ((; a=[1]) |> Arrow.write(p)) === p
+            @test Arrow.Table(p).a == [1]
+            p = at("writer")
+            Arrow.Writer(p) do w
+                Arrow.write(w, (; a=[1]))
+                return Arrow.write(w, (; a=[2]))
+            end
+            @test Arrow.Table(p).a == [1, 2]
+            p = at("open")
+            w = open(Arrow.Writer, p)
+            Arrow.write(w, (; a=[3]))
+            close(w)
+            @test Arrow.Table(p).a == [3]
+        end
+        # An IOStream is mapped, as a path is: the read copies nothing.
+        p = FilePathsBase.Path(joinpath(dir, "mapped.arrow"))
+        Arrow.write(p, tbl)
+        if !Sys.iswindows()
+            @test allocatedby(() -> Arrow.Table(p; mmap=true)) < sizeof(tbl.a) ÷ 8
+            @test allocatedby(() -> Arrow.Table(p; mmap=false)) > sizeof(tbl.a)
+        end
+        # A local path object gets the same atomic replacement as a string:
+        # failed writes preserve the file, and rewriting a mapped source is safe.
+        p = FilePathsBase.Path(joinpath(dir, "atomic.arrow"))
+        Arrow.write(p, (; a=[1, 2, 3]))
+        original = Base.read(string(p))
+        @test_throws ArgumentError Arrow.write(p, (; a=[big(1)]))
+        @test Base.read(string(p)) == original
+        mapped = Arrow.Table(p)
+        @test Arrow.write(p, mapped) === p
+        @test mapped.a == [1, 2, 3]
+        Arrow.Writer(p) do w
+            Arrow.write(w, (; a=[4]))
+        end
+        @test mapped.a == [1, 2, 3]
+        @test Arrow.Table(p).a == [4]
+        p = FilePathsBase.Path(joinpath(dir, "append.arrow"))
+        @test Arrow.append(p, (; a=[1])) === p
+        @test ((; a=[2, 3]) |> Arrow.append(p)) === p
+        @test Arrow.Table(p).a == [1, 2, 3]
+        # Another IO is read whole, or written in place in the file format.
+        bytes = take!(Arrow.write(IOBuffer(), tbl))
+        @test Arrow.Table(OpenableIO(IOBuffer(bytes))).a == tbl.a
+        sink = Base.BufferStream()
+        Arrow.write(OpenableIO(sink), (; a=[4]))
+        out = Base.read(sink)
+        @test out[1:6] == b"ARROW1"
+        @test Arrow.Table(out).a == [4]
+        # Anything else says what Arrow writes to.
+        for f in (() -> Arrow.write((; a=[1]), (; a=[1])), () -> Arrow.write((; a=[1])))
+            err = @test_throws ArgumentError f()
+            @test occursin("an object that open(x, \"w\") accepts", err.value.msg)
+        end
+        # A function is no path, though `open(f, mode)` calls it: a do-block
+        # Writer without a sink, or a function as a source, opens no file.
+        cd(mktempdir()) do
+            @test_throws ArgumentError Arrow.Writer(w -> Arrow.write(w, (; a=[1])))
+            @test_throws ArgumentError Arrow.Table(identity)
+            @test isempty(readdir())
+        end
+    end
+
+    @testset "tobuffer emits the stream format" begin
+        buf = Arrow.tobuffer((; a=[1, 2, 3]))
+        @test position(buf) == 0
+        bytes = take!(buf)
+        @test bytes[1:6] != b"ARROW1"
+        t = Arrow.Table(bytes)
+        @test t.a == [1, 2, 3]
+        parts = collect(Arrow.Stream(bytes))
+        @test length(parts) == 1
+    end
+
+    @testset "curried write" begin
+        path = joinpath(mktempdir(), "curried.arrow")
+        @test ((; a=[1, 2]) |> Arrow.write(path)) == path
+        @test Arrow.Table(path).a == [1, 2]
+        io = IOBuffer()
+        @test ((; a=[3]) |> Arrow.write(io; file=false)) === io
+        @test Arrow.Table(take!(io)).a == [3]
+    end
+
+    @testset "removed write keywords warn and are ignored" begin
+        io = IOBuffer()
+        @test_logs (:warn, r"`alignment` was removed") match_mode = :any Arrow.write(
+            io,
+            (; a=[1]);
+            alignment=64,
+        )
+        @test Arrow.Table(take!(io)).a == [1]
+        # Ignored keywords still produce a working write.
+        io = IOBuffer()
+        Arrow.write(io, (; a=[1]); ntasks=2, alignment=64, maxdepth=6)
+        @test Arrow.Table(take!(io)).a == [1]
+        # Arrow 2.x documented ntasks=0 for unbuffered writing: one task.
+        @test Arrow.Table(take!(Arrow.write(IOBuffer(), (; a=[1]); ntasks=0))).a == [1]
+    end
+end
+
+@testset "unknown keywords and mismatched filter literals are ArgumentErrors" begin
+    bytes = take!(Arrow.tobuffer((a=[1, 2], s=["x", "y"])))
+    msg(f) =
+        try
+            f()
+            ""
+        catch e
+            e isa ArgumentError ? e.msg : "not an ArgumentError: $(typeof(e))"
+        end
+    m = msg(() -> Arrow.write(IOBuffer(), (a=[1],); compression=:zstd))
+    @test occursin("unknown write keyword `compression` (use `compress`).", m)
+    @test occursin("The keywords are file, compress, compresslevel, batchsize", m)
+    m = msg(() -> Arrow.Writer(IOBuffer(); compression_level=3, nope=1))
+    @test occursin("keywords `compression_level` (use `compresslevel`), `nope`", m)
+    m = msg(() -> Arrow.append(Arrow.tobuffer((a=[1],)), (a=[2],); compression=:lz4))
+    @test occursin("unknown append keyword `compression` (use `compress`)", m)
+    m = msg(() -> Arrow.Table(bytes; columns=[:a]))
+    @test occursin("unknown read keyword `columns` (use `select`).", m)
+    @test occursin("The keywords are select, drop, filter, limit, scan", m)
+    @test occursin(
+        "`convert` (removed in Arrow 3.0",
+        msg(() -> Arrow.Table(bytes; convert=false)),
+    )
+    @test occursin(
+        "`use_threads` (use `ntasks`)",
+        msg(() -> Arrow.Stream(bytes; use_threads=true)),
+    )
+    @test occursin(
+        "`memory_map` (use `mmap`)",
+        msg(() -> Arrow.read(bytes, identity; memory_map=true)),
+    )
+    # Arrow 2.x's byte windows.
+    @test occursin(
+        "Arrow.Table(bytes[pos:pos+len-1])",
+        msg(() -> Arrow.Table(bytes, 1, 10)),
+    )
+    @test occursin("Arrow.Stream(bytes[pos:pos+len-1])", msg(() -> Arrow.Stream(bytes, 1)))
+    # A literal of another kind than its column, when the read binds the filter.
+    m = msg(() -> Arrow.Table(bytes; filter=Arrow.col(:s) > 1))
+    @test m == "the filter compares column s, which holds strings, with 1::Int64"
+    m = msg(() -> Arrow.Table(bytes; filter=Arrow.colin(Arrow.col(:a), ["1"])))
+    @test m == "the filter compares column a, which holds Int64 values, with \"1\"::String"
+    m = msg(() -> Arrow.Stream(bytes; filter=startswith(Arrow.col(:a), "1")))
+    @test m == "the filter matches text in column a, which holds Int64 values"
+    # Literals of the column's kind still read.
+    @test Arrow.Table(bytes; filter=Arrow.col(:a) > 1.5).a == [2]
+    @test Arrow.Table(bytes; filter=startswith(Arrow.col(:s), "y")).s == ["y"]
+end
+
+@testset "filter forms Tables.jl 1.14 does not take get a hint" begin
+    bytes = take!(Arrow.tobuffer((a=[1, 2],)))
+    msg(f) =
+        try
+            f()
+            ""
+        catch e
+            e isa ArgumentError ? e.msg : "not an ArgumentError: $(typeof(e))"
+        end
+    equality = msg(() -> Arrow.Table(bytes; filter=Arrow.col(:a) == 1))
+    @test occursin("Arrow.colcmp(==, Arrow.col(:x), v)", equality)
+    @test occursin("Arrow.colin", equality)
+    @test occursin("Tables.jl 1.15", msg(() -> Arrow.Table(bytes; filter=:a => ==(1))))
+    @test occursin(
+        "not a function",
+        msg(() -> Arrow.Stream(bytes; filter=row -> row.a > 1)),
+    )
+    @test Arrow.Table(bytes; filter=Arrow.colcmp(==, Arrow.col(:a), 1)).a == [1]
+end
+
+@testset "select and drop by function; errors in their terms; table names" begin
+    bytes = take!(Arrow.tobuffer((a=[1, 2], b=["x", "y"], c=[1.5, 2.5])))
+    names(t) = collect(Tables.columnnames(t))
+    # A function (i, name) -> Bool picks columns, as in CSV.jl.
+    @test names(Arrow.Table(bytes; select=(i, name) -> i > 1)) == [:b, :c]
+    @test names(Arrow.Table(bytes; drop=(i, name) -> name === :b)) == [:a, :c]
+    @test names(first(Arrow.Stream(bytes; select=(i, name) -> name !== :a))) == [:b, :c]
+    msg(f) =
+        try
+            f()
+            ""
+        catch e
+            e isa ArgumentError ? e.msg : "not an ArgumentError: $(typeof(e))"
+        end
+    @test msg(() -> Arrow.Table(bytes; select=[:nope])) ==
+          "select names no column :nope; the columns are a, b, c"
+    @test msg(() -> Arrow.Table(bytes; drop=:nope)) ==
+          "drop names no column :nope; the columns are a, b, c"
+    @test msg(() -> Arrow.Stream(bytes; select=[4])) ==
+          "select names no column 4; the columns are a, b, c"
+    # An unsupported selector (a Set, or DataFrames' Not) points at drop.
+    m = msg(() -> Arrow.Table(bytes; select=Set([:a])))
+    @test occursin("select takes column names, indices, a Regex, a function", m)
+    @test occursin("drop gives the columns to leave out", m)
+    # Container conveniences.
+    t = Arrow.Table(bytes)
+    @test Base.names(t) == ["a", "b", "c"]
+    @test t["b"] == ["x", "y"]
+    @test DataAPI.nrow(t) == 2 && DataAPI.ncol(t) == 3
+    # Tables compare by names and columns, as DataFrames do.
+    @test t == Arrow.Table(bytes) && isequal(t, Arrow.Table(bytes))
+    @test hash(t) == hash(Arrow.Table(bytes))
+    @test t != Arrow.Table(bytes; select=[:a, :b])
+    @test t != Arrow.Table(take!(Arrow.tobuffer((a=[1, 3], b=["x", "y"], c=[1.5, 2.5]))))
+    withmissing = take!(Arrow.tobuffer((a=[1, missing],)))
+    @test ismissing(Arrow.Table(withmissing) == Arrow.Table(withmissing))
+    @test isequal(Arrow.Table(withmissing), Arrow.Table(withmissing))
+    # A table in memory is not a source; the error says how to get one.
+    @test occursin("Arrow.Table(Arrow.tobuffer(table))", msg(() -> Arrow.Table((a=[1],))))
+end
+
+@testset "a filtered Stream writes only the batches with rows" begin
+    parts = Tables.partitioner([(a=[1, 2],), (a=[3, 4],), (a=[5, 6],)])
+    bytes = take!(Arrow.write(IOBuffer(), parts; file=true))
+    out = take!(Arrow.write(IOBuffer(), Arrow.Stream(bytes; filter=Arrow.col(:a) > 4)))
+    @test [Tables.rowcount(b) for b in Arrow.Stream(out)] == [2]
+    @test Arrow.Table(out).a == [5, 6]
+    # No match at all: the schema and no record batch.
+    none = take!(Arrow.write(IOBuffer(), Arrow.Stream(bytes; filter=Arrow.col(:a) > 9)))
+    @test isempty(collect(Arrow.Stream(none)))
+    @test isempty(Arrow.Table(none).a) && eltype(Arrow.Table(none).a) <: Union{Missing,Int}
+end
+
+@testset "typed scan overrides for composite rows" begin
+    NT = NamedTuple{(:a, :b),Tuple{Float64,String}}
+    tbl = (; x=[1, 2], c=[(a=1.0, b="x"), (a=2.0, b="y")])
+    io = IOBuffer()
+    Arrow.write(io, tbl)
+    bytes = take!(io)
+
+    @testset "struct rows to NamedTuple" begin
+        t = Arrow.Table(bytes; scan=Tables.Scan(select=(:x, :c => NT)))
+        @test eltype(t.c) == NT
+        @test t.c == tbl.c
+    end
+
+    @testset "missing rows stay missing" begin
+        io = IOBuffer()
+        Arrow.write(io, (; c=[(a=1.0, b="x"), missing]))
+        bytes = take!(io)
+        for T in (NT, Union{Missing,NT})
+            t = Arrow.Table(bytes; scan=Tables.Scan(select=(:c => T,)))
+            @test eltype(t.c) == Union{Missing,NT}
+            @test t.c[1] == (a=1.0, b="x")
+            @test t.c[2] === missing
+        end
+    end
+
+    @testset "nested vectors of structs" begin
+        # Fresh list-of-struct writes are unsupported, so build the fixture
+        # at the core level: a list column over one struct child.
+        fs, ds = AC.fromjulia_struct("item", (a=[1.0, 2.0, 3.0], b=["x", "y", "z"]))
+        lt = AC.ListType(false)
+        f = AC.Field("c", lt; nullable=false, children=[fs])
+        d = AC.ArrayData(
+            lt,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 1, 3])];
+            children=[ds],
+            nullcount=0,
+        )
+        sch = AC.Schema([f])
+        nested = Arrow.writefile(sch, [AC.RecordBatch(sch, [d])])
+        t = Arrow.Table(nested; scan=Tables.Scan(select=(:c => Vector{NT},)))
+        @test eltype(t.c) == Vector{NT}
+        @test t.c == [[(a=1.0, b="x")], [(a=2.0, b="y"), (a=3.0, b="z")]]
+    end
+
+    @testset "abstract NamedTuple columns widen field by field" begin
+        # Rows whose fields are missing in some rows have different concrete
+        # types; Arrow 2.x wrote them as one Struct, and so does 3.0.
+        v = [(a=isodd(i) ? missing : i, b=isodd(i) ? "x$i" : missing) for i = 1:4]
+        @test !isconcretetype(eltype(v))
+        W = @NamedTuple{a::Union{Missing,Int64}, b::Union{Missing,String}}
+        t = Arrow.Table(Arrow.tobuffer((; v)); scan=Tables.Scan(select=(:v => W,)))
+        @test eltype(t.v) == W
+        @test isequal(t.v, v)
+    end
+
+    @testset "field-name mismatch errors" begin
+        Bad = NamedTuple{(:a, :wrong),Tuple{Float64,String}}
+        @test_throws MethodError Arrow.Table(bytes; scan=Tables.Scan(select=(:c => Bad,)))
+    end
+
+    @testset "public temporal leaves in typed rows" begin
+        # Rows hold public values at every depth, so a claim naming the
+        # public leaf types is an identity check per leaf.
+        ns = AC.TimestampType(AC.NANOSECOND, nothing)
+        day = AC.DateType(AC.DAY)
+        tsf = AC.Field("when", ns; nullable=false)
+        dayf = AC.Field("day", day; nullable=false)
+        stf = AC.Field("c", AC.StructType(); nullable=false, children=[tsf, dayf])
+        tsd = AC.ArrayData(
+            ns,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int64[10, 20])];
+            nullcount=0,
+        )
+        dayd = AC.ArrayData(
+            day,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 1])];
+            nullcount=0,
+        )
+        std = AC.ArrayData(
+            AC.StructType(),
+            2,
+            [AC.BufferSlice()];
+            children=[tsd, dayd],
+            nullcount=0,
+        )
+        sch = AC.Schema([stf])
+        tsbytes = Arrow.writefile(sch, [AC.RecordBatch(sch, [std])])
+        Ts = Durations.Timestamp{Dates.Nanosecond}
+        TNT = NamedTuple{(:when, :day),Tuple{Ts,Dates.Date}}
+        t = Arrow.Table(tsbytes; scan=Tables.Scan(select=(:c => TNT,)))
+        @test eltype(t.c) == TNT
+        @test t.c == [
+            (when=reinterpret(Ts, Int64(10)), day=Dates.Date(1970, 1, 1)),
+            (when=reinterpret(Ts, Int64(20)), day=Dates.Date(1970, 1, 2)),
+        ]
+        # a claim naming raw storage integers no longer matches public rows
+        RawNT = NamedTuple{(:when, :day),Tuple{Int64,Int32}}
+        @test_throws Exception Arrow.Table(tsbytes; scan=Tables.Scan(select=(:c => RawNT,)))
+    end
+end
+
+# A value wrapper with a DataAPI ref pool, shaped like CategoricalArrays'
+# CategoricalValue/CategoricalArray, which has no ArrowTypes.jl mapping.
+struct CompatWrapped
+    x::String
+end
+DataAPI.unwrap(w::CompatWrapped) = w.x
+struct CompatWrappedVector <: AbstractVector{CompatWrapped}
+    refs::Vector{UInt32}
+    levels::Vector{String}
+end
+Base.size(v::CompatWrappedVector) = size(v.refs)
+Base.getindex(v::CompatWrappedVector, i::Int) = CompatWrapped(v.levels[v.refs[i]])
+DataAPI.refarray(v::CompatWrappedVector) = v.refs
+DataAPI.refpool(v::CompatWrappedVector) = CompatWrapped.(v.levels)
+
+struct CompatHasPtr
+    p::Ptr{Nothing}
+end
+
+@testset "DataAPI ref-pool columns write dictionary-encoded" begin
+    # Arrow 2.x dictionary-encoded PooledArray and CategoricalArray columns;
+    # the pool order and unused entries carry over.
+    function pool(col)
+        s = Arrow.readstream(take!(Arrow.tobuffer((; col))))
+        f = only(s.schema.fields)
+        @test f.type isa AC.DictionaryType
+        d = only(s.batches).columns[1]
+        return Arrow.materialize(AC.dictvaluefield(f, f.type), d.dictionary)
+    end
+    p = PooledArray(["b", "a", "b"])
+    p[1] = "z"
+    @test pool(p) == ["b", "a", "z"]
+    @test Arrow.Table(Arrow.tobuffer((; p))).p == ["z", "a", "b"]
+    m = PooledArray(["a", missing, "a"])
+    @test isequal(Arrow.Table(Arrow.tobuffer((; m))).m, ["a", missing, "a"])
+    # Wrapped values without an ArrowTypes.jl mapping unwrap through DataAPI.
+    w = CompatWrappedVector(UInt32[2, 3, 2], ["c", "b", "a"])
+    @test pool(w) == ["c", "b", "a"]
+    t = Arrow.Table(Arrow.tobuffer((; w)))
+    @test eltype(t.w) == Arrow.DataStrings.DataString
+    @test t.w == ["b", "a", "b"]
+    # Arrow.Writer encodes them too; later tables' new categories extend them.
+    io = IOBuffer()
+    Arrow.Writer(io) do writer
+        Arrow.write(writer, (; p=PooledArray(["a", "b", "a"]), w))
+        return Arrow.write(writer, (; p=PooledArray(["c", "c", "d"]), w))
+    end
+    t = Arrow.Table(take!(io))
+    @test all(f -> f.type isa AC.DictionaryType, getfield(t, :schema).fields)
+    @test t.p == ["a", "b", "a", "c", "c", "d"]
+    @test t.w == ["b", "a", "b", "b", "a", "b"]
+    # A struct whose fields cannot be written names the column and type.
+    err = @test_throws ArgumentError Arrow.tobuffer((; x=[CompatHasPtr(C_NULL)]))
+    @test occursin("column x holds", err.value.msg)
+    @test occursin("CompatHasPtr", err.value.msg)
+end
+
+@testset "dictencode=false writes pooled columns as their values" begin
+    isdict(t, j) = getfield(t, :schema).fields[j].type isa AC.DictionaryType
+    p = PooledArray(["NY", "LA", "NY"])
+    t = Arrow.Table(
+        Arrow.tobuffer((; p, d=Arrow.DictEncode(["a", "b", "a"])); dictencode=false),
+    )
+    @test !isdict(t, 1) && t.p == ["NY", "LA", "NY"]
+    # An Arrow.DictEncode column asks for its dictionary itself.
+    @test isdict(t, 2) && t.d == ["a", "b", "a"]
+    @test isdict(Arrow.Table(Arrow.tobuffer((; p))), 1)
+    # A dictionary column read from Arrow, in its table or on its own.
+    src = Arrow.Table(Arrow.tobuffer((; p=PooledArray(["x", missing, "x"]), n=[1, 2, 3])))
+    @test isdict(src, 1)
+    for x in (src, (; p=src.p))
+        back = Arrow.Table(Arrow.tobuffer(x; dictencode=false))
+        @test !isdict(back, 1) && getfield(back, :schema).fields[1].nullable
+        @test isequal(back.p, ["x", missing, "x"])
+    end
+    # One column name, as well as a collection of them.
+    t = Arrow.Table(Arrow.tobuffer((a=["u", "v"], b=["w", "w"]); dictencode=:a))
+    @test isdict(t, 1) && !isdict(t, 2)
+end
+
+@testset "dictionary writes do not allocate per row" begin
+    # Ref-pool and DictEncode columns share one encoder; 200,000 cells here.
+    vals = [string("c", i % 50) for i = 1:100_000]
+    tbl = (d=Arrow.DictEncode(vals), p=PooledArray(vals))
+    Arrow.tobuffer(tbl)
+    @test (@allocations Arrow.tobuffer(tbl)) < 100_000
+end
+
+@testset "Arrow 2.x FixedSizeBinary extension columns" begin
+    # Arrow 2.x wrote every NTuple{N,UInt8} storage type, including UUID, as
+    # FixedSizeBinary(N); ArrowTypes.jl restores UUID from NTuple{16,UInt8}.
+    u = [UUIDs.UUID(1), UUIDs.UUID(typemax(UInt128) - 1)]
+    t = AC.FixedSizeBinaryType(16)
+    meta = ["ARROW:extension:name" => "JuliaLang.UUID", "ARROW:extension:metadata" => ""]
+    bytes = collect(reinterpret(UInt8, [x.value for x in u]))
+    d = AC.ArrayData(t, 2, [AC.BufferSlice(), AC._databuffer(bytes)]; nullcount=0)
+    sch = AC.Schema([AC.Field("u", t; nullable=false, metadata=meta)])
+    tbl = Arrow.Table(Arrow.writefile(sch, [AC.RecordBatch(sch, [d])]))
+    @test eltype(tbl.u) == UUIDs.UUID
+    @test tbl.u == u
+    # A rewrite keeps the 2.x label and byte order.
+    re = Arrow.readfile(take!(Arrow.write(IOBuffer(), tbl; file=true)))
+    @test Arrow._fieldmetadata(only(re.schema.fields)) == meta
+    @test AC.slicebytes(AC.rolebuffer(re[1].columns[1], AC.DATA)) == bytes
+end
+
+@testset "files from Arrow.jl before 2.6" begin
+    # Those releases wrote V5 messages under a V4 file footer, which the
+    # reference implementation reads.
+    bytes = take!(Arrow.write(IOBuffer(), (; a=[1, 2]); file=true))
+    footerlen = Int(only(reinterpret(Int32, bytes[(end - 9):(end - 6)])))
+    footerstart = length(bytes) - 10 - footerlen
+    footer = Arrow.FB.getrootas(
+        Arrow.Meta.Footer,
+        bytes[(footerstart + 1):(footerstart + footerlen)],
+        0,
+    )
+    @test footer.version == Arrow.Meta.MetadataVersion.V5
+    at = footerstart + Arrow.FB.offset(footer, 4) + Arrow.FB.pos(footer)
+    bytes[(at + 1):(at + 2)] = reinterpret(UInt8, [Int16(Arrow.Meta.MetadataVersion.V4)])
+    @test Arrow.Table(bytes).a == [1, 2]
+    @test [b.a for b in Arrow.Stream(bytes)] == [[1, 2]]
+end
+
+@testset "Arrow 2.x temporal extension labels" begin
+    # Arrow 2.x labelled its temporal columns; Arrow 3.0 reads the storage
+    # natively and does not warn about these labels.
+    label(name) = ["ARROW:extension:name" => name, "ARROW:extension:metadata" => ""]
+    ms = AC.TimestampType(AC.MILLISECOND, nothing)
+    zms = AC.TimestampType(AC.MILLISECOND, "UTC")
+    cols = [
+        ("d", AC.DateType(AC.DAY), "JuliaLang.Date", Int32[1]),
+        ("dt", ms, "JuliaLang.DateTime", Int64[1]),
+        ("t", AC.TimeType(AC.NANOSECOND, 64), "JuliaLang.Time", Int64[1]),
+        ("p", AC.DurationType(AC.SECOND), "JuliaLang.Dates.Period", Int64[1]),
+        ("z", zms, "JuliaLang.ZonedDateTime-UTC", Int64[1]),
+        ("ts", ms, "JuliaLang.Durations.Timestamp", Int64[1]),
+    ]
+    fields = [AC.Field(n, t; nullable=false, metadata=label(l)) for (n, t, l, _) in cols]
+    data = [
+        AC.ArrayData(t, 1, [AC.BufferSlice(), AC._databuffer(v)]; nullcount=0) for
+        (_, t, _, v) in cols
+    ]
+    sch = AC.Schema(fields)
+    bytes = Arrow.writestream(sch, [AC.RecordBatch(sch, data)])
+    tbl = @test_logs min_level = Base.CoreLogging.Warn Arrow.Table(bytes)
+    @test tbl.d == [Date(1970, 1, 2)]
+    @test tbl.dt == [DateTime(1970, 1, 1, 0, 0, 0, 1)]
+    @test tbl.t == [Time(0, 0, 0, 0, 0, 1)]
+    @test tbl.p == [Second(1)]
+    @test tbl.ts == tbl.dt
+    # Before Arrow 2.4.2 the zoned label stored local wall time, which a UTC
+    # instant read does not reproduce, so it still warns.
+    old = AC.Field("z", zms; nullable=false, metadata=label("JuliaLang.ZonedDateTime"))
+    osch = AC.Schema([old])
+    obytes = Arrow.writestream(osch, [AC.RecordBatch(osch, [data[5]])])
+    @test_logs (:warn, r"JuliaLang.ZonedDateTime") Arrow.Table(obytes)
+end
+
+@testset "timezone-aware timestamps without TimeZones" begin
+    # This process must not have loaded TimeZones: zoned reads are native
+    # ZonedTimestamp values and need no extension.
+    @test Base.get_extension(Arrow, :ArrowTimeZonesExt) === nothing
+    t = AC.TimestampType(AC.MILLISECOND, "America/Denver")
+    d = AC.ArrayData(t, 1, [AC.BufferSlice(), AC._databuffer(Int64[0])]; nullcount=0)
+    sch = AC.Schema([AC.Field("ts", t; nullable=false)])
+    tbl = Arrow.Table(Arrow.writefile(sch, [AC.RecordBatch(sch, [d])]))
+    Z = Durations.ZonedTimestamp{Dates.Millisecond,Symbol("America/Denver")}
+    @test eltype(tbl.ts) == Z
+    @test tbl.ts[1] == Z(Durations.Timestamp{Dates.Millisecond}(1970), Dates.UTC)
+    # instant operations need no zone rules; local-time ones name TimeZones
+    @test tbl.ts[1] < tbl.ts[1] + Dates.Second(1)
+    err = try
+        Dates.hour(tbl.ts[1])
+    catch e
+        e
+    end
+    @test err isa ArgumentError && occursin("TimeZones.jl", err.msg)
+end
+
+@testset "ArrowTimeZonesExt child" begin
+    @test success(
+        `$(Base.julia_cmd()) --startup-file=no --project=$(Base.active_project()) $(joinpath(@__DIR__, "timezones_child.jl"))`,
+    )
+end
diff --git a/test/conformance_support_tests.jl b/test/conformance_support_tests.jl
new file mode 100644
index 00000000..55ae994d
--- /dev/null
+++ b/test/conformance_support_tests.jl
@@ -0,0 +1,1127 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module ConformanceSupportTests
+
+using Test
+
+# All three adapters must share one support-module identity when a caller
+# composes them in one process.
+module CombinedAdapters
+const ROOT = normpath(joinpath(@__DIR__, ".."))
+include(joinpath(ROOT, "conformance", "corpus.jl"))
+const FIRST_VERDICT = Verdict
+include(joinpath(ROOT, "conformance", "oracle.jl"))
+include(joinpath(ROOT, "conformance", "cdata_oracle.jl"))
+end
+
+module NarrowCDataStress
+include(joinpath(@__DIR__, "support", "CDataStressSupport.jl"))
+end
+
+# A composed include must ignore a child marker that belongs to another entry
+# point. The test environment intentionally does not depend on PythonCall.
+module PoisonedCDataInclude
+const ROOT = normpath(joinpath(@__DIR__, ".."))
+const SAVED_ARGS = copy(ARGS)
+empty!(ARGS)
+push!(ARGS, "--child")
+try
+    include(joinpath(ROOT, "conformance", "cdata_oracle.jl"))
+finally
+    empty!(ARGS)
+    append!(ARGS, SAVED_ARGS)
+end
+end
+
+const CS = CombinedAdapters.ConformanceSupport
+
+@test !isdefined(PoisonedCDataInclude, :PythonCall)
+
+function _field(
+    name,
+    type;
+    nullable=true,
+    children=Any[],
+    metadata=Any[],
+    dictionary=nothing,
+)
+    field = Dict{String,Any}(
+        "name" => name,
+        "nullable" => nullable,
+        "type" => type,
+        "children" => children,
+        "metadata" => metadata,
+    )
+    dictionary === nothing || (field["dictionary"] = dictionary)
+    return field
+end
+
+_onecolumndoc(field, column) = Dict{String,Any}(
+    "schema" => Dict{String,Any}("fields" => Any[field]),
+    "batches" =>
+        Any[Dict{String,Any}("count" => column["count"], "columns" => Any[column])],
+)
+
+_emptydoc(field) = Dict{String,Any}(
+    "schema" => Dict{String,Any}("fields" => Any[field]),
+    "batches" => Any[],
+)
+
+function _coreview(data, offset, len)
+    AC = CS.ArrowCore
+    return AC.ArrayData(
+        data.type,
+        len,
+        collect(AC.BufferSlice, data.buffers);
+        offset=data.offset + offset,
+        children=collect(AC.ArrayData, data.children),
+        dictionary=data.dictionary,
+    )
+end
+
+function _denseunionpair(left, right)
+    AC = CS.ArrowCore
+    leftfield, leftdata = AC.fromjulia("left", left)
+    rightfield, rightdata = AC.fromjulia("right", right)
+    uniontype = AC.UnionType(AC.DenseMode, Int8[0, 1])
+    unionfield =
+        AC.Field("union", uniontype; nullable=false, children=[leftfield, rightfield])
+    function uniondata(typeid)
+        return AC.ArrayData(
+            uniontype,
+            1,
+            [AC._databuffer(Int8[typeid]), AC._databuffer(Int32[0])];
+            children=[leftdata, rightdata],
+            nullcount=0,
+        )
+    end
+    return unionfield, uniondata(0), uniondata(1)
+end
+
+function _normalizationdoc(
+    dictid;
+    poolname,
+    poolvalue,
+    entryname,
+    keyname,
+    valuename,
+    metadata,
+    decimalwidth,
+    nullvalue,
+)
+    dictionary = Dict{String,Any}(
+        "id" => dictid,
+        "indexType" =>
+            Dict{String,Any}("name" => "int", "bitWidth" => 32, "isSigned" => true),
+        "isOrdered" => false,
+    )
+    dictfield = _field(
+        "d",
+        Dict{String,Any}("name" => "floatingpoint", "precision" => "SINGLE");
+        dictionary,
+        metadata,
+    )
+    entryfield = _field(
+        entryname,
+        Dict{String,Any}("name" => "struct");
+        nullable=false,
+        children=Any[
+            _field(
+                keyname,
+                Dict{String,Any}("name" => "int", "bitWidth" => 64, "isSigned" => false),
+                nullable=false,
+            ),
+            _field(valuename, Dict{String,Any}("name" => "utf8")),
+        ],
+    )
+    mapfield = _field(
+        "m",
+        Dict{String,Any}("name" => "map", "keysSorted" => false);
+        children=Any[entryfield],
+    )
+    decimaltype = Dict{String,Any}("name" => "decimal", "precision" => 10, "scale" => 2)
+    decimalwidth === nothing || (decimaltype["bitWidth"] = decimalwidth)
+    fields = Any[
+        dictfield,
+        mapfield,
+        _field("x", decimaltype),
+        _field(
+            "nulls",
+            Dict{String,Any}("name" => "int", "bitWidth" => 64, "isSigned" => true),
+        ),
+    ]
+    mapcolumn = Dict{String,Any}(
+        "name" => "m",
+        "count" => 1,
+        "VALIDITY" => [1],
+        "OFFSET" => [0, 1],
+        "children" => Any[Dict{String,Any}(
+            "name" => entryname,
+            "count" => 1,
+            "children" => Any[
+                Dict{String,Any}("name" => keyname, "count" => 1, "DATA" => [1]),
+                Dict{String,Any}(
+                    "name" => valuename,
+                    "count" => 1,
+                    "OFFSET" => [0, 1],
+                    "DATA" => ["v"],
+                ),
+            ],
+        )],
+    )
+    return Dict{String,Any}(
+        "schema" => Dict{String,Any}("fields" => fields, "metadata" => metadata),
+        "dictionaries" => Any[Dict{String,Any}(
+            "id" => dictid,
+            "data" => Dict{String,Any}(
+                "count" => 1,
+                "columns" => Any[Dict{String,Any}(
+                    "name" => poolname,
+                    "count" => 1,
+                    "VALIDITY" => [1],
+                    "DATA" => Any[poolvalue],
+                )],
+            ),
+        )],
+        "batches" => Any[Dict{String,Any}(
+            "count" => 1,
+            "columns" => Any[
+                Dict{String,Any}(
+                    "name" => "d",
+                    "count" => 1,
+                    "VALIDITY" => [1],
+                    "DATA" => [0],
+                ),
+                mapcolumn,
+                Dict{String,Any}("name" => "x", "count" => 1, "DATA" => ["1"]),
+                Dict{String,Any}(
+                    "name" => "nulls",
+                    "count" => 1,
+                    "VALIDITY" => [0],
+                    "DATA" => [nullvalue],
+                ),
+            ],
+        )],
+    )
+end
+
+@testset "acceptance and conformance support contracts" begin
+    @test CombinedAdapters.Verdict === CS.Verdict === CombinedAdapters.FIRST_VERDICT
+    @test isdefined(CombinedAdapters, :runcorpus)
+    @test isdefined(CombinedAdapters, :runoracle)
+    @test isdefined(CombinedAdapters, :_oracle_parent)
+    @test CombinedAdapters.COMPRESSED_ORACLE_FAMILIES ==
+          ("generated_primitive", "generated_nested_dictionary", "generated_binary_view")
+    targeted = [
+        CombinedAdapters.OracleCase("v__$(family)+$(variant)", "", "") for
+        (family, variant) in CombinedAdapters.TARGETED_ORACLE_VARIANTS
+    ]
+    @test CombinedAdapters._requiretargetedoracles(targeted) === nothing
+    @test_throws ErrorException CombinedAdapters._requiretargetedoracles(targeted[2:end])
+    @test isdefined(NarrowCDataStress.CDataStressSupport, :run)
+    @test !isdefined(NarrowCDataStress.CDataStressSupport, :AcceptanceSupport)
+    @test !isdefined(NarrowCDataStress.CDataStressSupport, :PooledArrays)
+    @test !isdefined(NarrowCDataStress.CDataStressSupport, :ipc_read_battery)
+    @test !isdefined(NarrowCDataStress.CDataStressSupport, :scan_battery)
+    @test isempty(CS.familyskipreason("generated_extension"))
+    @test isempty(CS.familyskipreason("generated_decimal256"))
+    @test !isempty(CS.familyskipreason("generated_primitive", "0.17.1"))
+    @test isempty(CS.familyskipreason("generated_primitive", "0.14.1"))
+    @test isempty(CS.familyskipreason("generated_primitive", "1.0.0-bigendian"))
+    @test !isempty(CS.goldipcskipreason("generated_primitive", "0.14.1"))
+    @test !isempty(CS.goldipcskipreason("generated_primitive", "1.0.0-bigendian"))
+    @test isempty(CS.goldipcskipreason("generated_primitive", "0.17.1"))
+
+    @testset "empty conformance inputs fail closed" begin
+        mktempdir() do corpus
+            root = joinpath(corpus, "data", "arrow-ipc-stream", "integration")
+            mkpath(root)
+            @test_throws ErrorException CombinedAdapters.runcorpus(corpus)
+            @test_throws ErrorException CombinedAdapters.preparecases(
+                corpus,
+                joinpath(corpus, "oracle-work"),
+            )
+
+            skipped = joinpath(root, "0.17.1")
+            mkpath(skipped)
+            write(joinpath(skipped, "only_skipped.json.gz"), UInt8[])
+            @test_throws ErrorException CombinedAdapters.runcorpus(corpus)
+        end
+    end
+
+    @testset "route-specific legacy gold skips" begin
+        AC = CS.ArrowCore
+        AJ = CS.ArrowJSON
+        field, data = AC.fromjulia("x", Union{Missing,Int64}[1, missing, 3])
+        schema = AC.Schema([field])
+        batches = [AC.RecordBatch(schema, [data], 3)]
+        document = AJ.tojson(schema, batches)
+
+        mktempdir() do corpus
+            root = joinpath(corpus, "data", "arrow-ipc-stream", "integration")
+            for (version, family) in (
+                ("0.14.1", "legacy_case"),
+                ("1.0.0-bigendian", "bigendian_case"),
+                ("0.17.1", "v4_case"),
+            )
+                dir = joinpath(root, version)
+                mkpath(dir)
+                jsonbytes = Vector{UInt8}(codeunits(CS.JSON.json(document)))
+                write(
+                    joinpath(dir, family * ".json.gz"),
+                    transcode(CS.CodecZlib.GzipCompressor, jsonbytes),
+                )
+                # These sentinels would fail if a legacy gold route ran.
+                write(joinpath(dir, family * ".stream"), UInt8[0])
+                write(joinpath(dir, family * ".arrow_file"), UInt8[0])
+            end
+
+            for (version, family) in
+                (("0.14.1", "legacy_case"), ("1.0.0-bigendian", "bigendian_case"))
+                verdicts = CS.Verdict[]
+                CombinedAdapters.runfamily(joinpath(root, version), family, verdicts)
+                @test length(verdicts) == 5
+                @test count(v -> v.status == :pass, verdicts) == 3
+                @test count(v -> v.status == :skip, verdicts) == 2
+                @test count(v -> v.status == :fail, verdicts) == 0
+                @test Set(v.check for v in verdicts if v.status == :skip) ==
+                      Set(("gold stream→json", "gold file→json"))
+            end
+
+            workdir = joinpath(corpus, "oracle-work")
+            cases, skips = CombinedAdapters.preparecases(corpus, workdir)
+            @test Set(case.label for case in cases) ==
+                  Set(("0.14.1/legacy_case", "1.0.0-bigendian/bigendian_case"))
+            @test skips == [("0.17.1/v4_case", CS.FAMILY_SKIP["0.17.1"])]
+            @test length(readdir(joinpath(workdir, "cases"))) == 4
+        end
+    end
+
+    @testset "decimal256 integration JSON" begin
+        AJ = CS.ArrowJSON
+        AC = CS.ArrowCore
+        minimum = -(BigInt(1) << 255)
+        maximum = (BigInt(1) << 255) - 1
+        values = string.([minimum, -BigInt(1), BigInt(0), BigInt(1), maximum])
+
+        @test AJ._decimal256bytes("0") == zeros(UInt8, 32)
+        @test AJ._decimal256bytes("1") == [UInt8(1); zeros(UInt8, 31)]
+        @test AJ._decimal256bytes("-1") == fill(typemax(UInt8), 32)
+        @test AJ._decimal256bytes(string(minimum)) == [zeros(UInt8, 31); UInt8(0x80)]
+        @test AJ._decimal256bytes(string(maximum)) ==
+              [fill(typemax(UInt8), 31); UInt8(0x7f)]
+        for value in values
+            @test string(AJ._decimal256value(AJ._decimal256bytes(value))) == value
+        end
+        @test_throws ArgumentError AJ._decimal256bytes(string(minimum - 1))
+        @test_throws ArgumentError AJ._decimal256bytes(string(maximum + 1))
+        @test_throws ArgumentError AJ._decimal256value(zeros(UInt8, 31))
+
+        field = AC.Field("d", AC.DecimalType(76, 0, 256); nullable=true)
+        column = Dict{String,Any}(
+            "name" => "d",
+            "count" => length(values),
+            "VALIDITY" => [1, 1, 0, 1, 1],
+            "DATA" => values,
+        )
+        data = AJ.fromjsoncolumn(
+            field,
+            column,
+            Dict{Int64,AC.ArrayData}(),
+            IdDict{AC.Field,Int64}(),
+        )
+        @test AJ.tojsoncolumn(field, data) == column
+    end
+
+    expected_checks = (
+        ("ours→pyarrow stream", "pyarrow_stream", ".pyarrow.stream"),
+        ("ours→pyarrow file", "pyarrow_file", ".pyarrow.arrow"),
+        ("ours→nanoarrow stream", "nanoarrow_stream", ".nanoarrow.stream"),
+    )
+    @test map(check -> check[1:3], CombinedAdapters.ORACLE_CHECKS) == expected_checks
+    @test !occursin("skip: ", CombinedAdapters.PYDRIVER)
+
+    mktempdir() do dir
+        goldpath = joinpath(dir, "gold.json")
+        write(goldpath, "{}")
+        case = CombinedAdapters.OracleCase("required", "required", goldpath)
+        statuses = Dict{String,Any}(
+            "pyarrow_stream" => "required oracle unavailable",
+            "pyarrow_file" => "required oracle unavailable",
+            "nanoarrow_stream" => "required oracle unavailable",
+        )
+        verdicts = CombinedAdapters.compareresults(
+            [case],
+            Tuple{String,String}[],
+            Dict{String,Any}("cases" => Dict{String,Any}("required" => statuses)),
+            dir,
+        )
+        @test length(verdicts) == length(expected_checks)
+        @test all(verdict -> verdict.status == :fail, verdicts)
+    end
+
+    @test_throws ArgumentError CombinedAdapters.oraclereport(
+        CS.Verdict[],
+        Dict{String,Any}("pyarrow" => "p", "nanoarrow" => "n");
+        io=IOBuffer(),
+    )
+
+    unicode = repeat("é", 201)
+    verdict = CS.documentcheck("family", "check", Dict{String,Any}()) do
+        throw(ErrorException(unicode))
+    end
+    @test verdict.status == :fail
+    @test verdict.detail == repeat("é", 200)
+    @test length(verdict.detail) == 200
+    @test CS.errorverdict("family", "check", ErrorException(repeat("x", 201))).detail ==
+          repeat("x", 200)
+    @test_throws InterruptException CS.documentcheck(
+        () -> throw(InterruptException()),
+        "family",
+        "check",
+        Dict{String,Any}(),
+    )
+    @test_throws OutOfMemoryError CS.documentcheck(
+        () -> throw(OutOfMemoryError()),
+        "family",
+        "check",
+        Dict{String,Any}(),
+    )
+
+    metadata_a = Any[
+        Dict{String,Any}("key" => "z", "value" => "1"),
+        Dict{String,Any}("key" => "a", "value" => "2"),
+    ]
+    metadata_b = reverse(metadata_a)
+    actual = _normalizationdoc(
+        41;
+        poolname="field-name",
+        poolvalue=0.1,
+        entryname="some_entries",
+        keyname="some_key",
+        valuename="some_value",
+        metadata=metadata_a,
+        decimalwidth=128,
+        nullvalue=111,
+    )
+    expected = _normalizationdoc(
+        7;
+        poolname="DICT0",
+        poolvalue=Float64(Float32(0.1)),
+        entryname="entries",
+        keyname="key",
+        valuename="value",
+        metadata=metadata_b,
+        decimalwidth=nothing,
+        nullvalue=-999,
+    )
+    actual_before = deepcopy(actual)
+    expected_before = deepcopy(expected)
+    @test isempty(CS.documentdiffs(actual, expected))
+    @test actual == actual_before
+    @test expected == expected_before
+    changedpool = deepcopy(expected)
+    changedpool["dictionaries"][1]["data"]["columns"][1]["DATA"][1] = 0.2
+    @test !isempty(CS.documentdiffs(actual, changedpool))
+
+    # Materialization, not generic string parsing, owns representation
+    # normalization. Text stays exact; Int64 JSON number/string spellings and
+    # decimal string spellings become the same declared storage value.
+    AC = CS.ArrowCore
+    AJ = CS.ArrowJSON
+    textfield, textdata = AC.fromjulia("text", ["01"])
+    textschema = AC.Schema([textfield])
+    textdoc = AJ.tojson(textschema, [AC.RecordBatch(textschema, [textdata], 1)])
+    changedtext = deepcopy(textdoc)
+    changedtext["batches"][1]["columns"][1]["DATA"][1] = "1"
+    changedtext["batches"][1]["columns"][1]["OFFSET"] = [0, 1]
+    @test !isempty(CS.documentdiffs(textdoc, changedtext))
+
+    intfield, intdata = AC.fromjulia("value", Int64[1])
+    intschema = AC.Schema([intfield])
+    intdoc = AJ.tojson(intschema, [AC.RecordBatch(intschema, [intdata], 1)])
+    intnumber = deepcopy(intdoc)
+    intnumber["batches"][1]["columns"][1]["DATA"] = Any[1]
+    @test isempty(CS.documentdiffs(intdoc, intnumber))
+
+    decimalspelling = deepcopy(expected)
+    decimalspelling["batches"][1]["columns"][3]["DATA"][1] = "01"
+    @test isempty(CS.documentdiffs(expected, decimalspelling))
+
+    # Integration JSON makes these false-valued schema properties required.
+    # A missing property must not compare equal to its explicit false value.
+    required_false_paths = (
+        ("field nullability", (doc) -> delete!(doc["schema"]["fields"][1], "nullable")),
+        (
+            "integer signedness",
+            (doc) -> delete!(
+                doc["schema"]["fields"][2]["children"][1]["children"][1]["type"],
+                "isSigned",
+            ),
+        ),
+        (
+            "map key ordering",
+            (doc) -> delete!(doc["schema"]["fields"][2]["type"], "keysSorted"),
+        ),
+        (
+            "dictionary ordering",
+            (doc) -> delete!(doc["schema"]["fields"][1]["dictionary"], "isOrdered"),
+        ),
+    )
+    for (label, remove!) in required_false_paths
+        incomplete = deepcopy(expected)
+        remove!(incomplete)
+        @testset "$label is required" begin
+            @test !isempty(CS.documentdiffs(incomplete, expected))
+            @test !isempty(CS.documentdiffs(expected, incomplete))
+        end
+    end
+
+    @testset "integration JSON structure is fail-closed" begin
+        structural_mutations = (
+            (
+                "extra root column",
+                doc -> push!(
+                    doc["batches"][1]["columns"],
+                    deepcopy(doc["batches"][1]["columns"][end]),
+                ),
+            ),
+            ("missing root column", doc -> pop!(doc["batches"][1]["columns"])),
+            ("reordered root columns", doc -> reverse!(doc["batches"][1]["columns"])),
+            (
+                "wrong root column name",
+                doc -> begin
+                    doc["batches"][1]["columns"][1]["name"] = "wrong"
+                end,
+            ),
+            (
+                "extra Struct child",
+                doc -> push!(
+                    doc["batches"][1]["columns"][2]["children"][1]["children"],
+                    deepcopy(
+                        doc["batches"][1]["columns"][2]["children"][1]["children"][end],
+                    ),
+                ),
+            ),
+            (
+                "missing Struct child",
+                doc -> pop!(doc["batches"][1]["columns"][2]["children"][1]["children"]),
+            ),
+            (
+                "reordered Struct children",
+                doc -> reverse!(doc["batches"][1]["columns"][2]["children"][1]["children"]),
+            ),
+            (
+                "wrong Struct child name",
+                doc -> begin
+                    doc["batches"][1]["columns"][2]["children"][1]["children"][1]["name"] = "wrong"
+                end,
+            ),
+            (
+                "dictionary batch count mismatch",
+                doc -> begin
+                    doc["dictionaries"][1]["data"]["count"] += 1
+                end,
+            ),
+        )
+        for (label, mutate!) in structural_mutations
+            malformed = deepcopy(expected)
+            mutate!(malformed)
+            @testset "$label" begin
+                @test !isempty(CS.documentdiffs(malformed, expected))
+                @test !isempty(CS.documentdiffs(expected, malformed))
+                @test !isempty(CS.documentdiffs(malformed, malformed))
+            end
+        end
+    end
+
+    @testset "integration JSON array lengths are exact" begin
+        inttype = Dict{String,Any}("name" => "int", "bitWidth" => 32, "isSigned" => true)
+        unionfield = _field(
+            "u",
+            Dict{String,Any}("name" => "union", "mode" => "SPARSE", "typeIds" => [0, 1]);
+            children=Any[_field("a", inttype), _field("b", inttype)],
+        )
+        uniondoc = _onecolumndoc(
+            unionfield,
+            Dict{String,Any}(
+                "name" => "u",
+                "count" => 1,
+                "TYPE_ID" => [0],
+                "children" => Any[
+                    Dict{String,Any}(
+                        "name" => "a",
+                        "count" => 1,
+                        "VALIDITY" => [1],
+                        "DATA" => [10],
+                    ),
+                    Dict{String,Any}(
+                        "name" => "b",
+                        "count" => 1,
+                        "VALIDITY" => [1],
+                        "DATA" => [20],
+                    ),
+                ],
+            ),
+        )
+        array_mutations = (
+            (
+                "extra DATA",
+                expected,
+                doc -> push!(doc["batches"][1]["columns"][4]["DATA"], 0),
+            ),
+            (
+                "truncated DATA",
+                expected,
+                doc -> pop!(doc["batches"][1]["columns"][4]["DATA"]),
+            ),
+            (
+                "extra VALIDITY",
+                expected,
+                doc -> push!(doc["batches"][1]["columns"][4]["VALIDITY"], 1),
+            ),
+            (
+                "truncated VALIDITY",
+                expected,
+                doc -> pop!(doc["batches"][1]["columns"][4]["VALIDITY"]),
+            ),
+            (
+                "extra OFFSET",
+                expected,
+                doc -> push!(doc["batches"][1]["columns"][2]["OFFSET"], 1),
+            ),
+            (
+                "truncated OFFSET",
+                expected,
+                doc -> pop!(doc["batches"][1]["columns"][2]["OFFSET"]),
+            ),
+            (
+                "extra child DATA",
+                expected,
+                doc -> push!(
+                    doc["batches"][1]["columns"][2]["children"][1]["children"][1]["DATA"],
+                    0,
+                ),
+            ),
+            (
+                "truncated child DATA",
+                expected,
+                doc -> pop!(
+                    doc["batches"][1]["columns"][2]["children"][1]["children"][1]["DATA"],
+                ),
+            ),
+            (
+                "extra TYPE_ID",
+                uniondoc,
+                doc -> push!(doc["batches"][1]["columns"][1]["TYPE_ID"], 0),
+            ),
+            (
+                "truncated TYPE_ID",
+                uniondoc,
+                doc -> pop!(doc["batches"][1]["columns"][1]["TYPE_ID"]),
+            ),
+        )
+        for (label, valid, mutate!) in array_mutations
+            malformed = deepcopy(valid)
+            mutate!(malformed)
+            @testset "$label" begin
+                @test !isempty(CS.documentdiffs(malformed, valid))
+                @test !isempty(CS.documentdiffs(valid, malformed))
+                @test !isempty(CS.documentdiffs(malformed, malformed))
+            end
+        end
+    end
+
+    @testset "schema child cardinality is fail-closed" begin
+        child = _field(
+            "child",
+            Dict{String,Any}("name" => "int", "bitWidth" => 32, "isSigned" => true),
+        )
+        no_child_types = Any[
+            Dict{String,Any}("name" => "null"),
+            Dict{String,Any}("name" => "bool"),
+            Dict{String,Any}("name" => "int", "bitWidth" => 32, "isSigned" => true),
+            Dict{String,Any}("name" => "floatingpoint", "precision" => "DOUBLE"),
+            Dict{String,Any}("name" => "utf8"),
+            Dict{String,Any}("name" => "largeutf8"),
+            Dict{String,Any}("name" => "binary"),
+            Dict{String,Any}("name" => "largebinary"),
+            Dict{String,Any}("name" => "utf8view"),
+            Dict{String,Any}("name" => "binaryview"),
+            Dict{String,Any}("name" => "fixedsizebinary", "byteWidth" => 4),
+            Dict{String,Any}("name" => "decimal", "precision" => 10, "scale" => 2),
+            Dict{String,Any}("name" => "date", "unit" => "DAY"),
+            Dict{String,Any}("name" => "time", "unit" => "SECOND", "bitWidth" => 32),
+            Dict{String,Any}("name" => "timestamp", "unit" => "SECOND"),
+            Dict{String,Any}("name" => "duration", "unit" => "SECOND"),
+            Dict{String,Any}("name" => "interval", "unit" => "YEAR_MONTH"),
+        ]
+        for type in no_child_types
+            malformed = _emptydoc(_field("x", type; children=Any[child]))
+            @testset "$(type["name"]) rejects children" begin
+                @test !isempty(CS.documentdiffs(malformed, malformed))
+            end
+        end
+
+        one_child_types = Any[
+            Dict{String,Any}("name" => "list"),
+            Dict{String,Any}("name" => "largelist"),
+            Dict{String,Any}("name" => "listview"),
+            Dict{String,Any}("name" => "largelistview"),
+            Dict{String,Any}("name" => "fixedsizelist", "listSize" => 2),
+            Dict{String,Any}("name" => "map", "keysSorted" => false),
+        ]
+        for type in one_child_types
+            missing = _emptydoc(_field("x", type))
+            extra = _emptydoc(_field("x", type; children=Any[child, deepcopy(child)]))
+            @testset "$(type["name"]) requires one child" begin
+                @test !isempty(CS.documentdiffs(missing, missing))
+                @test !isempty(CS.documentdiffs(extra, extra))
+            end
+        end
+
+        union = _emptydoc(
+            _field(
+                "x",
+                Dict{String,Any}(
+                    "name" => "union",
+                    "mode" => "SPARSE",
+                    "typeIds" => [0, 1],
+                );
+                children=Any[child],
+            ),
+        )
+        encoded = _emptydoc(
+            _field("x", Dict{String,Any}("name" => "runendencoded"); children=Any[child]),
+        )
+        @test !isempty(CS.documentdiffs(union, union))
+        @test !isempty(CS.documentdiffs(encoded, encoded))
+
+        emptystruct = _emptydoc(_field("x", Dict{String,Any}("name" => "struct")))
+        @test isempty(CS.documentdiffs(emptystruct, emptystruct))
+    end
+
+    @testset "schema JSON scalar types are strict" begin
+        scalar_mutations = (
+            (
+                "field nullability Bool as integer",
+                doc -> (doc["schema"]["fields"][2]["children"][1]["nullable"] = 0),
+            ),
+            (
+                "signedness Bool as integer",
+                doc -> (
+                    doc["schema"]["fields"][2]["children"][1]["children"][1]["type"]["isSigned"] =
+                        0
+                ),
+            ),
+            (
+                "integer bit width as float",
+                doc -> (
+                    doc["schema"]["fields"][2]["children"][1]["children"][1]["type"]["bitWidth"] =
+                        64.0
+                ),
+            ),
+            (
+                "integer bit width as string",
+                doc -> (
+                    doc["schema"]["fields"][2]["children"][1]["children"][1]["type"]["bitWidth"] = "64"
+                ),
+            ),
+        )
+        for (label, mutate!) in scalar_mutations
+            malformed = deepcopy(expected)
+            mutate!(malformed)
+            @testset "$label" begin
+                @test !isempty(CS.documentdiffs(malformed, expected))
+                @test !isempty(CS.documentdiffs(expected, malformed))
+                @test !isempty(CS.documentdiffs(malformed, malformed))
+            end
+        end
+    end
+
+    # Metadata is optional. Missing, null, and empty metadata all mean no
+    # key/value metadata, but this equivalence is specific to `metadata`.
+    no_metadata = deepcopy(expected)
+    empty_metadata = deepcopy(expected)
+    null_metadata = deepcopy(expected)
+    delete!(no_metadata["schema"], "metadata")
+    empty_metadata["schema"]["metadata"] = Any[]
+    null_metadata["schema"]["metadata"] = nothing
+    @test isempty(CS.documentdiffs(no_metadata, empty_metadata))
+    @test isempty(CS.documentdiffs(no_metadata, null_metadata))
+
+    @testset "nested nulls compare by public-domain value" begin
+        inttype = Dict{String,Any}("name" => "int", "bitWidth" => 32, "isSigned" => true)
+
+        structfield = _field(
+            "parent",
+            Dict{String,Any}("name" => "struct");
+            children=Any[_field("item", inttype)],
+        )
+        structactual = _onecolumndoc(
+            structfield,
+            Dict{String,Any}(
+                "name" => "parent",
+                "count" => 3,
+                "VALIDITY" => [1, 0, 1],
+                "children" => Any[Dict{String,Any}(
+                    "name" => "item",
+                    "count" => 3,
+                    "VALIDITY" => [1, 1, 1],
+                    "DATA" => [10, 111, 30],
+                )],
+            ),
+        )
+        structexpected = deepcopy(structactual)
+        structexpected["batches"][1]["columns"][1]["children"][1]["DATA"][2] = -111
+        structbad = deepcopy(structexpected)
+        structbad["batches"][1]["columns"][1]["children"][1]["DATA"][3] = 999
+
+        fixedfield = _field(
+            "parent",
+            Dict{String,Any}("name" => "fixedsizelist", "listSize" => 2);
+            children=Any[_field("item", inttype)],
+        )
+        fixedactual = _onecolumndoc(
+            fixedfield,
+            Dict{String,Any}(
+                "name" => "parent",
+                "count" => 3,
+                "VALIDITY" => [1, 0, 1],
+                "children" => Any[Dict{String,Any}(
+                    "name" => "item",
+                    "count" => 6,
+                    "VALIDITY" => fill(1, 6),
+                    "DATA" => [10, 11, 111, 112, 30, 31],
+                )],
+            ),
+        )
+        fixedexpected = deepcopy(fixedactual)
+        fixedexpected["batches"][1]["columns"][1]["children"][1]["DATA"][3:4] = [-111, -112]
+        fixedbad = deepcopy(fixedexpected)
+        fixedbad["batches"][1]["columns"][1]["children"][1]["DATA"][6] = 999
+
+        listfield = _field(
+            "parent",
+            Dict{String,Any}("name" => "list");
+            children=Any[_field("item", inttype)],
+        )
+        listactual = _onecolumndoc(
+            listfield,
+            Dict{String,Any}(
+                "name" => "parent",
+                "count" => 3,
+                "VALIDITY" => [1, 0, 1],
+                "OFFSET" => [0, 1, 3, 4],
+                "children" => Any[Dict{String,Any}(
+                    "name" => "item",
+                    "count" => 4,
+                    "VALIDITY" => fill(1, 4),
+                    "DATA" => [10, 111, 112, 30],
+                )],
+            ),
+        )
+        listexpected = _onecolumndoc(
+            listfield,
+            Dict{String,Any}(
+                "name" => "parent",
+                "count" => 3,
+                "VALIDITY" => [1, 0, 1],
+                "OFFSET" => [0, 1, 1, 2],
+                "children" => Any[Dict{String,Any}(
+                    "name" => "item",
+                    "count" => 2,
+                    "VALIDITY" => fill(1, 2),
+                    "DATA" => [10, 30],
+                )],
+            ),
+        )
+        listbad = deepcopy(listexpected)
+        listbad["batches"][1]["columns"][1]["children"][1]["DATA"][2] = 999
+
+        entriesfield = _field(
+            "entries",
+            Dict{String,Any}("name" => "struct");
+            nullable=false,
+            children=Any[_field("key", inttype; nullable=false), _field("value", inttype)],
+        )
+        mapfield = _field(
+            "parent",
+            Dict{String,Any}("name" => "map", "keysSorted" => false);
+            children=Any[entriesfield],
+        )
+        mapactual = _onecolumndoc(
+            mapfield,
+            Dict{String,Any}(
+                "name" => "parent",
+                "count" => 3,
+                "VALIDITY" => [1, 0, 1],
+                "OFFSET" => [0, 1, 3, 4],
+                "children" => Any[Dict{String,Any}(
+                    "name" => "entries",
+                    "count" => 4,
+                    "VALIDITY" => fill(1, 4),
+                    "children" => Any[
+                        Dict{String,Any}(
+                            "name" => "key",
+                            "count" => 4,
+                            "VALIDITY" => fill(1, 4),
+                            "DATA" => [1, 111, 112, 3],
+                        ),
+                        Dict{String,Any}(
+                            "name" => "value",
+                            "count" => 4,
+                            "VALIDITY" => fill(1, 4),
+                            "DATA" => [10, 111, 112, 30],
+                        ),
+                    ],
+                )],
+            ),
+        )
+        mapexpected = _onecolumndoc(
+            mapfield,
+            Dict{String,Any}(
+                "name" => "parent",
+                "count" => 3,
+                "VALIDITY" => [1, 0, 1],
+                "OFFSET" => [0, 1, 1, 2],
+                "children" => Any[Dict{String,Any}(
+                    "name" => "entries",
+                    "count" => 2,
+                    "VALIDITY" => fill(1, 2),
+                    "children" => Any[
+                        Dict{String,Any}(
+                            "name" => "key",
+                            "count" => 2,
+                            "VALIDITY" => fill(1, 2),
+                            "DATA" => [1, 3],
+                        ),
+                        Dict{String,Any}(
+                            "name" => "value",
+                            "count" => 2,
+                            "VALIDITY" => fill(1, 2),
+                            "DATA" => [10, 30],
+                        ),
+                    ],
+                )],
+            ),
+        )
+        mapbad = deepcopy(mapexpected)
+        mapbad["batches"][1]["columns"][1]["children"][1]["children"][2]["DATA"][2] = 999
+
+        for (label, actualdoc, expecteddoc, baddoc) in (
+            ("struct", structactual, structexpected, structbad),
+            ("fixed-size list", fixedactual, fixedexpected, fixedbad),
+            ("list with a non-empty null segment", listactual, listexpected, listbad),
+            ("map with a non-empty null segment", mapactual, mapexpected, mapbad),
+        )
+            @testset "$label" begin
+                actualbefore = deepcopy(actualdoc)
+                expectedbefore = deepcopy(expecteddoc)
+                @test isempty(CS.documentdiffs(actualdoc, expecteddoc))
+                @test !isempty(CS.documentdiffs(actualdoc, baddoc))
+                @test actualdoc == actualbefore
+                @test expecteddoc == expectedbefore
+            end
+        end
+    end
+
+    @testset "nonzero-offset Core batch windows" begin
+        AC = CS.ArrowCore
+        stringfield, stringdata = AC.fromjulia("text", ["zero", "one", "two", "three"])
+
+        binarytype = AC.BinaryType(true)
+        binaryfield = AC.Field("large_binary", binarytype; nullable=false)
+        binaryvalues = [UInt8[0x00], UInt8[0x01, 0x02], UInt8[], UInt8[0x03]]
+        binarydata = AC.ArrayData(
+            binarytype,
+            4,
+            [
+                AC.BufferSlice(),
+                AC._databuffer(Int64[0, 1, 3, 3, 4]),
+                AC._databuffer(vcat(binaryvalues...)),
+            ];
+            nullcount=0,
+        )
+
+        listfield, listdata =
+            AC.fromjulia("list", [Int32[0], Int32[1, 2], Int32[3], Int32[4, 5]])
+        structfield, structdata = AC.fromjulia_struct(
+            "struct",
+            (number=Int32[0, 1, 2, 3], text=["a", "b", "c", "d"]),
+        )
+        schema = AC.Schema([stringfield, binaryfield, listfield, structfield])
+        source = AC.RecordBatch(schema, [stringdata, binarydata, listdata, structdata], 4)
+        sliced = AC.RecordBatch(
+            schema,
+            [
+                _coreview(stringdata, 1, 2),
+                _coreview(binarydata, 1, 2),
+                _coreview(listdata, 1, 2),
+                _coreview(structdata, 1, 2),
+            ],
+            2,
+        )
+
+        @test isempty(CS.corebatchdiffs(sliced, source; expectedoffset=1, rows=2))
+        @test !isempty(CS.corebatchdiffs(sliced, source; expectedoffset=0, rows=2))
+        @test_throws BoundsError CS.corebatchdiffs(sliced, source; expectedoffset=3, rows=2)
+    end
+
+    @testset "Union comparison preserves selected type ids" begin
+        AC = CS.ArrowCore
+        AJ = CS.ArrowJSON
+
+        function rejectdifferentroute(field, expecteddata, actualdata)
+            schema = AC.Schema([field])
+            expected = AC.RecordBatch(schema, [expecteddata], 1)
+            actual = AC.RecordBatch(schema, [actualdata], 1)
+            @test !isempty(CS.corebatchdiffs(actual, expected))
+            @test !isempty(
+                CS.documentdiffs(
+                    AJ.tojson(schema, [actual]),
+                    AJ.tojson(schema, [expected]),
+                ),
+            )
+            return nothing
+        end
+
+        for (label, left, right) in (
+            ("Int64 versus Utf8", Int64[1], String["1"]),
+            ("Bool versus Int64", Bool[true], Int64[1]),
+        )
+            @testset "$label" begin
+                field, expecteddata, actualdata = _denseunionpair(left, right)
+                rejectdifferentroute(field, expecteddata, actualdata)
+            end
+        end
+
+        # The selected Arrow child is semantic even when both children expose
+        # the same Julia value and type. Nest the Union so a scalar-type check
+        # or a top-level-only route check cannot satisfy this regression.
+        unionfield, unionexpected, unionactual = _denseunionpair(Int64[1], Int64[1])
+        structtype = AC.StructType()
+        structfield = AC.Field("parent", structtype; nullable=true, children=[unionfield])
+        visibleexpected = AC.ArrayData(
+            structtype,
+            1,
+            [AC.BufferSlice()];
+            children=[unionexpected],
+            nullcount=0,
+        )
+        visibleactual = AC.ArrayData(
+            structtype,
+            1,
+            [AC.BufferSlice()];
+            children=[unionactual],
+            nullcount=0,
+        )
+        @test AC.materialize(structfield, visibleactual) ==
+              AC.materialize(structfield, visibleexpected)
+        rejectdifferentroute(structfield, visibleexpected, visibleactual)
+
+        # Map values and dictionary pools are two places where a generic
+        # materializer can erase a nested Union route before comparison.
+        keyfield, keydata = AC.fromjulia("key", Int32[7])
+        entriesfield =
+            AC.Field("entries", structtype; nullable=false, children=[keyfield, unionfield])
+        expectedentries = AC.ArrayData(
+            structtype,
+            1,
+            [AC.BufferSlice()];
+            children=[keydata, unionexpected],
+            nullcount=0,
+        )
+        actualentries = AC.ArrayData(
+            structtype,
+            1,
+            [AC.BufferSlice()];
+            children=[keydata, unionactual],
+            nullcount=0,
+        )
+        maptype = AC.MapType(false)
+        mapfield = AC.Field("map", maptype; nullable=false, children=[entriesfield])
+        expectedmap = AC.ArrayData(
+            maptype,
+            1,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 1])];
+            children=[expectedentries],
+            nullcount=0,
+        )
+        actualmap = AC.ArrayData(
+            maptype,
+            1,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 1])];
+            children=[actualentries],
+            nullcount=0,
+        )
+        rejectdifferentroute(mapfield, expectedmap, actualmap)
+
+        dictionarytype = AC.DictionaryType(AC.IntType(8, false), unionfield.type, false)
+        dictionaryfield = AC.Field(
+            "dictionary",
+            dictionarytype;
+            nullable=false,
+            children=unionfield.children,
+        )
+        expecteddictionary = AC.ArrayData(
+            dictionarytype,
+            1,
+            [AC.BufferSlice(), AC._databuffer(UInt8[0])];
+            dictionary=unionexpected,
+            nullcount=0,
+        )
+        actualdictionary = AC.ArrayData(
+            dictionarytype,
+            1,
+            [AC.BufferSlice(), AC._databuffer(UInt8[0])];
+            dictionary=unionactual,
+            nullcount=0,
+        )
+        rejectdifferentroute(dictionaryfield, expecteddictionary, actualdictionary)
+
+        # Physical child slots below a null parent remain unspecified. A route
+        # tag must therefore follow the same masking rule as its public-domain value.
+        hiddenvalidity = AC._databuffer(UInt8[0x00])
+        hiddenexpected = AC.ArrayData(
+            structtype,
+            1,
+            [hiddenvalidity];
+            children=[unionexpected],
+            nullcount=1,
+        )
+        hiddenactual = AC.ArrayData(
+            structtype,
+            1,
+            [hiddenvalidity];
+            children=[unionactual],
+            nullcount=1,
+        )
+        hiddenschema = AC.Schema([structfield])
+        expectedbatch = AC.RecordBatch(hiddenschema, [hiddenexpected], 1)
+        actualbatch = AC.RecordBatch(hiddenschema, [hiddenactual], 1)
+        @test isempty(CS.corebatchdiffs(actualbatch, expectedbatch))
+        @test isempty(
+            CS.documentdiffs(
+                AJ.tojson(hiddenschema, [actualbatch]),
+                AJ.tojson(hiddenschema, [expectedbatch]),
+            ),
+        )
+    end
+end
+
+end # module ConformanceSupportTests
diff --git a/test/core_tests.jl b/test/core_tests.jl
new file mode 100644
index 00000000..8c728ccc
--- /dev/null
+++ b/test/core_tests.jl
@@ -0,0 +1,2316 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Core unit tests: ArrowCore's regions, descriptors, layouts, validation,
+# accessors, and builders — plus the two adapter seams the builders feed
+# (IPC write/read and C data export/import) where a Core column must cross.
+
+using Test
+
+# Top-level release-action trampoline for the ReleaseCell test (the closure
+# form of @cfunction is unsupported on some platforms).
+function _cell_bump(p::Ptr{Cvoid})::Cvoid
+    (unsafe_pointer_to_objref(p)::Base.RefValue{Int})[] += 1
+    return nothing
+end
+# Its C pointer. A `@cfunction`, `@allocated`, or `@timed` written in a top-level
+# testset makes Julia compile that whole testset as one function before running
+# it, which takes minutes for "ArrowCore"; the testset calls these instead.
+_cell_bump_ptr() = @cfunction(_cell_bump, Cvoid, (Ptr{Cvoid},))
+_allocated(f, args...) = @allocated f(args...)
+
+using Arrow
+using Arrow.ArrowCore
+const AC = ArrowCore
+
+@noinline _build_bool_probe(v) = AC.fromjulia("b", v)
+
+struct ManagedLoad
+    value::Any
+end
+
+struct GcTriggeredLoad
+    value::UInt8
+end
+
+struct UnregisteredArrowType <: ArrowType end
+
+mutable struct RegionRootProbe
+    bytes::Vector{UInt8}
+    finalized::Base.RefValue{Bool}
+end
+
+function AC.datatype_alignment(::Type{GcTriggeredLoad})
+    GC.gc(true)
+    return 1
+end
+
+@noinline function load_while_collecting(finalized)
+    root = RegionRootProbe(UInt8[0x2a], finalized)
+    finalizer(root) do probe
+        probe.finalized[] = true
+    end
+    region = AC.OwnerRegion(Ptr{UInt8}(pointer(root.bytes)), 1; root=root)
+    slice = BufferSlice(region, 0, 1)
+    return AC.loadat(slice, GcTriggeredLoad, Int64(0)), finalized[]
+end
+
+# A region over a vector that `resize!` then moves to new storage, and a weak
+# reference to the storage the region points at.
+@noinline function resized_region()
+    v = collect(Int64, 1:1000)
+    b = BufferSlice(heapregion(v), 0, 8000)
+    storage = WeakRef(v.ref.mem)
+    resize!(v, 1_000_000)
+    return b, storage
+end
+
+@noinline function read_mapped_slice_while_collecting(path)
+    # Keep only the slice local. Its region must be enough to retain the Mmap
+    # array through collection and the raw loads below.
+    b = BufferSlice(mmapregion(path), 0, 8)
+    rooted = b.region.root isa Vector{UInt8}
+    GC.gc(true)
+    return rooted,
+    AC.loadat(b, UInt8, Int64(0)),
+    AC.loadat(b, UInt32, Int64(4)),
+    AC.loadat(b, UInt8, Int64(7))
+end
+
+@testset "ArrowCore" begin
+    @testset "OwnerRegion: reachability-based validity" begin
+        @testset "heap wrap is zero-copy and rooted" begin
+            v = Int64[1, 2, 3, 4]
+            r = heapregion(v)
+            @test r.len == 32
+            @test r.root === AC._storageroot(v)
+            b = BufferSlice(r, 0, 32)
+            @test AC.loadat(b, Int64, Int64(0)) == 1
+            @test AC.loadat(b, Int64, Int64(24)) == 4
+            # Regions are immutable values: nothing to close, nothing to race.
+            @test_throws ErrorException setproperty!(r, :root, nothing)
+        end
+
+        # Julia 1.10 vectors own their bytes directly; there is no storage
+        # object to keep alive apart from the vector.
+        VERSION >= v"1.11" &&
+            @testset "a heap region keeps its storage when the vector is resized" begin
+                b, storage = resized_region()
+                GC.gc(true)
+                @test storage.value !== nothing
+                @test AC.loadat(b, Int64, Int64(7992)) == 1000
+            end
+
+        @testset "raw load preserves the region root" begin
+            finalized = Ref(false)
+            value, finalized_during_load = load_while_collecting(finalized)
+            @test value == GcTriggeredLoad(0x2a)
+            @test !finalized_during_load
+        end
+
+        @testset "construction validation" begin
+            @test_throws ArgumentError AC.OwnerRegion(Ptr{UInt8}(0), 1)
+            @test_throws ArgumentError AC.OwnerRegion(Ptr{UInt8}(8), -1)
+            @test_throws ArgumentError AC.OwnerRegion(Ptr{UInt8}(8), 1)
+            # extents that would wrap native pointer arithmetic are rejected
+            @test_throws ArgumentError AC.OwnerRegion(
+                Ptr{UInt8}(typemax(UInt) - 8),
+                64;
+                root=UInt8[],
+            )
+            @test_throws ArgumentError heapregion(["not", "isbits"])
+        end
+
+        @testset "mapped region: stdlib-backed, reachability-valid" begin
+            path = tempname()
+            write(path, UInt8[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88])
+            rooted, firstbyte, lastword, lastbyte = read_mapped_slice_while_collecting(path)
+            @test rooted
+            @test firstbyte == 0x11
+            @test lastword == 0x88776655
+            @test lastbyte == 0x88
+            emptypath = tempname()
+            touch(emptypath)
+            @test_throws ArgumentError mmapregion(emptypath)
+            rm(emptypath)
+            @test_throws SystemError mmapregion(tempname())
+            # The helper returned no region or slice. Collect the stdlib mapping
+            # before deleting the path on platforms that lock active mappings.
+            GC.gc(true)
+            GC.gc(true)
+            rm(path)
+        end
+    end
+
+    @testset "BufferSlice bounds" begin
+        r = heapregion(zeros(UInt8, 16))
+        @test_throws ArgumentError BufferSlice(r, 0, 17)
+        @test_throws ArgumentError BufferSlice(r, 16, 1)
+        @test_throws ArgumentError BufferSlice(r, -1, 4)
+        b = BufferSlice(r, 8, 8)
+        @test length(b) == 8
+        @test_throws ArgumentError AC.subslice(b, 4, 8)   # 4+8 > 8
+        @test_throws ArgumentError AC.subslice(b, -1, 1)  # cannot escape parent span
+        @test_throws ArgumentError AC.subslice(b, 0, -1)
+        sub = AC.subslice(b, 4, 4)
+        @test length(sub) == 4
+        # loadat re-checks: last line of defense before the pointer
+        @test_throws BoundsError AC.loadat(b, UInt64, Int64(1))
+        @test_throws BoundsError AC.loadat(b, UInt8, Int64(8))
+        @test_throws BoundsError AC.loadat(b, UInt8, typemax(Int64))
+        @test_throws ArgumentError OwnerRegion(Ptr{UInt8}(typemax(UInt)), 2)
+        # empty buffer
+        e = BufferSlice()
+        @test length(e) == 0
+        @test AC.isempty_buffer(e)
+        # Arbitrary bytes must never become managed Julia references.
+        managed = BufferSlice(r, 0, sizeof(ManagedLoad))
+        @test_throws ArgumentError AC.loadat(managed, ManagedLoad, Int64(0))
+    end
+
+    @testset "unaligned loads" begin
+        bytes = UInt8[0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02]
+        r = heapregion(bytes)
+        b = BufferSlice(r, 0, 9)
+        # offset 1 is misaligned for Int64; must still read correctly
+        v = AC.loadat(b, Int64, Int64(1))
+        @test v == Int64(1) | (Int64(2) << 56)
+    end
+
+    @testset "layout registry covers all format-1.5 layouts" begin
+        types = AC.ArrowType[
+            NullType(),
+            BoolType(),
+            IntType(32, true),
+            IntType(64, false),
+            FloatType(64),
+            DecimalType(10, 2, 128),
+            DecimalType(9, 2, 32),
+            FixedSizeBinaryType(16),
+            BinaryType(false),
+            BinaryType(true),
+            Utf8Type(false),
+            Utf8Type(true),
+            DateType(AC.DAY),
+            TimeType(AC.NANOSECOND, 64),
+            TimestampType(AC.MICROSECOND, "UTC"),
+            DurationType(AC.MILLISECOND),
+            IntervalType(AC.MONTH_DAY_NANO),
+            ListType(false),
+            ListType(true),
+            FixedSizeListType(3),
+            StructType(),
+            MapType(false),
+            UnionType(AC.DenseMode, Int8[0, 1]),
+            UnionType(AC.SparseMode, Int8[0, 1]),
+            DictionaryType(IntType(32, true), Utf8Type(false), false),
+            ViewType(true),
+            ListViewType(false),
+            RunEndEncodedType(),
+        ]
+        for t in types
+            spec = layoutspec(t)
+            @test spec isa LayoutSpec
+            # offsets width only ever 0/4/8
+            @test spec.offsetwidth in (0, 4, 8)
+        end
+        @test_throws ArgumentError layoutspec(UnregisteredArrowType())
+        @test_throws ArgumentError AC._validate_descriptor(UnregisteredArrowType())
+        # two timestamps with different timezones: same Julia type
+        @test typeof(TimestampType(AC.SECOND, "America/Denver")) ==
+              typeof(TimestampType(AC.NANOSECOND, nothing))
+
+        # Schema/data containers defensively copy mutable caller input and expose
+        # no normal mutation API. This keeps semantic-cache results stable.
+        ids = Int8[0, 1]
+        ut = UnionType(AC.SparseMode, ids)
+        ids[1] = 7
+        @test collect(ut.typeids) == Int8[0, 1]
+        @test_throws Exception setindex!(ut.typeids, Int8(7), 1)
+        children = Field[fromjulia("x", Int64[])[1]]
+        frozen = Field("l", ListType(false); children=children)
+        empty!(children)
+        @test length(frozen.children) == 1
+
+        # Sequential metadata is the lossless representation: preserve order and
+        # duplicate keys while defensively copying the caller's container.
+        ordered_metadata = ["k" => "first", "k" => "second", "z" => "last"]
+        metadata_field = Field("m", IntType(8, true); metadata=ordered_metadata)
+        pop!(ordered_metadata)
+        @test collect(metadata_field.metadata) ==
+              ["k" => "first", "k" => "second", "z" => "last"]
+        @test collect(
+            Schema([metadata_field]; metadata=("a" => "1", "a" => "2")).metadata,
+        ) == ["a" => "1", "a" => "2"]
+        @test_throws ArgumentError Field("m", IntType(8, true); metadata=["not a pair"])
+        @test_throws ArgumentError Schema([metadata_field]; metadata=("not a pair",))
+
+        # ListView offsets are per-slot and may be unordered; view data buffers
+        # are variadic after the fixed validity/views pair. Both validate and
+        # read end-to-end.
+        cf, cd = fromjulia("item", Int64[1, 2, 3])
+        lvt = ListViewType(false)
+        lvf = Field("lv", lvt; children=[cf])
+        lvd = AC.ArrayData(
+            lvt,
+            2,
+            [BufferSlice(), AC._databuffer(Int32[2, 0]), AC._databuffer(Int32[1, 2])];
+            children=[cd],
+            nullcount=0,
+        )
+        @test validate_structural(lvf, lvd) === lvd
+        @test validate_semantic(lvf, lvd) === lvd
+        @test getvalue(lvf, lvd, 1) == [3]          # unordered offsets: slot 1 reads the tail
+        @test getvalue(lvf, lvd, 2) == [1, 2]
+        vt = ViewType(true)
+        vf = Field("v", vt)
+        vd = AC.ArrayData(
+            vt,
+            1,
+            [BufferSlice(), AC._databuffer(zeros(UInt8, 16)), AC._databuffer(UInt8[0x61])];
+            nullcount=0,
+        )
+        @test validate_structural(vf, vd) === vd
+        @test validate_semantic(vf, vd) === vd
+        @test getvalue(vf, vd, 1) == ""             # zeroed entry: inline empty string
+    end
+
+    @testset "fromjulia round-trips" begin
+        @testset "zero-copy primitive" begin
+            v = Int64[10, 20, 30]
+            f, d = fromjulia("x", v)
+            @test f.type == IntType(64, true)
+            @test nullcount(d) == 0
+            @test [getvalue(f, d, i) for i = 1:3] == v
+            @test materialize(f, d) == v
+        end
+
+        @testset "nullable primitive" begin
+            f, d = fromjulia("x", [1.5, missing, 3.5])
+            validate_structural(f, d)
+            @test nullcount(d) == 1
+            @test isequal(materialize(f, d), [1.5, missing, 3.5])
+        end
+
+        @testset "bool with missings (bit-packed values)" begin
+            f, d = fromjulia("b", [true, missing, false, true])
+            @test isequal(materialize(f, d), [true, missing, false, true])
+        end
+
+        @testset "strings incl. empty and missing" begin
+            vals = ["hey", "", missing, "αβ∀"]
+            f, d = fromjulia("s", collect(vals))
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            validate_full(f, d)
+            @test isequal(materialize(f, d), vals)
+        end
+
+        @testset "release! releases deterministically" begin
+            f, d = fromjulia("x", Int64[1, 2, 3])
+            buf = d.buffers[2]
+            @test AC.loadat(buf, Int64, Int64(0)) == 1
+            r = buf.region::OwnerRegion
+            # A heap region is a BORROW: release! revokes but must not run the
+            # caller's own finalizers on the borrowed vector.
+            borrowed = r.root
+            callerfin = Ref(false)
+            finalizer(_ -> callerfin[] = true, borrowed)
+            release!(r)
+            @test !callerfin[]
+            @test_throws InvalidStateException AC.loadat(buf, Int64, Int64(0))
+            @test_throws InvalidStateException AC.slicebytes(buf)
+            @test_throws InvalidStateException materialize(f, d)
+            release!(r)   # idempotent
+            GC.@preserve borrowed nothing
+
+            # A deep copy shares the region and its release: it is revoked
+            # with the original, and releasing it again is inert.
+            copied = Ref(0)
+            cv = UInt8[1, 2]
+            cr = GC.@preserve cv OwnerRegion(
+                pointer(cv),
+                2;
+                root=cv,
+                cell=ReleaseCell(_cell_bump_ptr(), copied),
+            )
+            cb = deepcopy(BufferSlice(cr, 0, 2))
+            @test cb.region.root === cr.root
+            @test AC.loadat(cb, UInt8, Int64(1)) == 0x02
+            release!(cr)
+            @test_throws InvalidStateException AC.loadat(cb, UInt8, Int64(0))
+            release!(cb.region)
+            @test copied[] == 1
+
+            # Regions sharing one ReleaseCell are revoked together and the
+            # release action runs exactly once.
+            released = Ref(0)
+            cell = ReleaseCell(_cell_bump_ptr(), released)
+            v1, v2 = UInt8[1, 2], UInt8[3, 4]
+            ra = GC.@preserve v1 OwnerRegion(pointer(v1), 2; root=v1, cell=cell)
+            rb = GC.@preserve v2 OwnerRegion(pointer(v2), 2; root=v2, cell=cell)
+            sa, sb = BufferSlice(ra, 0, 2), BufferSlice(rb, 0, 2)
+            @test AC.loadat(sb, UInt8, Int64(0)) == 0x03
+            release!(ra)
+            @test_throws InvalidStateException AC.loadat(sa, UInt8, Int64(0))
+            @test_throws InvalidStateException AC.loadat(sb, UInt8, Int64(0))
+            release!(rb)
+            @test released[] == 1
+
+            # An mmap-backed region actually unmaps NOW: the release targets the
+            # object Mmap registered the unmap finalizer on (`_storageroot`), and
+            # the observer proves it ran — rm() alone would not, since POSIX
+            # happily unlinks mapped files.
+            path, io = mktemp()
+            write(io, zeros(UInt8, 64))
+            close(io)
+            mr = mmapregion(path)
+            mslice = BufferSlice(mr, 0, mr.len)
+            @test AC.loadat(mslice, UInt8, Int64(0)) == 0x00
+            unmapped = Ref(false)
+            finalizer(_ -> unmapped[] = true, AC._storageroot(mr.root::Vector{UInt8}))
+            release!(mr)
+            @test unmapped[]
+            @test_throws InvalidStateException AC.loadat(mslice, UInt8, Int64(0))
+            rm(path)
+        end
+
+        @testset "canonical bit-packed form is full-tier only" begin
+            # A junk trailing bit in the final validity byte: semantic accepts
+            # (readers must not rely on unused bits), validate_full rejects.
+            vals = Union{Missing,Int64}[1, missing, 3]
+            f, d = fromjulia("x", vals)
+            vbytes = AC.slicebytes(AC.validitybuffer(d))
+            junk = copy(vbytes)
+            junk[end] |= 0x80                     # bit 8 of a 3-element bitmap
+            jd = AC.ArrayData(
+                d.type,
+                d.len,
+                [AC._databuffer(junk), d.buffers[2]];
+                nullcount=1,
+            )
+            @test validate_semantic(f, jd) === jd
+            @test_throws ValidationError AC.validate_full(f, jd)
+            @test AC.validate_full(f, d) === d    # canonical original passes
+            # Sliced windows are exempt: trailing bits may belong to a sibling.
+            sliced = AC.ArrayData(
+                d.type,
+                2,
+                [AC._databuffer(junk), d.buffers[2]];
+                offset=1,
+                nullcount=1,
+            )
+            @test validate_semantic(f, sliced) === sliced
+            @test AC.validate_full(f, sliced) === sliced
+        end
+
+        @testset "list of ints with missing" begin
+            vals = [[1, 2], Int[], missing, [3]]
+            f, d = fromjulia("l", collect(vals))
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            out = materialize(f, d)
+            @test isequal(out, [[1, 2], Int[], missing, [3]])
+        end
+
+        @testset "empty lists preserve their declared child type" begin
+            ff, fd = fromjulia("empty-float-list", Vector{Vector{Float64}}())
+            @test ff.children[1].type == FloatType(64)
+            @test isempty(materialize(ff, fd))
+
+            uf, ud = fromjulia(
+                "missing-uint-list",
+                Union{Missing,Vector{UInt8}}[missing, missing],
+            )
+            @test uf.children[1].type == IntType(8, false)
+            @test isequal(materialize(uf, ud), [missing, missing])
+
+            nf, nd = fromjulia("null-list", [Missing[missing, missing], Missing[]])
+            @test nf.children[1].type isa NullType
+            @test nf.children[1].nullable
+            @test isequal(materialize(nf, nd), [Missing[missing, missing], Missing[]])
+            @test_throws ArgumentError fromjulia("bottom", Union{}[])
+        end
+
+        @testset "struct" begin
+            f, d = AC.fromjulia_struct("st", (a=Int64[1, 2], b=["x", "y"]))
+            validate_structural(f, d)
+            # Core struct scalars are ordered name=>value pairs; the NamedTuple
+            # surface is the facade's (or a static claim through getvalue(::Type{T}, ...)).
+            @test materialize(f, d) == [["a" => 1, "b" => "x"], ["a" => 2, "b" => "y"]]
+        end
+
+        @testset "dictionary-encoded" begin
+            f, d = AC.fromjulia_dict("d", ["lo", "hi"], [0, 1, missing, 0])
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test isequal(materialize(f, d), ["lo", "hi", missing, "lo"])
+        end
+
+        @testset "maximum narrow dictionary indices" begin
+            for (T, signed) in ((Int8, true), (UInt8, false))
+                n = Int(typemax(T)) + 1
+                vf, vd = fromjulia("pool", collect(Int64(1):Int64(n)))
+                t = DictionaryType(IntType(8, signed), vf.type, false)
+                f = Field("d", t; nullable=false)
+                d = AC.ArrayData(
+                    t,
+                    1,
+                    [BufferSlice(), AC._databuffer(T[typemax(T)])];
+                    dictionary=vd,
+                    nullcount=0,
+                )
+                validate_structural(f, d)
+                validate_semantic(f, d)
+                @test materialize(f, d) == Int64[n]
+            end
+        end
+
+        @testset "canonical empty offset arrays" begin
+            st = Utf8Type(false)
+            sf = Field("s", st)
+            sd = AC.ArrayData(
+                st,
+                0,
+                [BufferSlice(), BufferSlice(), BufferSlice()];
+                nullcount=0,
+            )
+            @test validate_structural(sf, sd) === sd
+            @test validate_semantic(sf, sd) === sd
+            @test isempty(materialize(sf, sd))
+
+            cf, cd = fromjulia("item", Int64[])
+            lt = ListType(false)
+            lf = Field("l", lt; children=[cf])
+            ld = AC.ArrayData(
+                lt,
+                0,
+                [BufferSlice(), BufferSlice()];
+                children=[cd],
+                nullcount=0,
+            )
+            @test validate_structural(lf, ld) === ld
+            @test validate_semantic(lf, ld) === ld
+            @test isempty(materialize(lf, ld))
+        end
+
+        @testset "dictionary pool nullability is independent" begin
+            vf, vd = fromjulia("pool", Union{Missing,String}[missing, "x"])
+            t = DictionaryType(IntType(32, true), vf.type, false)
+            f = Field("d", t; nullable=false, children=vf.children)
+            d = AC.ArrayData(
+                t,
+                2,
+                [BufferSlice(), AC._databuffer(Int32[0, 1])];
+                dictionary=vd,
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test isequal(materialize(f, d), [missing, "x"])
+        end
+    end
+
+    # Layouts fromjulia doesn't build: construct by hand to prove the accessors.
+    @testset "hand-built layouts" begin
+        @testset "fixed-size list" begin
+            t = FixedSizeListType(2)
+            cf, cd = fromjulia("item", Int64[1, 2, 3, 4, 5, 6])
+            f = Field("fsl", t; children=[cf])
+            d = AC.ArrayData(t, 3, [BufferSlice()]; children=[cd], nullcount=0)
+            validate_structural(f, d)
+            @test materialize(f, d) == [[1, 2], [3, 4], [5, 6]]
+        end
+
+        @testset "map" begin
+            # map<utf8, int64>: entries struct("key","value"), offsets [0,2,3]
+            kf, kd = fromjulia("key", ["a", "b", "c"])
+            vf, vd = fromjulia("value", Int64[1, 2, 3])
+            ef = Field("entries", StructType(); nullable=false, children=[kf, vf])
+            ed = AC.ArrayData(
+                StructType(),
+                3,
+                [BufferSlice()];
+                children=[kd, vd],
+                nullcount=0,
+            )
+            offs = Int32[0, 2, 3]
+            t = MapType(false)
+            f = Field("m", t; children=[ef])
+            d = AC.ArrayData(
+                t,
+                2,
+                [BufferSlice(), AC._databuffer(offs)];
+                children=[ed],
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test materialize(f, d) == [["a" => 1, "b" => 2], ["c" => 3]]
+        end
+
+        @testset "map applies the entries struct offset" begin
+            kf, kd = fromjulia("key", ["skip", "a", "b"])
+            vf, vd = fromjulia("value", Int64[0, 1, 2])
+            ef = Field("entries", StructType(); nullable=false, children=[kf, vf])
+            ed = AC.ArrayData(
+                StructType(),
+                2,
+                [BufferSlice()];
+                offset=1,
+                children=[kd, vd],
+                nullcount=0,
+            )
+            t = MapType(false)
+            f = Field("m", t; children=[ef])
+            d = AC.ArrayData(
+                t,
+                1,
+                [BufferSlice(), AC._databuffer(Int32[0, 2])];
+                children=[ed],
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test materialize(f, d) == [["a" => 1, "b" => 2]]
+        end
+
+        @testset "empty large-list range does not wrap" begin
+            cf = Field("item", NullType())
+            cd = AC.ArrayData(NullType(), typemax(Int64), BufferSlice[])
+            t = ListType(true)
+            f = Field("list", t; children=[cf])
+            d = AC.ArrayData(
+                t,
+                1,
+                [BufferSlice(), AC._databuffer(Int64[typemax(Int64), typemax(Int64)])];
+                children=[cd],
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test getvalue(f, d, 1) == Any[]
+        end
+
+        @testset "dense union" begin
+            t = UnionType(AC.DenseMode, Int8[0, 1])
+            af, ad = fromjulia("i", Int64[10, 20])
+            bf, bd = fromjulia("s", ["x"])
+            f = Field("u", t; children=[af, bf])
+            typeids = Int8[0, 1, 0]
+            offsets = Int32[0, 0, 1]
+            d = AC.ArrayData(
+                t,
+                3,
+                [AC._databuffer(typeids), AC._databuffer(offsets)];
+                children=[ad, bd],
+            )
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test materialize(f, d) == [10, "x", 20]
+        end
+
+        @testset "sparse union" begin
+            t = UnionType(AC.SparseMode, Int8[0, 1])
+            af, ad = fromjulia("i", Int64[10, 20, 30])
+            bf, bd = fromjulia("s", ["x", "y", "z"])
+            f = Field("u", t; children=[af, bf])
+            d = AC.ArrayData(t, 3, [AC._databuffer(Int8[0, 1, 0])]; children=[ad, bd])
+            validate_structural(f, d)
+            @test materialize(f, d) == [10, "y", 30]
+        end
+
+        @testset "interval MONTH_DAY_NANO" begin
+            t = IntervalType(AC.MONTH_DAY_NANO)
+            raw = vcat(reinterpret(UInt8, Int32[1, 2]), reinterpret(UInt8, Int64[3]))
+            f = Field("iv", t; nullable=false)
+            d = AC.ArrayData(
+                t,
+                1,
+                [BufferSlice(), AC._databuffer(collect(raw))];
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            @test getvalue(f, d, 1) == (months=1, days=2, nanos=3)
+        end
+
+        @testset "decimal32/64 read at the right width" begin
+            for (bits, T) in ((32, Int32), (64, Int64))
+                t = DecimalType(9, 2, bits)
+                vals = T[12345, -678]
+                f = Field("dec", t; nullable=false)
+                d = AC.ArrayData(t, 2, [BufferSlice(), AC._databuffer(vals)]; nullcount=0)
+                validate_structural(f, d)
+                @test [getvalue(f, d, i) for i = 1:2] == vals
+            end
+        end
+
+        @testset "logical offset (sliced data)" begin
+            v = Int64[1, 2, 3, 4, 5]
+            t = IntType(64, true)
+            f = Field("x", t; nullable=false)
+            d = AC.ArrayData(
+                t,
+                3,
+                [BufferSlice(), AC._databuffer(v)];
+                offset=2,
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            @test materialize(f, d) == [3, 4, 5]
+        end
+
+        @testset "logical offset in struct and sparse union" begin
+            af, ad = fromjulia("a", Int64[10, 20, 30])
+            sf = Field("st", StructType(); children=[af])
+            sd = AC.ArrayData(
+                StructType(),
+                2,
+                [BufferSlice()];
+                offset=1,
+                children=[ad],
+                nullcount=0,
+            )
+            validate_structural(sf, sd)
+            @test materialize(sf, sd) == [["a" => 20], ["a" => 30]]
+
+            uf = Field(
+                "u",
+                UnionType(AC.SparseMode, Int8[0, 1]);
+                children=[af, fromjulia("b", ["x", "y", "z"])[1]],
+            )
+            bd = fromjulia("b", ["x", "y", "z"])[2]
+            ud = AC.ArrayData(
+                uf.type,
+                2,
+                [AC._databuffer(Int8[0, 1, 0])];
+                offset=1,
+                children=[ad, bd],
+                nullcount=0,
+            )
+            validate_structural(uf, ud)
+            validate_semantic(uf, ud)
+            @test materialize(uf, ud) == ["y", 30]
+        end
+
+        @testset "struct access preserves names that NamedTuple cannot represent" begin
+            af, ad = fromjulia("dup", Int64[1])
+            bf, bd = fromjulia("dup", Int64[2])
+            f = Field("s", StructType(); children=[af, bf])
+            d = AC.ArrayData(
+                StructType(),
+                1,
+                [BufferSlice()];
+                children=[ad, bd],
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test getvalue(f, d, 1) == ["dup" => 1, "dup" => 2]
+
+            unnamed = Field(
+                "s",
+                StructType();
+                children=[
+                    Field("", af.type; nullable=false),
+                    Field("", bf.type; nullable=false),
+                ],
+            )
+            validate_structural(unnamed, d)
+            validate_semantic(unnamed, d)
+            @test getvalue(unnamed, d, 1) == ["" => 1, "" => 2]
+
+            nulname = "embedded\0nul"
+            nulnamed =
+                Field("s", StructType(); children=[Field(nulname, af.type; nullable=false)])
+            nuld =
+                AC.ArrayData(StructType(), 1, [BufferSlice()]; children=[ad], nullcount=0)
+            validate_structural(nulnamed, nuld)
+            validate_semantic(nulnamed, nuld)
+            @test getvalue(nulnamed, nuld, 1) == [nulname => 1]
+        end
+
+        @testset "run-end encoding: validation, access, logical nulls, slicing" begin
+            t = RunEndEncodedType()
+            ref, red = fromjulia("run_ends", Int32[2, 3])
+            vf, vd = fromjulia("values", Int64[7, 9])
+            f = Field("ree", t; children=[ref, vf])
+            d = AC.ArrayData(t, 3, BufferSlice[]; children=[red, vd], nullcount=0)
+            validate_structural(f, d)
+            @test validate_semantic(f, d) === d
+            @test [getvalue(f, d, i) for i = 1:3] == [7, 7, 9]
+            @test materialize(f, d) == [7, 7, 9]
+            @test nullcount(d) == 0
+
+            # nulls are runs whose VALUE is null; the parent has no bitmap
+            nvf, nvd = fromjulia("values", Union{Missing,Int64}[missing, 4])
+            nf = Field("ree", t; children=[ref, nvf])
+            nd = AC.ArrayData(t, 3, BufferSlice[]; children=[red, nvd], nullcount=0)
+            @test validate_semantic(nf, nd) === nd
+            @test isequal(materialize(nf, nd), [missing, missing, 4])
+
+            # slicing shifts logical positions through the run search
+            sliced =
+                AC.ArrayData(t, 2, BufferSlice[]; offset=1, children=[red, vd], nullcount=0)
+            @test validate_semantic(f, sliced) === sliced
+            @test materialize(f, sliced) == [7, 9]
+            boundary =
+                AC.ArrayData(t, 1, BufferSlice[]; offset=2, children=[red, vd], nullcount=0)
+            @test validate_semantic(f, boundary) === boundary
+            @test materialize(f, boundary) == [9]
+
+            # adversarial: non-ascending, zero/negative, short coverage,
+            # unequal children, declared parent nulls
+            badruns(v) = AC.ArrayData(
+                t,
+                3,
+                BufferSlice[];
+                children=[fromjulia("run_ends", v)[2], vd],
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_semantic(f, badruns(Int32[3, 2]))
+            @test_throws ValidationError validate_semantic(f, badruns(Int32[0, 3]))
+            @test_throws ValidationError validate_semantic(f, badruns(Int32[2, 2]))
+            @test_throws ValidationError validate_semantic(f, badruns(Int32[1, 2]))
+            shortchild = AC.ArrayData(
+                t,
+                3,
+                BufferSlice[];
+                children=[red, fromjulia("values", Int64[7])[2]],
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_semantic(f, shortchild)
+            declared = AC.ArrayData(t, 3, BufferSlice[]; children=[red, nvd], nullcount=2)
+            @test_throws ValidationError validate_semantic(nf, declared)
+            # An UNKNOWN parent null count (-1, spec-legal for every layout, and
+            # what a C producer may hand us) is not a declared positive count:
+            # it validates and resolves to the bitmap-less physical zero.
+            unknown = AC.ArrayData(t, 3, BufferSlice[]; children=[red, nvd])
+            @test validate_semantic(nf, unknown) === unknown
+            @test nullcount(unknown) == 0
+            @test isequal(materialize(nf, unknown), [missing, missing, 4])
+        end
+
+        @testset "view layouts: entries, prefixes, variadic buffers" begin
+            # helper: build one 16-byte view entry (mirrors the batteries'
+            # `_viewentry`/`_viewlong`; this suite does not load those helpers)
+            entry(len::Int, rest::Vector{UInt8}) = vcat(
+                reinterpret(UInt8, Int32[Int32(len)]),
+                rest,
+                zeros(UInt8, 12 - length(rest)),
+            )
+            long(len, prefix, bufidx, off) = vcat(
+                reinterpret(UInt8, Int32[Int32(len)]),
+                prefix,
+                reinterpret(UInt8, Int32[Int32(bufidx), Int32(off)]),
+            )
+            vt = ViewType(true)
+            vf = Field("v", vt; nullable=true)
+            payload = collect(codeunits("hello-world-beyond-inline"))
+            views = vcat(
+                entry(5, collect(codeunits("hello"))),                # inline short
+                long(25, payload[1:4], 0, 0),                          # out-of-line
+                entry(12, collect(codeunits("exactly-12bb"))),
+            )         # inline max
+            vd = AC.ArrayData(
+                vt,
+                3,
+                [BufferSlice(), AC._databuffer(views), AC._databuffer(payload)];
+                nullcount=0,
+            )
+            @test validate_semantic(vf, vd) === vd
+            @test AC.validate_full(vf, vd) === vd
+            @test materialize(vf, vd) ==
+                  ["hello", "hello-world-beyond-inline", "exactly-12bb"]
+
+            # Length 12 is inline; length 13 is out-of-line. The parent offset
+            # selects the second physical 16-byte view entry.
+            payload13 = collect(codeunits("exactly-13-by"))
+            boundaryviews = vcat(
+                entry(12, collect(codeunits("exactly-12bb"))),
+                long(13, payload13[1:4], 0, 0),
+            )
+            slicedview = AC.ArrayData(
+                vt,
+                1,
+                [BufferSlice(), AC._databuffer(boundaryviews), AC._databuffer(payload13)];
+                offset=1,
+                nullcount=0,
+            )
+            @test validate_full(vf, slicedview) === slicedview
+            @test materialize(vf, slicedview) == ["exactly-13-by"]
+
+            # binary views return bytes
+            bt = ViewType(false)
+            bf = Field("b", bt)
+            bd = AC.ArrayData(
+                bt,
+                1,
+                [BufferSlice(), AC._databuffer(entry(2, UInt8[0xff, 0x00]))];
+                nullcount=0,
+            )
+            @test validate_semantic(bf, bd) === bd
+            @test getvalue(bf, bd, 1) == UInt8[0xff, 0x00]
+
+            # null slots' entry bytes are unrestricted by the spec
+            nulld = AC.ArrayData(
+                vt,
+                1,
+                [
+                    AC._databuffer(UInt8[0x00]),
+                    AC._databuffer(long(99, UInt8[1, 2, 3, 4], 7, -5)),
+                ];
+                nullcount=1,
+            )
+            @test validate_semantic(vf, nulld) === nulld
+            @test getvalue(vf, nulld, 1) === missing
+
+            # adversarial: bad prefix, escaping range, bad buffer index,
+            # negative length/offset
+            badprefix = AC.ArrayData(
+                vt,
+                1,
+                [
+                    BufferSlice(),
+                    AC._databuffer(long(25, UInt8[1, 2, 3, 4], 0, 0)),
+                    AC._databuffer(payload),
+                ];
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_semantic(vf, badprefix)
+            escaping = AC.ArrayData(
+                vt,
+                1,
+                [
+                    BufferSlice(),
+                    AC._databuffer(long(26, payload[1:4], 0, 4)),
+                    AC._databuffer(payload),
+                ];
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_semantic(vf, escaping)
+            badbuf = AC.ArrayData(
+                vt,
+                1,
+                [
+                    BufferSlice(),
+                    AC._databuffer(long(25, payload[1:4], 3, 0)),
+                    AC._databuffer(payload),
+                ];
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_semantic(vf, badbuf)
+            neglen = AC.ArrayData(
+                vt,
+                1,
+                [BufferSlice(), AC._databuffer(entry(-1, UInt8[]))];
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_semantic(vf, neglen)
+
+            # ListView invariants bind NULL slots too (spec rule)
+            cf, cd = fromjulia("item", Int64[1, 2, 3])
+            lvt = ListViewType(false)
+            lvf = Field("lv", lvt; nullable=true, children=[cf])
+            nullbad = AC.ArrayData(
+                lvt,
+                1,
+                [
+                    AC._databuffer(UInt8[0x00]),
+                    AC._databuffer(Int32[9]),
+                    AC._databuffer(Int32[9]),
+                ];
+                children=[cd],
+                nullcount=1,
+            )
+            @test_throws ValidationError validate_semantic(lvf, nullbad)
+            # overlapping, shared child ranges are legal
+            overlap = AC.ArrayData(
+                lvt,
+                2,
+                [BufferSlice(), AC._databuffer(Int32[0, 0]), AC._databuffer(Int32[3, 2])];
+                children=[cd],
+                nullcount=0,
+            )
+            @test validate_semantic(lvf, overlap) === overlap
+            @test materialize(lvf, overlap) == [[1, 2, 3], [1, 2]]
+            slicedlistview = AC.ArrayData(
+                lvt,
+                1,
+                [BufferSlice(), AC._databuffer(Int32[2, 0]), AC._databuffer(Int32[1, 2])];
+                offset=1,
+                children=[cd],
+                nullcount=0,
+            )
+            @test validate_semantic(lvf, slicedlistview) === slicedlistview
+            @test materialize(lvf, slicedlistview) == [[1, 2]]
+            # large list-view uses 64-bit offsets and sizes
+            llvt = ListViewType(true)
+            llvf = Field("llv", llvt; children=[cf])
+            llvd = AC.ArrayData(
+                llvt,
+                1,
+                [BufferSlice(), AC._databuffer(Int64[1]), AC._databuffer(Int64[2])];
+                children=[cd],
+                nullcount=0,
+            )
+            @test validate_semantic(llvf, llvd) === llvd
+            @test getvalue(llvf, llvd, 1) == [2, 3]
+        end
+
+        @testset "fromviewentries: DataString payloads → Utf8View, zero-copy" begin
+            # A local encoder of the DataStrings payload (Core cannot depend on
+            # the package), which IS an Arrow view entry: length | first 4 bytes,
+            # then bytes 5..12 (≤12) or (Int32 buffer index, Int32 0-based
+            # offset). Any 16-byte isbits type is accepted.
+            struct ViewEntry
+                a::UInt64
+                b::UInt64
+            end
+            function inlineentry(bytes::Vector{UInt8})
+                len = length(bytes)
+                a = UInt64(len % UInt32)
+                b = zero(UInt64)
+                for i = 1:min(len, 4)
+                    a |= UInt64(bytes[i]) << (32 + 8 * (i - 1))
+                end
+                for i = 5:len
+                    b |= UInt64(bytes[i]) << (8 * (i - 5))
+                end
+                return ViewEntry(a, b)
+            end
+            function viewentry(data::Vector{UInt8}, pos1::Int, len::Int, bufidx::Int)
+                a = UInt64(len % UInt32)
+                for i = 1:4
+                    a |= UInt64(data[pos1 + i - 1]) << (32 + 8 * (i - 1))
+                end
+                return ViewEntry(
+                    a,
+                    UInt64(bufidx % UInt32) | (UInt64((pos1 - 1) % UInt32) << 32),
+                )
+            end
+            nullentry() = ViewEntry(UInt64(0xffffffff), zero(UInt64))
+
+            # buf: a "CSV input" with fields at known positions; extra: one
+            # unescaped-at-parse-time long value.
+            buf = collect(
+                codeunits(
+                    "id,name\n1,\"\"\n2,abcd\n3,twelve-bytes\n4,thirteen-byte\n5,a much longer value here\n",
+                ),
+            )
+            long1 = findfirst(codeunits("thirteen-byte"), buf)
+            long2 = findfirst(codeunits("a much longer value here"), buf)
+            extra = collect(codeunits("she said \"hi\" and left"))
+            payloads = ViewEntry[
+                inlineentry(UInt8[]),                                    # ""  (len 0)
+                inlineentry(collect(codeunits("abcd"))),                 # len 4 (a only)
+                inlineentry(collect(codeunits("twelve-bytes"))),         # len 12 (inline max)
+                viewentry(buf, first(long1), 13, 0),                     # first long: buf
+                nullentry(),                                             # missing
+                viewentry(buf, first(long2), 24, 0),                     # long: buf
+                viewentry(extra, 1, length(extra), 1),                   # long: extra
+            ]
+            f, d = fromviewentries("s", payloads, buf, extra)
+            @test f.type == ViewType(true)
+            @test f.nullable
+            @test length(d) == 7
+            @test nullcount(d) == 1
+            @test validate_full(f, d) === d          # geometry, prefixes, UTF-8
+            @test isequal(
+                materialize(f, d),
+                [
+                    "",
+                    "abcd",
+                    "twelve-bytes",
+                    "thirteen-byte",
+                    missing,
+                    "a much longer value here",
+                    "she said \"hi\" and left",
+                ],
+            )
+            # ZERO-COPY: the views buffer IS the payload vector, and the data
+            # buffers are the caller's vectors — none of the three is copied
+            @test d.buffers[2].region.root === AC._storageroot(payloads)
+            @test d.buffers[3].region.root === AC._storageroot(buf)
+            @test d.buffers[4].region.root === AC._storageroot(extra)
+            # the null slot's entry bytes are left as they are (spec: unspecified)
+            @test AC.loadat(d.buffers[2], Int32, Int64(16 * 4)) == Int32(-1)
+
+            # the column crosses both adapters as an ordinary Utf8View
+            sch = Schema(Field[f])
+            b = AC.RecordBatch(sch, ArrayData[d], 7)
+            s = Arrow.readstream(Arrow.writestream(sch, AC.RecordBatch[b]))
+            @test isequal(
+                materialize(s.schema.fields[1], s.batches[1].columns[1]),
+                materialize(f, d),
+            )
+            sp, ap = Arrow.to_c_data(f, d)
+            f2, d2 = Arrow.from_c_data(sp, ap)
+            @test isequal(materialize(f2, d2), materialize(f, d))
+            Arrow.release!(d2.owner::Arrow.ForeignOwner)
+            Arrow._reap!()
+
+            # no nulls, empty extra: the empty bitmap and an empty second data
+            # buffer (buffer index 1 always means `extra`)
+            f0, d0 = fromviewentries("t", payloads[[2, 3]], buf, UInt8[]; nullable=false)
+            @test !f0.nullable
+            @test length(d0.buffers) == 4
+            @test AC.isempty_buffer(d0.buffers[1])
+            @test validate_full(f0, d0) === d0
+            @test materialize(f0, d0) == ["abcd", "twelve-bytes"]
+            # ... and it too crosses the C boundary (an empty variadic buffer)
+            sp0, ap0 = Arrow.to_c_data(f0, d0)
+            f0b, d0b = Arrow.from_c_data(sp0, ap0)
+            @test materialize(f0b, d0b) == ["abcd", "twelve-bytes"]
+            Arrow.release!(d0b.owner::Arrow.ForeignOwner)
+            Arrow._reap!()
+
+            # malformed long entries construct (a wrap makes no promises about
+            # content) and refuse where every builder's output does: validation
+            for bad in (
+                viewentry(extra, 1, length(extra), 1) => UInt8[],  # extra referenced but empty
+                ViewEntry(payloads[6].a, UInt64(0) | (UInt64(length(buf) - 3) << 32)) =>
+                    extra,   # escapes buf
+                ViewEntry(payloads[6].a, UInt64(7)) => extra,
+            )            # buffer index 7
+                fb, db = fromviewentries("t", [bad.first], buf, bad.second)
+                @test_throws ValidationError validate_semantic(fb, db)
+            end
+            # wrong payload width and non-isbits payloads are constructor errors
+            @test_throws ArgumentError fromviewentries("t", UInt64[1, 2], buf, extra)
+            @test_throws ArgumentError fromviewentries("t", Any[1], buf, extra)
+        end
+    end
+
+    @testset "staged validation rejects corrupt metadata" begin
+        @testset "structural: descriptor values and field shape must match" begin
+            f = Field("x", IntType(32, true))
+            d = AC.ArrayData(
+                IntType(64, true),
+                1,
+                [BufferSlice(), AC._databuffer(Int64[1])];
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_structural(f, d)
+            @test_throws ValidationError validate_structural(
+                Field("l", ListType(false)),
+                AC.ArrayData(
+                    ListType(false),
+                    1,
+                    [BufferSlice(), AC._databuffer(Int32[0, 0])];
+                    children=[fromjulia("item", Int64[])[2]],
+                    nullcount=0,
+                ),
+            )
+            badt = IntType(24, true)
+            @test_throws ValidationError validate_structural(
+                Field("bad", badt),
+                AC.ArrayData(
+                    badt,
+                    1,
+                    [BufferSlice(), AC._databuffer(UInt8[0, 0, 0])];
+                    nullcount=0,
+                ),
+            )
+
+            invalidname = String(UInt8[0xff])
+            namef, named = fromjulia(invalidname, Int64[1])
+            @test_throws ValidationError validate_structural(namef, named)
+
+            badutf8 = String(UInt8[0xff])
+            for metadata in (Dict(badutf8 => "v"), Dict("k" => badutf8))
+                binaryfield = Field("metadata", IntType(8, true); metadata=metadata)
+                binarydata = AC.ArrayData(
+                    binaryfield.type,
+                    0,
+                    [BufferSlice(), BufferSlice()];
+                    nullcount=0,
+                )
+                @test validate_structural(binaryfield, binarydata) === binarydata
+            end
+            badtimezone = TimestampType(AC.SECOND, badutf8)
+            @test_throws ValidationError validate_structural(
+                Field("timestamp", badtimezone),
+                AC.ArrayData(badtimezone, 0, [BufferSlice(), BufferSlice()]; nullcount=0),
+            )
+
+            badtimeunit = reinterpret(AC.TimeUnit, UInt8(0xff))
+            baddateunit = reinterpret(AC.DateUnit, UInt8(0xff))
+            badintervalunit = reinterpret(AC.IntervalUnit, UInt8(0xff))
+            badunionmode = reinterpret(AC.UnionMode, UInt8(0xff))
+            for t in (
+                DateType(baddateunit),
+                TimeType(badtimeunit, 64),
+                TimestampType(badtimeunit, nothing),
+                DurationType(badtimeunit),
+                IntervalType(badintervalunit),
+            )
+                spec = layoutspec(t)
+                d = AC.ArrayData(t, 0, [BufferSlice() for _ in spec.buffers]; nullcount=0)
+                @test_throws ValidationError validate_structural(Field("bad", t), d)
+            end
+
+            cf, cd = fromjulia("item", Int64[])
+            badunion = UnionType(badunionmode, Int8[0])
+            baduniondata = AC.ArrayData(
+                badunion,
+                0,
+                [BufferSlice(), BufferSlice()];
+                children=[cd],
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_structural(
+                Field("bad-union", badunion; children=[cf]),
+                baduniondata,
+            )
+
+            if Sys.WORD_SIZE > 32
+                for scale in (Int(typemin(Int32)) - 1, Int(typemax(Int32)) + 1)
+                    badscale = DecimalType(1, scale, 32)
+                    @test_throws ValidationError validate_structural(
+                        Field("decimal", badscale),
+                        AC.ArrayData(
+                            badscale,
+                            0,
+                            [BufferSlice(), BufferSlice()];
+                            nullcount=0,
+                        ),
+                    )
+                end
+
+                badwidth = FixedSizeBinaryType(Int(typemax(Int32)) + 1)
+                @test_throws ValidationError validate_structural(
+                    Field("fixed", badwidth),
+                    AC.ArrayData(badwidth, 0, [BufferSlice(), BufferSlice()]; nullcount=0),
+                )
+
+                cf, cd = fromjulia("item", Int64[])
+                badsize = FixedSizeListType(Int(typemax(Int32)) + 1)
+                @test_throws ValidationError validate_structural(
+                    Field("list", badsize; children=[cf]),
+                    AC.ArrayData(badsize, 0, [BufferSlice()]; children=[cd], nullcount=0),
+                )
+            end
+        end
+
+        @testset "structural: wrong buffer arity" begin
+            t = IntType(64, true)
+            f = Field("x", t)
+            d = AC.ArrayData(t, 3, [BufferSlice()])   # missing DATA buffer
+            @test_throws ValidationError validate_structural(f, d)
+            @test_throws ValidationError validate_semantic(f, d)
+            @test_throws ValidationError validate_full(f, d)
+            @test !(@atomic d.semachecked)
+
+            wrongf = Field("x", IntType(32, true))
+            good64 =
+                AC.ArrayData(t, 1, [BufferSlice(), AC._databuffer(Int64[1])]; nullcount=0)
+            @test_throws ValidationError validate_semantic(wrongf, good64)
+            @test_throws ValidationError validate_full(wrongf, good64)
+            @test !(@atomic good64.semachecked)
+        end
+
+        @testset "structural: short data buffer (checked arithmetic)" begin
+            t = IntType(64, true)
+            f = Field("x", t)
+            short = AC._databuffer(Int64[1])          # 8 bytes for len=3
+            d = AC.ArrayData(t, 3, [BufferSlice(), short])
+            @test_throws ValidationError validate_structural(f, d)
+        end
+
+        @testset "structural: short offsets buffer" begin
+            t = Utf8Type(false)
+            f = Field("s", t)
+            offs = AC._databuffer(Int32[0, 1])        # need len+1 = 4 entries
+            d = AC.ArrayData(t, 3, [BufferSlice(), offs, BufferSlice()])
+            @test_throws ValidationError validate_structural(f, d)
+        end
+
+        @testset "semantic: non-monotonic offsets" begin
+            t = Utf8Type(false)
+            f = Field("s", t)
+            offs = AC._databuffer(Int32[0, 2, 1, 3])
+            data = AC._databuffer(UInt8[0x61, 0x62, 0x63])
+            d = AC.ArrayData(t, 3, [BufferSlice(), offs, data])
+            validate_structural(f, d)
+            @test_throws ValidationError validate_semantic(f, d)
+        end
+
+        @testset "semantic: final offset beyond data extent" begin
+            t = Utf8Type(false)
+            f = Field("s", t)
+            offs = AC._databuffer(Int32[0, 1, 2, 99])
+            data = AC._databuffer(UInt8[0x61, 0x62, 0x63])
+            d = AC.ArrayData(t, 3, [BufferSlice(), offs, data])
+            validate_structural(f, d)
+            @test_throws ValidationError validate_semantic(f, d)
+        end
+
+        @testset "semantic: Date64 and Time values obey their domains" begin
+            # Temporal value domains (Date64 whole days, Time-of-day range) are
+            # ADVISORY: the semantic stage accepts anything the layout admits and
+            # the opt-in validate_full tier enforces the domain.
+            function checkvalues(t, values; valid=true)
+                f = Field("temporal", t; nullable=false)
+                d = AC.ArrayData(
+                    t,
+                    length(values),
+                    [BufferSlice(), AC._databuffer(values)];
+                    nullcount=0,
+                )
+                validate_structural(f, d)
+                @test validate_semantic(f, d) === d
+                if valid
+                    @test AC.validate_full(f, d) === d
+                else
+                    @test_throws ValidationError AC.validate_full(f, d)
+                end
+            end
+
+            checkvalues(DateType(AC.MILLISECOND_DATE), Int64[-86_400_000, 0, 86_400_000])
+            # Date64 whole-day divisibility is ADVISORY (the arrow-testing gold
+            # corpus itself violates it): semantic accepts, validate_full rejects.
+            let t = DateType(AC.MILLISECOND_DATE),
+                f = Field("temporal", t; nullable=false),
+                d = AC.ArrayData(
+                    t,
+                    1,
+                    [BufferSlice(), AC._databuffer(Int64[1])];
+                    nullcount=0,
+                )
+
+                @test validate_semantic(f, d) === d
+                @test_throws ValidationError AC.validate_full(f, d)
+            end
+            checkvalues(TimeType(AC.SECOND, 32), Int32[0, 86_399])
+            checkvalues(TimeType(AC.SECOND, 32), Int32[-1]; valid=false)
+            checkvalues(TimeType(AC.SECOND, 32), Int32[86_400]; valid=false)
+            checkvalues(TimeType(AC.MILLISECOND, 32), Int32[86_399_999])
+            checkvalues(TimeType(AC.MICROSECOND, 64), Int64[86_399_999_999])
+            checkvalues(TimeType(AC.NANOSECOND, 64), Int64[86_399_999_999_999])
+            checkvalues(TimeType(AC.NANOSECOND, 64), Int64[86_400_000_000_000]; valid=false)
+        end
+
+        @testset "semantic: decimal values fit declared precision" begin
+            # Decimal precision is ADVISORY (the arrow-testing gold corpus carries
+            # decimal(3,2) values with five digits): validate_semantic accepts any
+            # coefficient; validate_full enforces the declared digit count.
+            function checkdecimal(t, bytes; valid=true, bitmap=BufferSlice(), nullcount=0)
+                f = Field("decimal", t)
+                d = AC.ArrayData(
+                    t,
+                    length(bytes) ÷ (t.bits ÷ 8),
+                    [bitmap, AC._databuffer(bytes)];
+                    nullcount=nullcount,
+                )
+                @test validate_semantic(f, d) === d
+                if valid
+                    @test AC.validate_full(f, d) === d
+                else
+                    @test_throws ValidationError AC.validate_full(f, d)
+                end
+            end
+
+            for (bits, T) in ((32, Int32), (64, Int64), (128, Int128))
+                t = DecimalType(1, 0, bits)
+                checkdecimal(t, collect(reinterpret(UInt8, T[9, -9])))
+                checkdecimal(t, collect(reinterpret(UInt8, T[10])); valid=false)
+                checkdecimal(t, collect(reinterpret(UInt8, T[-10])); valid=false)
+            end
+
+            limit128 = Int128(10)^38
+            t128max = DecimalType(38, 0, 128)
+            checkdecimal(
+                t128max,
+                collect(reinterpret(UInt8, Int128[limit128 - 1, -limit128 + 1])),
+            )
+            checkdecimal(
+                t128max,
+                collect(reinterpret(UInt8, Int128[limit128]));
+                valid=false,
+            )
+            checkdecimal(
+                t128max,
+                collect(reinterpret(UInt8, Int128[-limit128]));
+                valid=false,
+            )
+
+            # Decimal256 values are represented here as four little-endian UInt64
+            # limbs. Cover positive/negative precision edges without a BigInt
+            # dependency in either Core or its tests.
+            t256 = DecimalType(1, 0, 256)
+            pos9 = UInt64[9, 0, 0, 0]
+            pos10 = UInt64[10, 0, 0, 0]
+            neg9 = UInt64[
+                typemax(UInt64) - 8,
+                typemax(UInt64),
+                typemax(UInt64),
+                typemax(UInt64),
+            ]
+            checkdecimal(t256, collect(reinterpret(UInt8, vcat(pos9, neg9))))
+            checkdecimal(t256, collect(reinterpret(UInt8, pos10)); valid=false)
+
+            # 10^76 spans all four limbs. These exact boundaries exercise carry
+            # propagation when the precision limit is built.
+            limit76 = UInt64[
+                0x0000000000000000,
+                0x7775a5f171951000,
+                0x0764b4abe8652979,
+                0x161bcca7119915b5,
+            ]
+            below76 = UInt64[
+                0xffffffffffffffff,
+                0x7775a5f171950fff,
+                0x0764b4abe8652979,
+                0x161bcca7119915b5,
+            ]
+            t256max = DecimalType(76, 0, 256)
+            checkdecimal(t256max, collect(reinterpret(UInt8, below76)))
+            checkdecimal(t256max, collect(reinterpret(UInt8, limit76)); valid=false)
+
+            # Invalid bytes in a null slot are masked and do not violate the
+            # precision contract.
+            checkdecimal(
+                DecimalType(1, 0, 32),
+                collect(reinterpret(UInt8, Int32[10]));
+                bitmap=AC._databuffer(UInt8[0x00]),
+                nullcount=1,
+            )
+        end
+
+        @testset "semantic: dictionary index out of bounds" begin
+            f, d = AC.fromjulia_dict("d", ["a", "b"], [0, 1])
+            # corrupt: poke an index past the pool through a rebuilt ArrayData
+            bad = AC.ArrayData(
+                d.type,
+                d.len,
+                [d.buffers[1], AC._databuffer(Int32[0, 7])];
+                dictionary=d.dictionary,
+            )
+            @test_throws ValidationError validate_semantic(f, bad)
+        end
+
+        @testset "semantic: union type id outside declared domain" begin
+            t = UnionType(AC.SparseMode, Int8[0, 1])
+            af, ad = fromjulia("i", Int64[1, 2])
+            bf, bd = fromjulia("s", ["x", "y"])
+            f = Field("u", t; children=[af, bf])
+            d = AC.ArrayData(t, 2, [AC._databuffer(Int8[0, 5])]; children=[ad, bd])
+            validate_structural(f, d)
+            @test_throws ValidationError validate_semantic(f, d)
+        end
+
+        @testset "union ids and dense offsets obey the format" begin
+            af, ad = fromjulia("i", Int64[1, 2])
+            bf, bd = fromjulia("j", Int64[3, 4])
+            dupt = UnionType(AC.SparseMode, Int8[0, 0])
+            @test_throws ValidationError validate_structural(
+                Field("u", dupt; children=[af, bf]),
+                AC.ArrayData(
+                    dupt,
+                    2,
+                    [AC._databuffer(Int8[0, 0])];
+                    children=[ad, bd],
+                    nullcount=0,
+                ),
+            )
+
+            negt = UnionType(AC.SparseMode, Int8[-1, 0])
+            @test_throws ValidationError validate_structural(
+                Field("u", negt; children=[af, bf]),
+                AC.ArrayData(
+                    negt,
+                    2,
+                    [AC._databuffer(Int8[-1, 0])];
+                    children=[ad, bd],
+                    nullcount=0,
+                ),
+            )
+
+            shortt = UnionType(AC.SparseMode, Int8[0])
+            @test_throws ValidationError validate_structural(
+                Field("u", shortt; children=[af, bf]),
+                AC.ArrayData(
+                    shortt,
+                    2,
+                    [AC._databuffer(Int8[0, 0])];
+                    children=[ad, bd],
+                    nullcount=0,
+                ),
+            )
+
+            t = UnionType(AC.DenseMode, Int8[0])
+            f = Field("u", t; children=[af])
+            d = AC.ArrayData(
+                t,
+                2,
+                [AC._databuffer(Int8[0, 0]), AC._databuffer(Int32[1, 0])];
+                children=[ad],
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            @test_throws ValidationError validate_semantic(f, d)
+
+            # Equal dense offsets are valid; only decreases are forbidden.
+            repeated = AC.ArrayData(
+                t,
+                2,
+                [AC._databuffer(Int8[0, 0]), AC._databuffer(Int32[0, 0])];
+                children=[ad],
+                nullcount=0,
+            )
+            validate_structural(f, repeated)
+            @test validate_semantic(f, repeated) === repeated
+        end
+
+        @testset "structural: nested REE values are supported" begin
+            irf, ird = fromjulia("run_ends", Int32[1, 2])
+            ivf, ivd = fromjulia("values", Int64[10, 20])
+            innerf = Field("values", RunEndEncodedType(); children=[irf, ivf])
+            innerd = AC.ArrayData(
+                RunEndEncodedType(),
+                2,
+                BufferSlice[];
+                children=[ird, ivd],
+                nullcount=0,
+            )
+            orf, ord = fromjulia("run_ends", Int32[2, 4])
+            outerf = Field("ree", RunEndEncodedType(); children=[orf, innerf])
+            outerd = AC.ArrayData(
+                RunEndEncodedType(),
+                4,
+                BufferSlice[];
+                children=[ord, innerd],
+                nullcount=0,
+            )
+            @test validate_full(outerf, outerd) === outerd
+            @test getvalue(outerf, outerd, 3) == 20
+            @test materialize(outerf, outerd) == [10, 10, 20, 20]
+        end
+
+        @testset "structural: REE geometry must be representable" begin
+            erf, erd = fromjulia("run_ends", Int16[])
+            evf, evd = fromjulia("values", Int64[])
+            t = RunEndEncodedType()
+            f = Field("ree", t; children=[erf, evf])
+            emptyslice = AC.ArrayData(
+                t,
+                0,
+                BufferSlice[];
+                offset=5,
+                children=[erd, evd],
+                nullcount=0,
+            )
+            @test validate_full(f, emptyslice) === emptyslice
+            emptyphysical =
+                AC.ArrayData(t, 1, BufferSlice[]; children=[erd, evd], nullcount=0)
+            @test_throws ValidationError validate_structural(f, emptyphysical)
+
+            rf, rd = fromjulia("run_ends", Int16[typemax(Int16)])
+            vf, vd = fromjulia("values", Int64[1])
+            f = Field("ree", t; children=[rf, vf])
+            overflow = AC.ArrayData(
+                t,
+                Int64(typemax(Int16)) + 1,
+                BufferSlice[];
+                children=[rd, vd],
+                nullcount=0,
+            )
+            @test_throws ValidationError validate_structural(f, overflow)
+
+            badnulls = AC.ArrayData(t, 1, BufferSlice[]; children=[rd, vd], nullcount=1)
+            @test_throws ValidationError validate_structural(f, badnulls)
+        end
+
+        @testset "semantic: declared null count matches bitmap" begin
+            f, d = fromjulia("x", [1, missing])
+            bad = AC.ArrayData(d.type, d.len, d.buffers; nullcount=0)
+            validate_structural(f, bad)
+            @test_throws ValidationError validate_semantic(f, bad)
+            absent = AC.ArrayData(d.type, d.len, [BufferSlice(), d.buffers[2]]; nullcount=1)
+            @test_throws ValidationError validate_structural(f, absent)
+            @test_throws ArgumentError AC.ArrayData(d.type, d.len, d.buffers; nullcount=3)
+        end
+
+        @testset "field nullability is checked outside the data cache" begin
+            nullable, d = fromjulia("x", [1, missing])
+            validate_semantic(nullable, d)
+            @test (@atomic d.semachecked)
+            # `nullable` is ADVISORY (the arrow-testing gold corpus has
+            # non-nullable fields holding nulls, and C++ reads them): the semantic
+            # stage accepts and the cached certificate is not poisoned by the
+            # Field; the opt-in validate_full tier enforces the declaration.
+            nonnullable = Field("x", d.type; nullable=false)
+            @test validate_semantic(nonnullable, d) === d
+            @test_throws ValidationError AC.validate_full(nonnullable, d)
+
+            af, ad = fromjulia("a", Union{Missing,Int64}[missing])
+            uf = Field("u", UnionType(AC.DenseMode, Int8[0]); nullable=false, children=[af])
+            ud = AC.ArrayData(
+                uf.type,
+                1,
+                [AC._databuffer(Int8[0]), AC._databuffer(Int32[0])];
+                children=[ad],
+                nullcount=0,
+            )
+            validate_structural(uf, ud)
+            @test validate_semantic(uf, ud) === ud
+            @test_throws ValidationError AC.validate_full(uf, ud)
+        end
+
+        # These pin the MASKING rules of the nullability walk (a null parent hides
+        # non-nullable child slots), which runs in the validate_full tier.
+        @testset "parent nulls mask hidden non-nullable child slots" begin
+            cf = Field("x", IntType(64, true); nullable=false)
+            cd = AC.ArrayData(
+                cf.type,
+                2,
+                [AC._databuffer(UInt8[0x00]), AC._databuffer(Int64[0, 0])];
+                nullcount=2,
+            )
+
+            sf = Field("s", StructType(); children=[cf])
+            masked_struct = AC.ArrayData(
+                StructType(),
+                1,
+                [AC._databuffer(UInt8[0x00])];
+                children=[cd],
+                nullcount=1,
+            )
+            @test AC.validate_full(sf, masked_struct) === masked_struct
+            visible_struct =
+                AC.ArrayData(StructType(), 1, [BufferSlice()]; children=[cd], nullcount=0)
+            @test_throws ValidationError AC.validate_full(sf, visible_struct)
+
+            flt = FixedSizeListType(2)
+            flf = Field("fixed", flt; children=[cf])
+            masked_fixed = AC.ArrayData(
+                flt,
+                1,
+                [AC._databuffer(UInt8[0x00])];
+                children=[cd],
+                nullcount=1,
+            )
+            @test AC.validate_full(flf, masked_fixed) === masked_fixed
+            visible_fixed =
+                AC.ArrayData(flt, 1, [BufferSlice()]; children=[cd], nullcount=0)
+            @test_throws ValidationError AC.validate_full(flf, visible_fixed)
+
+            lt = ListType(false)
+            lf = Field("list", lt; children=[cf])
+            offsets = AC._databuffer(Int32[0, 1])
+            masked_list = AC.ArrayData(
+                lt,
+                1,
+                [AC._databuffer(UInt8[0x00]), offsets];
+                children=[cd],
+                nullcount=1,
+            )
+            @test AC.validate_full(lf, masked_list) === masked_list
+            visible_list =
+                AC.ArrayData(lt, 1, [BufferSlice(), offsets]; children=[cd], nullcount=0)
+            @test_throws ValidationError AC.validate_full(lf, visible_list)
+
+            lvt = ListViewType(false)
+            lvf = Field("listview", lvt; children=[cf])
+            lvoffsets = AC._databuffer(Int32[0])
+            lvsizes = AC._databuffer(Int32[1])
+            masked_listview = AC.ArrayData(
+                lvt,
+                1,
+                [AC._databuffer(UInt8[0x00]), lvoffsets, lvsizes];
+                children=[cd],
+                nullcount=1,
+            )
+            @test AC.validate_full(lvf, masked_listview) === masked_listview
+            visible_listview = AC.ArrayData(
+                lvt,
+                1,
+                [BufferSlice(), lvoffsets, lvsizes];
+                children=[cd],
+                nullcount=0,
+            )
+            @test_throws ValidationError AC.validate_full(lvf, visible_listview)
+            empty_at_end = AC.ArrayData(
+                lvt,
+                1,
+                [BufferSlice(), AC._databuffer(Int32[2]), AC._databuffer(Int32[0])];
+                children=[cd],
+                nullcount=0,
+            )
+            @test AC.validate_full(lvf, empty_at_end) === empty_at_end
+
+            keyfield = Field("key", IntType(64, true); nullable=false)
+            keydata = AC.ArrayData(
+                keyfield.type,
+                1,
+                [AC._databuffer(UInt8[0x00]), AC._databuffer(Int64[0])];
+                nullcount=1,
+            )
+            valuefield, valuedata = fromjulia("value", Int64[1])
+            entriesfield = Field(
+                "entries",
+                StructType();
+                nullable=false,
+                children=[keyfield, valuefield],
+            )
+            entriesdata = AC.ArrayData(
+                StructType(),
+                1,
+                [BufferSlice()];
+                children=[keydata, valuedata],
+                nullcount=0,
+            )
+            mt = MapType(false)
+            mf = Field("map", mt; children=[entriesfield])
+            masked_map = AC.ArrayData(
+                mt,
+                1,
+                [AC._databuffer(UInt8[0x00]), offsets];
+                children=[entriesdata],
+                nullcount=1,
+            )
+            @test AC.validate_full(mf, masked_map) === masked_map
+            visible_map = AC.ArrayData(
+                mt,
+                1,
+                [BufferSlice(), offsets];
+                children=[entriesdata],
+                nullcount=0,
+            )
+            @test_throws ValidationError AC.validate_full(mf, visible_map)
+        end
+
+        # Nullability lives in the validate_full tier; these pin that only the
+        # SELECTED union child slot is inspected.
+        @testset "union contracts inspect only selected child slots" begin
+            af, ad = fromjulia("a", Int64[1])
+            bf = Field("b", IntType(64, true); nullable=false)
+            bd = AC.ArrayData(
+                bf.type,
+                1,
+                [AC._databuffer(UInt8[0x00]), AC._databuffer(Int64[0])];
+                nullcount=1,
+            )
+            t = UnionType(AC.DenseMode, Int8[0, 1])
+            f = Field("u", t; children=[af, bf])
+            selected_valid = AC.ArrayData(
+                t,
+                1,
+                [AC._databuffer(Int8[0]), AC._databuffer(Int32[0])];
+                children=[ad, bd],
+                nullcount=0,
+            )
+            @test AC.validate_full(f, selected_valid) === selected_valid
+
+            selected_null = AC.ArrayData(
+                t,
+                1,
+                [AC._databuffer(Int8[1]), AC._databuffer(Int32[0])];
+                children=[ad, bd],
+                nullcount=0,
+            )
+            @test_throws ValidationError AC.validate_full(f, selected_null)
+
+            # Sparse selection applies the parent offset, but still ignores every
+            # unselected child's storage at that logical position.
+            saf, sad = fromjulia("a", Int64[1, 2])
+            sbf = Field("b", IntType(64, true); nullable=false)
+            sbd = AC.ArrayData(
+                sbf.type,
+                2,
+                [AC._databuffer(UInt8[0x00]), AC._databuffer(Int64[0, 0])];
+                nullcount=2,
+            )
+            st = UnionType(AC.SparseMode, Int8[0, 1])
+            sf = Field("u", st; children=[saf, sbf])
+            sparse_valid = AC.ArrayData(
+                st,
+                1,
+                [AC._databuffer(Int8[1, 0])];
+                offset=1,
+                children=[sad, sbd],
+                nullcount=0,
+            )
+            @test AC.validate_full(sf, sparse_valid) === sparse_valid
+            sparse_null = AC.ArrayData(
+                st,
+                1,
+                [AC._databuffer(Int8[0, 1])];
+                offset=1,
+                children=[sad, sbd],
+                nullcount=0,
+            )
+            @test_throws ValidationError AC.validate_full(sf, sparse_null)
+        end
+
+        @testset "nested dictionary pools retain field contracts" begin
+            valuefield = Field("x", IntType(64, true); nullable=false)
+            nullvalue = AC.ArrayData(
+                valuefield.type,
+                1,
+                [AC._databuffer(UInt8[0x00]), AC._databuffer(Int64[0])];
+                nullcount=1,
+            )
+            valuetype = StructType()
+            pool = AC.ArrayData(
+                valuetype,
+                1,
+                [BufferSlice()];
+                children=[nullvalue],
+                nullcount=0,
+            )
+            dicttype = DictionaryType(IntType(32, true), valuetype, false)
+            dictfield = Field("dict", dicttype; children=[valuefield])
+            dictdata = AC.ArrayData(
+                dicttype,
+                1,
+                [BufferSlice(), AC._databuffer(Int32[0])];
+                dictionary=pool,
+                nullcount=0,
+            )
+            outerfield = Field("outer", StructType(); children=[dictfield])
+            outerdata = AC.ArrayData(
+                StructType(),
+                1,
+                [BufferSlice()];
+                children=[dictdata],
+                nullcount=0,
+            )
+            @test_throws ValidationError AC.validate_full(outerfield, outerdata)
+
+            maskedpool = AC.ArrayData(
+                valuetype,
+                1,
+                [AC._databuffer(UInt8[0x00])];
+                children=[nullvalue],
+                nullcount=1,
+            )
+            maskeddict = AC.ArrayData(
+                dicttype,
+                1,
+                [BufferSlice(), AC._databuffer(Int32[0])];
+                dictionary=maskedpool,
+                nullcount=0,
+            )
+            maskedouter = AC.ArrayData(
+                StructType(),
+                1,
+                [BufferSlice()];
+                children=[maskeddict],
+                nullcount=0,
+            )
+            @test AC.validate_full(outerfield, maskedouter) === maskedouter
+        end
+
+        @testset "full: invalid UTF-8" begin
+            t = Utf8Type(false)
+            f = Field("s", t)
+            offs = AC._databuffer(Int32[0, 2])
+            data = AC._databuffer(UInt8[0xff, 0xfe])
+            d = AC.ArrayData(t, 1, [BufferSlice(), offs, data])
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test_throws ValidationError validate_full(f, d)
+        end
+
+        @testset "full: invalid UTF-8 in dictionary values" begin
+            vt = Utf8Type(false)
+            vd = AC.ArrayData(
+                vt,
+                1,
+                [BufferSlice(), AC._databuffer(Int32[0, 1]), AC._databuffer(UInt8[0xff])];
+                nullcount=0,
+            )
+            t = DictionaryType(IntType(32, true), vt, false)
+            f = Field("d", t; nullable=false)
+            d = AC.ArrayData(
+                t,
+                1,
+                [BufferSlice(), AC._databuffer(Int32[0])];
+                dictionary=vd,
+                nullcount=0,
+            )
+            validate_structural(f, d)
+            validate_semantic(f, d)
+            @test_throws ValidationError validate_full(f, d)
+        end
+
+        @testset "semantic result is cached" begin
+            f, d = fromjulia("s", ["a", "b"])
+            @test !(@atomic d.semachecked)
+            validate_semantic(f, d)
+            @test (@atomic d.semachecked)
+            # The data-intrinsic scan is cached; Field contracts still run.
+            validate_semantic(f, d)
+            @test (@atomic d.semachecked)
+        end
+    end
+
+    @testset "nullcount is lazy and cached" begin
+        f, d = fromjulia("x", [1, missing, missing, 4])
+        @test (@atomic d.nullcount) == 2   # builder knew it
+        d2 = AC.ArrayData(d.type, d.len, d.buffers)  # unknown (-1)
+        @test (@atomic d2.nullcount) == -1
+        @test nullcount(d2) == 2
+        @test (@atomic d2.nullcount) == 2
+    end
+
+    @testset "bitmap scans honor slice offsets and lengths" begin
+        # Null counts and nullable bulk reads walk the validity bitmap a byte
+        # at a time; every start bit and length must agree with per-element
+        # validity, and a bitmap too short for the slice must refuse.
+        vals = [i % 3 == 0 ? missing : Int64(i) for i = 1:40]
+        f, d = fromjulia("x", vals)
+        for off = 0:9, len = 0:(40 - off)
+            s = AC.ArrayData(d.type, len, d.buffers; offset=off)
+            want = vals[(off + 1):(off + len)]
+            @test nullcount(s) == count(ismissing, want)
+            @test isequal(materialize(Union{Missing,Int64}, f, s), want)
+        end
+        short = AC.ArrayData(d.type, 40, [AC.subslice(d.buffers[1], 0, 4), d.buffers[2]])
+        @test_throws BoundsError nullcount(short)
+        @test_throws BoundsError materialize(Union{Missing,Int64}, f, short)
+        # A claim without Missing refuses a slice holding a null (slot 2)
+        # and accepts one whose bits are all set.
+        @test_throws ArgumentError materialize(
+            Int64,
+            f,
+            AC.ArrayData(d.type, 2, d.buffers; offset=1),
+        )
+        @test materialize(Int64, f, AC.ArrayData(d.type, 2, d.buffers; offset=3)) == [4, 5]
+    end
+
+    @testset "RecordBatch" begin
+        b = batch((a=Int64[1, 2, 3], b=["x", "y", "z"]))
+        @test b.nrows == 3
+        @test length(b.schema.fields) == 2
+        @test materialize(b.schema.fields[1], b.columns[1]) == [1, 2, 3]
+        @test_throws ArgumentError RecordBatch(
+            b.schema,
+            [b.columns[1], AC.fromjulia("b", ["only-one"])[2]],
+        )
+        wrongtype = AC.fromjulia("a", Float64[1, 2, 3])[2]
+        @test_throws ValidationError RecordBatch(Schema([b.schema.fields[1]]), [wrongtype])
+        missingdata = AC.ArrayData(IntType(64, true), 3, BufferSlice[])
+        @test_throws ValidationError RecordBatch(
+            Schema([b.schema.fields[1]]),
+            [missingdata],
+        )
+        empty_schema = Schema(Field[])
+        @test RecordBatch(empty_schema, ArrayData[], 7).nrows == 7
+        badutf8 = String(UInt8[0xff])
+        for metadata in (Dict(badutf8 => "v"), Dict("k" => badutf8))
+            binaryschema = Schema(Field[]; metadata=metadata)
+            @test RecordBatch(binaryschema, ArrayData[], 0).schema === binaryschema
+        end
+        badendian = reinterpret(AC.Endianness, UInt8(0xff))
+        @test_throws ValidationError RecordBatch(
+            Schema(Field[]; endianness=badendian),
+            ArrayData[],
+            0,
+        )
+        nonnative =
+            AC._native_endianness() == AC.LittleEndian ? AC.BigEndian : AC.LittleEndian
+        @test_throws ValidationError RecordBatch(
+            Schema(Field[]; endianness=nonnative),
+            ArrayData[],
+            0,
+        )
+
+        @testset "certified dictionary pools are not revisited" begin
+            # The descriptor set is closed (the layout-registry ladder), so the
+            # revisit observable is the pool's own semantic-cache bit: clear it
+            # after certification — a revisit would run the semantic stage and
+            # set it back; a honored certificate leaves it untouched.
+            valuefield, pool = fromjulia("pool", ["x"])
+            validate_semantic(valuefield, pool)
+            validated = AC._ValidatedDictionaries(pool => nothing)
+            @atomic :monotonic pool.semachecked = false
+
+            dicttype = DictionaryType(IntType(8, false), valuefield.type, false)
+            dictfield = Field("d", dicttype; nullable=false)
+            dictdata = AC.ArrayData(
+                dicttype,
+                1,
+                [BufferSlice(), AC._databuffer(UInt8[0])];
+                dictionary=pool,
+                nullcount=0,
+            )
+            @test AC._validate_semantic(dictfield, dictdata, validated) === dictdata
+            @test !(@atomic :monotonic pool.semachecked)
+
+            batch = AC.RecordBatch(Schema([dictfield]), [dictdata], 1, validated)
+            @test batch.columns[1] === dictdata
+            @test !(@atomic :monotonic pool.semachecked)
+        end
+    end
+
+    @testset "typed element access (static schemas)" begin
+        f, d = fromjulia("x", Int64[1, 2, 3])
+        @test getvalue(Int64, f, d, 2) === Int64(2)
+        @test materialize(Int64, f, d) == Int64[1, 2, 3]
+        @test materialize(Int64, f, d) isa Vector{Int64}
+        @test getvalue(Any, f, d, 1) === Int64(1)   # dynamic delegation
+        @test_throws BoundsError getvalue(Int64, f, d, 4)
+        # exact-match discipline: no conversion, no widening
+        @test_throws ArgumentError getvalue(Int32, f, d, 1)
+        @test_throws ArgumentError getvalue(Integer, f, d, 1)
+        fm, dm = fromjulia("y", [1.5, missing])
+        @test getvalue(Union{Missing,Float64}, fm, dm, 2) === missing
+        @test isequal(materialize(Union{Missing,Float64}, fm, dm), [1.5, missing])
+        @test_throws ArgumentError getvalue(Float64, fm, dm, 2)
+        fs, ds = fromjulia("s", ["a", missing])
+        @test getvalue(Union{Missing,String}, fs, ds, 1) == "a"
+        fb, db = fromjulia("b", [true, false])
+        @test materialize(Bool, fb, db) == [true, false]
+        # A plain Vector{Bool} is packed directly and remains non-nullable.
+        @test !fb.nullable
+        @test nullcount(db) == 0
+        @test fromjulia("bm", [true, missing])[1].nullable
+
+        packedlen = 1_000_000
+        packedbytes = cld(packedlen, 8)
+        plainbools = Bool[isodd(i) for i = 1:packedlen]
+        nullablebools =
+            Union{Missing,Bool}[i == packedlen ? missing : isodd(i) for i = 1:packedlen]
+        _build_bool_probe(plainbools)
+        _build_bool_probe(nullablebools)
+        GC.gc()
+        plainallocation = _allocated(_build_bool_probe, plainbools)
+        GC.gc()
+        nullableallocation = _allocated(_build_bool_probe, nullablebools)
+        @test plainallocation <= packedbytes + 256 * 1024
+        @test nullableallocation <= 2 * packedbytes + 256 * 1024
+        _, plainbooldata = _build_bool_probe(plainbools)
+        _, nullablebooldata = _build_bool_probe(nullablebools)
+        @test plainbooldata.buffers[1].len == 0
+        @test plainbooldata.buffers[2].len == packedbytes
+        @test nullablebooldata.buffers[1].len == packedbytes
+        @test nullablebooldata.buffers[2].len == packedbytes
+        # lists recurse the claim
+        fl, dl = fromjulia("l", [Int64[1, 2], Int64[]])
+        @test getvalue(Vector{Int64}, fl, dl, 1) == [1, 2]
+        @test materialize(Vector{Int64}, fl, dl) isa Vector{Vector{Int64}}
+        @test_throws ArgumentError getvalue(Vector{Float64}, fl, dl, 1)
+        fn, dn = fromjulia("ln", [[1.5, missing], missing])
+        @test isequal(
+            getvalue(Union{Missing,Vector{Union{Missing,Float64}}}, fn, dn, 1),
+            [1.5, missing],
+        )
+        @test getvalue(Union{Missing,Vector{Union{Missing,Float64}}}, fn, dn, 2) === missing
+        # structs: Vector{Pair} row or a NamedTuple claim (names must match)
+        saf, sad = fromjulia("a", Int64[7, 8])
+        sbf, sbd = fromjulia("b", ["x", "y"])
+        sf = Field("st", StructType(); nullable=false, children=[saf, sbf])
+        sd =
+            AC.ArrayData(StructType(), 2, [BufferSlice()]; children=[sad, sbd], nullcount=0)
+        NT = NamedTuple{(:a, :b),Tuple{Int64,String}}
+        @test getvalue(NT, sf, sd, 2) === (a=Int64(8), b="y")
+        @test materialize(NT, sf, sd) isa Vector{NT}
+        @test getvalue(Vector{Pair{String,Any}}, sf, sd, 1) == ["a" => 7, "b" => "x"]
+        WRONGNAME = NamedTuple{(:a, :c),Tuple{Int64,String}}
+        @test_throws ArgumentError getvalue(WRONGNAME, sf, sd, 1)
+        WRONGTYPE = NamedTuple{(:a, :b),Tuple{Int32,String}}
+        @test_throws ArgumentError getvalue(WRONGTYPE, sf, sd, 1)
+        # dictionary reads recurse into the pool
+        df, dd = AC.fromjulia_dict("d", ["lo", "hi"], [0, 1, missing])
+        @test getvalue(Union{Missing,String}, df, dd, 2) == "hi"
+        @test getvalue(Union{Missing,String}, df, dd, 3) === missing
+        # typed == dynamic on every covered layout
+        for (ff, cc, T) in (
+            (f, d, Int64),
+            (fm, dm, Union{Missing,Float64}),
+            (fs, ds, Union{Missing,String}),
+            (fl, dl, Vector{Int64}),
+            (df, dd, Union{Missing,String}),
+        )
+            @test isequal(materialize(T, ff, cc), materialize(ff, cc))
+        end
+        # The claim checks against the DESCRIPTOR: empty or all-null data
+        # certifies nothing.
+        fe, de = fromjulia("e", Int64[])
+        @test_throws ArgumentError materialize(String, fe, de)
+        @test materialize(Int64, fe, de) == Int64[]
+        fan, dan = fromjulia("an", Union{Missing,Int64}[missing, missing])
+        @test_throws ArgumentError materialize(Union{Missing,String}, fan, dan)
+        fel, del = fromjulia("el", Vector{Int32}[])
+        @test_throws ArgumentError materialize(Vector{Int64}, fel, del)
+        @test materialize(Vector{Int32}, fel, del) == Vector{Int32}[]
+        # Four heterogeneous NamedTuple fields (the compile-time-unrolled
+        # struct row; ntuple closures lose per-field types at this arity).
+        h1 = fromjulia("a", Int64[1, 2])
+        h2 = fromjulia("b", [1.5, 2.5])
+        h3 = fromjulia("c", ["x", "y"])
+        h4 = fromjulia("d", [true, false])
+        hf =
+            Field("st", StructType(); nullable=false, children=[h1[1], h2[1], h3[1], h4[1]])
+        hd = AC.ArrayData(
+            StructType(),
+            2,
+            [BufferSlice()];
+            children=[h1[2], h2[2], h3[2], h4[2]],
+            nullcount=0,
+        )
+        NT4 = NamedTuple{(:a, :b, :c, :d),Tuple{Int64,Float64,String,Bool}}
+        @test getvalue(NT4, hf, hd, 2) === (a=Int64(2), b=2.5, c="y", d=false)
+        @test materialize(NT4, hf, hd) isa Vector{NT4}
+        # A null struct never certifies a wrong claim either.
+        WRONG4 = NamedTuple{(:a, :b, :c, :z),Tuple{Int64,Float64,String,Bool}}
+        @test_throws ArgumentError getvalue(WRONG4, hf, hd, 1)
+        # Typed recursion keeps the dynamic path's child LOGICAL bounds: a
+        # hidden physical value past a child's logical length is unreadable.
+        leafd = AC.ArrayData(
+            IntType(64, true),
+            1,
+            [BufferSlice(), AC._databuffer(Int64[11, 22])],
+        )
+        listd = AC.ArrayData(
+            ListType(false),
+            1,
+            [BufferSlice(), AC._databuffer(Int32[0, 2])];
+            children=[leafd],
+        )
+        lfb = Field(
+            "l",
+            ListType(false);
+            nullable=false,
+            children=[Field("item", IntType(64, true); nullable=false)],
+        )
+        @test_throws BoundsError getvalue(Vector{Int64}, lfb, listd, 1)
+        @test_throws BoundsError getvalue(lfb, listd, 1)   # dynamic parity
+        # Non-exact NamedTuple shapes (Unions, UnionAlls) refuse with the
+        # documented ArgumentError, never a generation-time MethodError.
+        UNT = Union{
+            NamedTuple{(:a, :b),Tuple{Int64,Int64}},
+            NamedTuple{(:a, :b),Tuple{Int64,String}},
+        }
+        @test_throws ArgumentError getvalue(UNT, hf, hd, 1)
+        @test_throws ArgumentError materialize(UNT, hf, hd)
+        # Bulk extraction trusts the BITMAP, never a caller-supplied
+        # null-count cache (the typed path serves unvalidated data).
+        bmp = AC._bitmapbuffer([true, false, true])
+        hd = AC.ArrayData(
+            IntType(64, true),
+            3,
+            [bmp, AC._databuffer(Int64[10, 20, 30])];
+            nullcount=0,
+        )
+        hfb = Field("h", IntType(64, true); nullable=true)
+        @test isequal(materialize(Union{Missing,Int64}, hfb, hd), [10, missing, 30])
+        @test_throws ArgumentError materialize(Int64, hfb, hd)
+        # Hostile validity geometry stays a BoundsError, exactly like the
+        # per-element path.
+        short = AC.ArrayData(
+            IntType(8, true),
+            9,
+            [BufferSlice(AC.heapregion(UInt8[0xff]), 0, 1), AC._databuffer(Int8.(1:9))];
+            nullcount=0,
+        )
+        sf9 = Field("s", IntType(8, true); nullable=true)
+        @test_throws BoundsError materialize(Union{Missing,Int8}, sf9, short)
+        # Invalid widths (juliatype 64-bit fallback) refuse instead of
+        # copying at the claim's width or asserting a mistyped load.
+        i24 = AC.ArrayData(
+            IntType(24, true),
+            2,
+            [BufferSlice(), AC._databuffer(UInt8[8, 0, 0, 7, 0, 0])],
+        )
+        f24 = Field("x", IntType(24, true); nullable=false)
+        @test_throws ArgumentError materialize(Int64, f24, i24)
+        @test_throws ArgumentError getvalue(Int64, f24, i24, 1)
+        # The buffer is PADDED to hold two Float64 bit patterns: a removed
+        # bulk-width gate would then copy wrong-width values successfully
+        # instead of tripping buffer bounds — this pin must fail on the
+        # wrong VALUES, not pass on an incidental bounds error.
+        f64bytes = collect(reinterpret(UInt8, Float64[1.25, -3.5]))
+        fl24 = AC.ArrayData(FloatType(24), 2, [BufferSlice(), AC._databuffer(f64bytes)])
+        ff24 = Field("y", FloatType(24); nullable=false)
+        @test_throws ArgumentError materialize(Float64, ff24, fl24)
+        @test_throws ArgumentError getvalue(Float64, ff24, fl24, 1)
+        # Fresh-process allocation: the typed hot loop must reach steady
+        # state without compiler-introspection priming (a separate process
+        # so this suite's own inference cannot mask a regression).
+        @test success(
+            `$(Base.julia_cmd()) --startup-file=no --project=$(Base.active_project()) $(joinpath(@__DIR__, "typed_alloc_child.jl"))`,
+        )
+    end
+
+    @testset "exact materialization budgets" begin
+        vectorbytes(T, n) = AC._materializedvectorbytes(T, n)
+        objectbytes(n) = AC._materializedobjectbytes(n)
+
+        # Julia 1.11+ can round a 4097-element Memory backing store to 8192
+        # elements. The common reserve must cover the real warm allocation,
+        # not only the logical payload.
+        @noinline vectorprobe() = Vector{Int64}(undef, 4097)
+        vectorprobe()
+        @test vectorbytes(Int64, 4097) >= _allocated(vectorprobe)
+        @noinline emptyvectorprobe() = UInt8[]
+        emptyvectorprobe()
+        @test vectorbytes(UInt8, 0) == 64
+        @test vectorbytes(UInt8, 0) >= _allocated(emptyvectorprobe)
+
+        function exactbudget(read, needed)
+            short = Arrow.AllocationBudget(needed - 1)
+            before = Arrow._remaining(short)
+            @test_throws Arrow.AllocationLimitError read(short)
+            @test Arrow._remaining(short) == before
+            exact = Arrow.AllocationBudget(needed)
+            value = read(exact)
+            @test Arrow._remaining(exact) == 0
+            return value
+        end
+
+        f, d = fromjulia("x", Int64[1, 2, 3, 4])
+        dynamicneed = vectorbytes(Any, d.len) + d.len * objectbytes(sizeof(Int64))
+        @test exactbudget(b -> materialize(f, d, b), dynamicneed) == Any[1, 2, 3, 4]
+        typedneed = vectorbytes(Int64, d.len)
+        @test exactbudget(b -> materialize(Int64, f, d, b), typedneed) == Int64[1, 2, 3, 4]
+
+        emptyutf8field, emptyutf8data = fromjulia("s", String["", "", ""])
+        emptyutf8need = vectorbytes(Any, emptyutf8data.len)
+        @test exactbudget(
+            b -> materialize(emptyutf8field, emptyutf8data, b),
+            emptyutf8need,
+        ) == Any["", "", ""]
+
+        emptybinarytype = BinaryType(false)
+        emptybinaryfield = Field("b", emptybinarytype; nullable=false)
+        emptybinarydata = AC.ArrayData(
+            emptybinarytype,
+            3,
+            [BufferSlice(), AC._databuffer(Int32[0, 0, 0, 0]), AC._databuffer(UInt8[])];
+            nullcount=0,
+        )
+        emptybinaryneed = vectorbytes(Any, 3) + 3 * vectorbytes(UInt8, 0)
+        @test exactbudget(
+            b -> materialize(emptybinaryfield, emptybinarydata, b),
+            emptybinaryneed,
+        ) == Any[UInt8[], UInt8[], UInt8[]]
+
+        emptylistfield, emptylistdata =
+            fromjulia("list", Vector{Int64}[Int64[], Int64[], Int64[]])
+        emptylistneed = vectorbytes(Any, 3) + 3 * vectorbytes(Any, 0)
+        @test exactbudget(
+            b -> materialize(emptylistfield, emptylistdata, b),
+            emptylistneed,
+        ) == Any[Any[], Any[], Any[]]
+
+        emptykeyfield, emptykeydata = fromjulia("key", String[])
+        emptyvaluefield, emptyvaluedata = fromjulia("value", Int64[])
+        emptyentriesfield = Field(
+            "entries",
+            StructType();
+            nullable=false,
+            children=[emptykeyfield, emptyvaluefield],
+        )
+        emptyentriesdata = AC.ArrayData(
+            StructType(),
+            0,
+            [BufferSlice()];
+            children=[emptykeydata, emptyvaluedata],
+            nullcount=0,
+        )
+        emptymaptype = MapType(false)
+        emptymapfield =
+            Field("map", emptymaptype; nullable=false, children=[emptyentriesfield])
+        emptymapdata = AC.ArrayData(
+            emptymaptype,
+            3,
+            [BufferSlice(), AC._databuffer(Int32[0, 0, 0, 0])];
+            children=[emptyentriesdata],
+            nullcount=0,
+        )
+        emptymapneed = vectorbytes(Any, 3) + 3 * vectorbytes(Pair{Any,Any}, 0)
+        @test exactbudget(b -> materialize(emptymapfield, emptymapdata, b), emptymapneed) ==
+              Any[Pair{Any,Any}[], Pair{Any,Any}[], Pair{Any,Any}[]]
+
+        nf, nd = fromjulia("nullable", Union{Missing,Int64}[1, missing, 3, missing])
+        nullabledynamic = vectorbytes(Any, nd.len) + 2 * objectbytes(sizeof(Int64))
+        @test isequal(
+            exactbudget(b -> materialize(nf, nd, b), nullabledynamic),
+            Any[1, missing, 3, missing],
+        )
+        NT = Union{Missing,Int64}
+        # The nullable bulk path loads values straight into its result.
+        nullabletyped = vectorbytes(NT, nd.len)
+        @test isequal(
+            exactbudget(b -> materialize(NT, nf, nd, b), nullabletyped),
+            NT[1, missing, 3, missing],
+        )
+
+        intervaltype = IntervalType(AC.MONTH_DAY_NANO)
+        intervals = [
+            (months=Int32(1), days=Int32(2), nanos=Int64(3)),
+            (months=Int32(4), days=Int32(5), nanos=Int64(6)),
+        ]
+        intervalfield = Field("i", intervaltype; nullable=false)
+        intervaldata = AC.ArrayData(
+            intervaltype,
+            length(intervals),
+            [BufferSlice(), AC._databuffer(intervals)],
+        )
+        intervalneed =
+            vectorbytes(Any, length(intervals)) + length(intervals) * objectbytes(16)
+        @test exactbudget(b -> materialize(intervalfield, intervaldata, b), intervalneed) ==
+              intervals
+
+        listsize = 100_000
+        childfield, childdata = fromjulia("item", Bool[isodd(i) for i = 1:listsize])
+        fixedtype = FixedSizeListType(listsize)
+        fixedfield = Field("values", fixedtype; nullable=false, children=[childfield])
+        fixeddata = AC.ArrayData(fixedtype, 1, [BufferSlice()]; children=[childdata])
+        fixedneed = vectorbytes(Any, 1) + vectorbytes(Any, listsize)
+        fixed = exactbudget(b -> materialize(fixedfield, fixeddata, b), fixedneed)
+        @test length(only(fixed)) == listsize
+        @test only(fixed)[1:4] == Any[true, false, true, false]
+
+        # A hostile width must exhaust the budget before the preflight can
+        # touch a deliberately short child.
+        huge = FixedSizeListType(1_000_000_000)
+        hugefield = Field(
+            "huge",
+            huge;
+            nullable=false,
+            children=[Field("item", NullType(); nullable=true)],
+        )
+        hugedata = AC.ArrayData(
+            huge,
+            1,
+            [BufferSlice()];
+            children=[AC.ArrayData(NullType(), 0, BufferSlice[]; nullcount=0)],
+        )
+        hugebudget = Arrow.AllocationBudget(1_000_000)
+        @test_throws Arrow.AllocationLimitError materialize(hugefield, hugedata, hugebudget)
+        @test Arrow._remaining(hugebudget) == 1_000_000
+    end
+
+    @testset "compact empty containers fit the default budget" begin
+        @test success(
+            `$(Base.julia_cmd()) --startup-file=no --project=$(Base.active_project()) $(joinpath(@__DIR__, "empty_container_budget_child.jl"))`,
+        )
+    end
+
+    # The suite commonly starts Julia with one thread. Run the memory-order
+    # stress in a small four-thread child so this gate tests real OS-thread
+    # interleavings on every invocation.
+    @testset "threaded stress child" begin
+        @test success(
+            `$(Base.julia_cmd()) --startup-file=no --threads=4 --project=$(Base.active_project()) $(joinpath(@__DIR__, "threaded_stress.jl"))`,
+        )
+    end
+end # ArrowCore testset
diff --git a/test/cstring_guard_child.jl b/test/cstring_guard_child.jl
new file mode 100644
index 00000000..b23c2c38
--- /dev/null
+++ b/test/cstring_guard_child.jl
@@ -0,0 +1,63 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Guard-page pin for the bounded C-string reader: map
+# EXACTLY the scan limit of readable non-NUL bytes with a PROT_NONE page
+# immediately after. The reader must refuse with ValidationError; touching
+# byte limit+1 would SIGBUS this child instead.
+using Arrow
+const AC = Arrow.ArrowCore
+
+const PROT_READ = Cint(1)
+const PROT_WRITE = Cint(2)
+const PROT_NONE = Cint(0)
+const MAP_PRIVATE = Cint(0x0002)
+const MAP_ANON = Sys.isapple() ? Cint(0x1000) : Cint(0x20)
+
+limit = Int(Arrow.CSTRING_SCAN_LIMIT)
+page = Int(ccall(:getpagesize, Cint, ()))
+total = limit + page
+p = ccall(
+    :mmap,
+    Ptr{UInt8},
+    (Ptr{Cvoid}, Csize_t, Cint, Cint, Cint, Int64),
+    C_NULL,
+    total,
+    PROT_READ | PROT_WRITE,
+    MAP_PRIVATE | MAP_ANON,
+    -1,
+    0,
+)
+p == Ptr{UInt8}(-1) && error("mmap failed")
+for i = 1:limit
+    unsafe_store!(p, 0x41, i)
+end
+rc = ccall(:mprotect, Cint, (Ptr{Cvoid}, Csize_t, Cint), p + limit, page, PROT_NONE)
+rc == 0 || error("mprotect failed")
+
+caught = try
+    Arrow._import_cstring(p, "guard probe")
+    false
+catch e
+    e isa AC.ValidationError
+end
+caught || error("bounded C-string read did not refuse at the scan limit")
+
+# A NUL just inside the window still reads cleanly (maximum payload).
+unsafe_store!(p, 0x00, limit)
+s = Arrow._import_cstring(p, "max payload")
+length(s) == limit - 1 || error("maximum payload length wrong")
+println("cstring guard page ok")
diff --git a/test/dataframes_tests.jl b/test/dataframes_tests.jl
new file mode 100644
index 00000000..3cf6fe09
--- /dev/null
+++ b/test/dataframes_tests.jl
@@ -0,0 +1,75 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module DataFramesTests
+
+using Test, Arrow, DataFrames, DataAPI, Dates
+using PooledArrays: PooledArray
+
+@testset "DataFrame workflows" begin
+    @test Base.get_extension(Arrow, :ArrowDataFramesExt) !== nothing
+    df = DataFrame(
+        id=[1, 2, 3],
+        x=[1.5, missing, 3.5],
+        name=["a", "a longer string than twelve bytes", missing],
+        day=[Date(2025, 1, 1), Date(2025, 1, 2), Date(2025, 1, 3)],
+        region=PooledArray(["east", "west", "east"]),
+        tags=[["a", "b"], String[], ["c"]],
+        point=[(x=1, y=2.0), (x=3, y=4.0), (x=5, y=6.0)],
+        attrs=[Dict("k" => 1), Dict("j" => 2, "k" => 3), Dict{String,Int}()],
+    )
+    metadata!(df, "source", "test"; style=:default)
+    colmetadata!(df, :id, "unit", "count"; style=:default)
+    path = joinpath(mktempdir(), "df.arrow")
+    Arrow.write(path, df)
+
+    @testset "a copy equals what was written and owns its columns" begin
+        t = Arrow.Table(path)
+        copied = DataFrame(t)
+        @test isequal(copied, df)
+        @test isequal(Arrow.read(path, DataFrame), df)
+        @test copied.attrs[2]["k"] == 3 && copied.tags[1] == ["a", "b"]
+        copied.id[1] = 10
+        @test t.id[1] == 1
+        @test metadata(copied, "source") == "test"
+        @test colmetadata(copied, :id, "unit") == "count"
+        push!(copied.tags[2], "new")
+        @test isempty(t.tags[2])
+    end
+
+    @testset "views read through DataFrames operations" begin
+        views = DataFrame(Arrow.Table(path); copycols=false)
+        @test isequal(views, df)
+        @test_throws Exception (views.id[1] = 10)
+        @test sort(views, :id; rev=true).id == [3, 2, 1]
+        @test filter(:id => >(1), views).id == [2, 3]
+        grouped = combine(groupby(views, :region), :id => sum => :total)
+        @test sort(grouped, :region).total == [4, 2]
+        joined = innerjoin(views, DataFrame(id=[2], y=[20]); on=:id)
+        @test joined.y == [20] && joined.day == [Date(2025, 1, 2)]
+    end
+
+    @testset "a table read back writes back" begin
+        t = Arrow.Table(path)
+        again = Arrow.Table(take!(Arrow.write(IOBuffer(), DataFrame(t); file=true)))
+        @test isequal(DataFrame(again), df)
+        rewritten = Arrow.Table(take!(Arrow.write(IOBuffer(), t; file=true)))
+        @test isequal(DataFrame(rewritten), df)
+        @test DataAPI.metadata(rewritten, "source") == "test"
+    end
+end
+
+end # module DataFramesTests
diff --git a/test/dates.jl b/test/dates.jl
deleted file mode 100644
index 9d33f5b6..00000000
--- a/test/dates.jl
+++ /dev/null
@@ -1,78 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import Dates
-import TimeZones
-
-struct WrappedDate
-    x::Dates.Date
-end
-
-ArrowTypes.arrowname(::Type{WrappedDate}) = Symbol("JuliaLang.WrappedDate")
-ArrowTypes.JuliaType(::Val{Symbol("JuliaLang.WrappedDate")}) = WrappedDate
-
-struct WrappedTime
-    x::Dates.Time
-end
-
-ArrowTypes.arrowname(::Type{WrappedTime}) = Symbol("JuliaLang.WrappedTime")
-ArrowTypes.JuliaType(::Val{Symbol("JuliaLang.WrappedTime")}) = WrappedTime
-
-struct WrappedDateTime
-    x::Dates.DateTime
-end
-
-ArrowTypes.arrowname(::Type{WrappedDateTime}) = Symbol("JuliaLang.WrappedDateTime")
-ArrowTypes.JuliaType(::Val{Symbol("JuliaLang.WrappedDateTime")}) = WrappedDateTime
-
-struct WrappedZonedDateTime
-    x::TimeZones.ZonedDateTime
-end
-
-ArrowTypes.arrowname(::Type{WrappedZonedDateTime}) =
-    Symbol("JuliaLang.WrappedZonedDateTime")
-ArrowTypes.JuliaType(::Val{Symbol("JuliaLang.WrappedZonedDateTime")}) = WrappedZonedDateTime
-
-@testset "Date and time wrappers with missing" begin
-    for T in (WrappedDate, WrappedTime, WrappedDateTime, WrappedZonedDateTime)
-        if T == WrappedZonedDateTime
-            time = T(Dates.now(TimeZones.tz"UTC"))
-        else
-            time = T(Dates.now())
-        end
-        table = (; x=[missing, missing, time, missing, time])
-        io = Arrow.tobuffer(table)
-        tbl = Arrow.Table(io)
-        @test isequal(collect(tbl.x), table.x)
-    end
-end
-
-@testset "`default(T) isa T`" begin
-    for T in (
-        Dates.Date,
-        Dates.Time,
-        Dates.DateTime,
-        TimeZones.ZonedDateTime,
-        Dates.Nanosecond,
-        Dates.Millisecond,
-        Dates.Second,
-        Dates.Day,
-        Dates.Month,
-        Dates.Year,
-    )
-        @test Arrow.ArrowTypes.default(T) isa T
-    end
-end
diff --git a/test/detached_values_tests.jl b/test/detached_values_tests.jl
new file mode 100644
index 00000000..3b527479
--- /dev/null
+++ b/test/detached_values_tests.jl
@@ -0,0 +1,297 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module DetachedValuesTests
+using Test, Arrow, Serialization, Tables
+using DataDecimals: Decimal
+using DataStrings: DataString
+const AC = Arrow.ArrowCore
+
+function roundtrip(x)
+    io = IOBuffer()
+    serialize(io, x)
+    seekstart(io)
+    return deserialize(io)
+end
+
+function detached(d)
+    @test d.owner === nothing
+    for b in d.buffers
+        b.region === nothing && continue
+        @test b.region.root isa (VERSION >= v"1.11" ? Memory{UInt8} : Vector{UInt8})
+        @test b.region.cell.action == C_NULL
+        @test b.region.cell.arg === nothing
+        @test !b.region.cell.closed
+    end
+    foreach(detached, d.children)
+    d.dictionary === nothing || detached(d.dictionary)
+end
+
+@testset "Detached copy and serialization" begin
+    pairs = [
+        Arrow.fromjulia("x", v) for v in (
+            Union{Missing,Int32}[1, missing, 3],
+            Union{Missing,Bool}[true, missing, false],
+            ["short", "a string longer than twelve bytes", ""],
+            [[1, 2], Int[], [3]],
+            Int32[],
+            [missing, missing],
+        )
+    ]
+    sf1, sd1 = Arrow.fromjulia("a", [1, 2])
+    sf2, sd2 = Arrow.fromjulia("b", ["one", "two"])
+    st = AC.StructType()
+    push!(
+        pairs,
+        (
+            AC.Field("struct", st; children=[sf1, sf2]),
+            AC.ArrayData(st, 2, [AC.BufferSlice()]; children=[sd1, sd2], nullcount=0),
+        ),
+    )
+    f, d = Arrow.fromjulia("slice", Int32[10, 20, 30, 40])
+    push!(pairs, (f, AC.ArrayData(d.type, 2, d.buffers; offset=1, nullcount=0)))
+    pf, pd = Arrow.fromjulia("pool", ["first", "unused", "last"])
+    dt = AC.DictionaryType(AC.IntType(8, true), pd.type, true)
+    push!(
+        pairs,
+        (
+            AC.Field("dict", dt),
+            AC.ArrayData(
+                dt,
+                3,
+                [AC.BufferSlice(), AC._databuffer(Int8[2, 0, 2])];
+                dictionary=pd,
+                nullcount=0,
+            ),
+        ),
+    )
+    for (f, d) in pairs
+        sp, ap = Arrow.to_c_data(f, d)
+        fi, imported = Arrow.from_c_data(sp, ap)
+        expected = Arrow.materialize(fi, imported)
+        copied = copy(imported)
+        saved = roundtrip((fi, imported, imported))
+        @test saved[2] === saved[3]
+        Arrow.release!(imported.owner)
+        GC.gc()
+        for result in (copied, saved[2])
+            detached(result)
+            @test result.offset == imported.offset
+            @test isequal(Arrow.materialize(fi, result), expected)
+            @test Arrow.validate_semantic(fi, result) === result
+        end
+        Arrow._reap!()
+    end
+    # A fresh process must rebuild pointers from saved bytes, after release.
+    mktemp() do path, io
+        f, d = Arrow.fromjulia("saved", Int32[4, 5, 6])
+        sp, ap = Arrow.to_c_data(f, d)
+        fi, imported = Arrow.from_c_data(sp, ap)
+        serialize(io, (fi, imported))
+        close(io)
+        Arrow.release!(imported.owner)
+        Arrow._reap!()
+        code = "using Arrow, Serialization; f, d = deserialize(ARGS[1]); @assert Arrow.materialize(f, d) == Int32[4,5,6]; @assert d.owner === nothing"
+        cmd = `$(Base.julia_cmd()) --startup-file=no --check-bounds=yes --project=$(Base.active_project()) -e $code $path`
+        @test success(cmd)
+    end
+    # Copy a BufferSlice window, not its whole underlying allocation.
+    backing = UInt8[0xaa, 1, 2, 3, 0xbb]
+    f = AC.Field("window", AC.IntType(8, false))
+    d = AC.ArrayData(
+        f.type,
+        3,
+        [AC.BufferSlice(), AC.BufferSlice(AC.heapregion(backing), 1, 3)],
+    )
+    c, s = copy(d), roundtrip(d)
+    backing[2:4] .= 9
+    @test Arrow.materialize(f, c) == [1, 2, 3]
+    @test Arrow.materialize(f, s) == [1, 2, 3]
+    Arrow.release!(d.buffers[2].region)
+    @test_throws InvalidStateException copy(d)
+    @test_throws InvalidStateException roundtrip(d)
+
+    b = Arrow.batch((x=Int32[1, 2], y=["one", "two"]))
+    bc, bs = copy(b), roundtrip(b)
+    foreach(
+        c ->
+            foreach(buf -> buf.region === nothing || Arrow.release!(buf.region), c.buffers),
+        b.columns,
+    )
+    for result in (bc, bs)
+        @test result.nrows == 2
+        @test Arrow.materialize(result.schema.fields[1], result.columns[1]) == [1, 2]
+        foreach(detached, result.columns)
+    end
+    empty = AC.RecordBatch(AC.Schema(AC.Field[]), AC.ArrayData[], 7)
+    @test copy(empty).nrows == roundtrip(empty).nrows == 7
+
+    mktemp() do path, io
+        Arrow.write(io, (x=Int32[1, 2], y=["a long materialized string", "two"]))
+        close(io)
+        t = Arrow.Table(path)
+        want = Tables.columntable(t)
+        tc, ts = copy(t), roundtrip(t)
+        Arrow.release!(t)
+        for result in (tc, ts)
+            @test isempty(getfield(result, :regions))
+            @test Tables.columntable(result) == want
+        end
+        tc.x[1] = 99
+        @test want.x[1] == ts.x[1] == 1
+    end
+end
+
+@testset "nested public values detach from input buffers" begin
+    D = Decimal{20,2,Int128}
+    a, b = D("1.25"), D("2.50")
+    cases = (
+        [[a, b], D[]],
+        [[[a], [b]], Vector{D}[]],
+        [(amount=a, values=[a, b]), (amount=b, values=D[])],
+        [([a], [b]), (D[], [a])],
+        [Dict("key" => [a], "other" => [b]), Dict("empty" => D[])],
+        Union{Missing,Vector{D}}[missing, [a, b]],
+        Union{Int,Vector{D}}[1, [a, b]],
+    )
+    for values in cases, batchsize in (1, 64)
+        bytes = take!(Arrow.tobuffer((; x=values); batchsize))
+        table = Arrow.Table(bytes)
+        copied = copy(table)
+        saved = roundtrip(table)
+        readcopy = Arrow.read(bytes, Tables.columntable)
+        fill!(bytes, 0)
+        for result in (copied, saved, readcopy)
+            @test isequal(result.x, values)
+            rewritten = Arrow.Table(take!(Arrow.tobuffer(result)))
+            @test isequal(copy(rewritten).x, values)
+        end
+    end
+    for batchsize in (1, 64)
+        values = [[a], [b], [a]]
+        bytes = take!(Arrow.tobuffer((; x=Arrow.DictEncode(values)); batchsize))
+        table = Arrow.Table(bytes)
+        copied, saved = copy(table), roundtrip(table)
+        fill!(bytes, 0)
+        @test copied.x == saved.x == values
+        @test copied.x[1] isa Vector{D}
+        @test copy(Arrow.Table(take!(Arrow.tobuffer(copied)))).x == values
+    end
+
+    # Empty nested columns use the same owned element types as nonempty ones.
+    empty = Arrow.Table(take!(Arrow.tobuffer((; x=Vector{Vector{D}}[]))))
+    @test eltype(copy(empty).x) === Vector{Vector{D}}
+    @test eltype(roundtrip(empty).x) === Vector{Vector{D}}
+
+    # Type overrides can box a borrowed row behind Any or an abstract container.
+    boxed = (
+        ([[a, b]], Any),
+        ([[a, b]], AbstractVector),
+        ([[a, b]], AbstractVector{D}),
+        ([(values=[a, b],)], NamedTuple),
+        ([([a], [b])], Tuple),
+    )
+    for (values, target) in boxed
+        bytes = take!(Arrow.tobuffer((; x=values)))
+        select = [:x => target]
+        table = Arrow.Table(bytes; select)
+        copied, saved = copy(table), roundtrip(table)
+        readcopy = Arrow.read(bytes, Tables.columntable; select)
+        fill!(bytes, 0)
+        @test copied.x == saved.x == readcopy.x == values
+    end
+    for target in (Any, Tuple, Tuple{Vararg{Int}}, NamedTuple)
+        bytes = take!(Arrow.tobuffer((; x=NamedTuple{(:a,),Tuple{Int}}[])))
+        table = Arrow.Table(bytes; select=[:x => target])
+        @test isempty(copy(table).x)
+        @test isempty(roundtrip(table).x)
+    end
+    materialized = Arrow.Table(take!(Arrow.tobuffer((; x=[Int128[1, 2]]))))
+    @test copy(materialized).x[1] === materialized.x[1]
+end
+
+@testset "copies of map columns are Dicts" begin
+    bytes = take!(Arrow.tobuffer((m=[Dict("a" => 1, "b" => 2), missing, Dict("c" => 3)],)))
+    t = Arrow.Table(bytes)
+    c = copy(t.m)
+    @test c isa Vector{Union{Missing,Dict{DataString,Int64}}}
+    @test c[1]["a"] == 1 && c[2] === missing && c[3]["c"] == 3
+    @test isequal(c, t.m) && isequal(copy(t).m, t.m)
+    owned = Arrow.read(bytes, Tables.columntable).m
+    @test owned[1] isa Dict && owned[1]["b"] == 2
+    @test isequal(roundtrip(t).m, t.m) && roundtrip(t).m[1] isa Dict
+    # Maps inside lists and structs copy to Dicts too, and write back.
+    nested = take!(Arrow.tobuffer((l=[[Dict("k" => 1)]], s=[(m=Dict("k" => 2),)])))
+    tn = Arrow.Table(nested)
+    @test copy(tn.l)[1][1] isa Dict && copy(tn.s)[1].m isa Dict
+    @test isequal(Arrow.Table(take!(Arrow.tobuffer(copy(tn)))).s, tn.s)
+    # The view keeps a repeated key's entries; a copy keeps the last value.
+    dup = Arrow.Table(take!(Arrow.tobuffer((m=[["k" => 1, "k" => 2]],))))
+    @test length(dup.m[1]) == 2 && dup.m[1]["k"] == 2
+    @test copy(dup.m)[1] == Dict("k" => 2)
+end
+
+@testset "Opaque binary metadata" begin
+    metadata = [
+        String(UInt8[0xff, 0x00, 0x80]) => String(UInt8[0xfe, 0x00]),
+        "duplicate" => "one",
+        "duplicate" => "two",
+        "" => "",
+    ]
+    f, d = Arrow.fromjulia("x", Int32[1, 2])
+    f = AC.Field(f.name, f.type; metadata=metadata)
+    schema = AC.Schema([f]; metadata=metadata)
+    b = AC.RecordBatch(schema, [d])
+    # Text required by the C Data spec is still checked.
+    badname = AC.Field(String(UInt8[0xff]), f.type)
+    @test_throws AC.ValidationError Arrow.to_c_data(badname, d)
+    @test Arrow.validate_semantic(f, d) === d
+    for writebytes in (Arrow.writestream, Arrow.writefile)
+        bytes = writebytes(schema, [b])
+        t = Arrow.Table(bytes)
+        @test collect(getfield(t, :schema).metadata) == metadata
+        @test collect(getfield(t, :schema).fields[1].metadata) == metadata
+        io = IOBuffer()
+        Arrow.write(io, t)
+        reread = Arrow.Table(take!(io))
+        @test collect(getfield(reread, :schema).metadata) == metadata
+        @test collect(getfield(reread, :schema).fields[1].metadata) == metadata
+    end
+    sp, ap = Arrow.to_c_data(f, d)
+    fi, di = Arrow.from_c_data(sp, ap)
+    @test collect(fi.metadata) == metadata
+    Arrow.release!(di.owner)
+    Arrow._reap!()
+    for batches in (AC.RecordBatch[], [b])
+        ref = Ref{Arrow.CArrowArrayStream}()
+        GC.@preserve ref begin
+            p = Base.unsafe_convert(Ptr{Arrow.CArrowArrayStream}, ref)
+            Arrow.export_stream!(p, schema, batches)
+            source = Arrow.from_c_stream(p)
+            @test collect(AC.schema(source).metadata) == metadata
+            @test collect(AC.schema(source).fields[1].metadata) == metadata
+            rb = Arrow.nextbatch!(source)
+            if rb !== nothing
+                @test collect(rb.schema.metadata) == metadata
+                Arrow.release!(rb.columns[1].owner)
+            end
+            @test Arrow.nextbatch!(source) === nothing
+            Arrow.release!(source)
+        end
+        Arrow._reap!()
+    end
+end
+end
diff --git a/test/eager_source_tests.jl b/test/eager_source_tests.jl
new file mode 100644
index 00000000..eeab7136
--- /dev/null
+++ b/test/eager_source_tests.jl
@@ -0,0 +1,77 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module EagerSourceTests
+
+using Test, Arrow, Tables
+const AC = Arrow.AC
+const ReleaseContext = Base.RefValue{Tuple{Vector{UInt8},Base.RefValue{Int}}}
+
+function poison_source(p::Ptr{Cvoid})::Cvoid
+    bytes, calls = (unsafe_pointer_to_objref(p)::ReleaseContext)[]
+    calls[] += 1
+    fill!(bytes, 0)
+    return nothing
+end
+
+function eagerhandle(bytes; limits=Arrow.Limits())
+    context = Ref((bytes, Ref(0)))
+    cell = AC.ReleaseCell(@cfunction(poison_source, Cvoid, (Ptr{Cvoid},)), context)
+    region = AC.OwnerRegion(pointer(bytes), length(bytes); root=bytes, cell)
+    return Arrow.readfile(region; limits), region, context[][2]
+end
+
+@testset "facade columns outlive externally releasable sources" begin
+    values = (x=Int64[11, 22], nested=[(n=Int64(1),), (n=Int64(2),)])
+    for compress in (:none, :zstd), form in (:table, :scan, :iterate, :index)
+        bytes = take!(Arrow.tobuffer(values; file=true, compress))
+        handle, region, calls = eagerhandle(bytes)
+        stream = form in (:iterate, :index) ? Arrow.Stream(handle) : nothing
+        table = if form === :table
+            Arrow.Table(handle)
+        elseif form === :scan
+            Arrow.Table(handle; select=[:x, :nested])
+        elseif form === :iterate
+            first(stream)
+        else
+            stream[1]
+        end
+        x, nested = table.x, table.nested
+        @test x == values.x
+        @test nested == values.nested
+        Arrow.release!(table)
+        @test calls[] == 0
+        @test !(@atomic region.cell.closed)
+        AC.release!(region)
+        @test calls[] == 1
+        @test x == values.x
+        @test nested == values.nested
+        @test_throws InvalidStateException table.x
+        stream === nothing || @test_throws InvalidStateException first(stream)
+    end
+    # Detaching is part of the read's allocation allowance, before copying.
+    bytes = take!(Arrow.tobuffer((x=collect(Int64, 1:10000),); file=true))
+    limits = Arrow.Limits(max_total_allocated_bytes=length(bytes) - 1)
+    handle, region, calls = eagerhandle(bytes; limits)
+    @test_throws Arrow.AllocationLimitError Arrow.Table(handle)
+    @test_throws Arrow.AllocationLimitError Arrow.Stream(handle)
+    @test calls[] == 0
+    @test !(@atomic region.cell.closed)
+    AC.release!(region)
+    @test calls[] == 1
+end
+
+end # module EagerSourceTests
diff --git a/test/empty_container_budget_child.jl b/test/empty_container_budget_child.jl
new file mode 100644
index 00000000..4565505e
--- /dev/null
+++ b/test/empty_container_budget_child.jl
@@ -0,0 +1,94 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Isolate the high-row-count acceptance gate so every case releases its heap
+# before the parent suite continues.
+# At 2,000,000 rows, charging each empty value as a nonempty Vector would
+# exceed a 256 MiB budget. Empty values must be charged as empty.
+
+using Arrow
+
+const AC = Arrow.AC
+const N = 2_000_000
+
+function roundtripempty(field, data)
+    schema = AC.Schema([field])
+    bytes = Arrow.writestream(schema, [AC.RecordBatch(schema, [data], N)])
+    table = Arrow.Table(bytes; limits=Arrow.Limits(max_total_allocated_bytes=256 * 1024^2))
+    column = table.x
+    @assert length(column) == N
+    @assert isempty(first(column))
+    @assert isempty(last(column))
+    Arrow.release!(table)
+    return nothing
+end
+
+function checkutf8()
+    field, data = AC.fromjulia("x", fill("", N))
+    roundtripempty(field, data)
+end
+
+function checkbinary()
+    type = AC.BinaryType(false)
+    field = AC.Field("x", type; nullable=false)
+    data = AC.ArrayData(
+        type,
+        N,
+        [AC.BufferSlice(), AC._databuffer(zeros(Int32, N + 1)), AC._databuffer(UInt8[])];
+        nullcount=0,
+    )
+    roundtripempty(field, data)
+end
+
+function checklist()
+    field, data = AC.fromjulia("x", fill(Int64[], N))
+    roundtripempty(field, data)
+end
+
+function checkmap()
+    keyfield, keydata = AC.fromjulia("key", String[])
+    valuefield, valuedata = AC.fromjulia("value", Int64[])
+    entriesfield = AC.Field(
+        "entries",
+        AC.StructType();
+        nullable=false,
+        children=[keyfield, valuefield],
+    )
+    entriesdata = AC.ArrayData(
+        AC.StructType(),
+        0,
+        [AC.BufferSlice()];
+        children=[keydata, valuedata],
+        nullcount=0,
+    )
+    type = AC.MapType(false)
+    field = AC.Field("x", type; nullable=false, children=[entriesfield])
+    data = AC.ArrayData(
+        type,
+        N,
+        [AC.BufferSlice(), AC._databuffer(zeros(Int32, N + 1))];
+        children=[entriesdata],
+        nullcount=0,
+    )
+    roundtripempty(field, data)
+end
+
+for check in (checkutf8, checkbinary, checklist, checkmap)
+    check()
+    GC.gc(true)
+end
+
+println("default allocation limit accepts compact empty containers ✓")
diff --git a/test/facade_tests.jl b/test/facade_tests.jl
new file mode 100644
index 00000000..38caec1d
--- /dev/null
+++ b/test/facade_tests.jl
@@ -0,0 +1,3415 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The public facade: Arrow.Table / Arrow.Stream / Arrow.write. Interface
+# tests only — layout/validation depth lives in the core tests, batteries,
+# and the conformance suites.
+
+module FacadeTests
+
+using Test
+using Tables
+using Dates
+import DataAPI
+import Profile
+using Arrow
+using DataStrings
+using Logging
+using UUIDs
+import DataDecimals, Durations
+using DataStrings: StringVector, StringPayload, BytesVector, DataBytes
+include(joinpath(@__DIR__, "support", "mapped.jl"))
+
+struct _InterruptingPeriod <: Dates.Period end
+struct _OutOfMemoryPeriod <: Dates.Period end
+struct _InterruptingInteger <: Integer end
+struct _ScanHookInteger <: Integer end
+Base.Int64(::_InterruptingInteger) = throw(InterruptException())
+const _SCAN_HOOK_CALLS = Ref(0)
+Base.convert(::Type{Second}, ::_InterruptingPeriod) = throw(InterruptException())
+Base.convert(::Type{Second}, ::_OutOfMemoryPeriod) = throw(OutOfMemoryError())
+Base.Int64(::_ScanHookInteger) = (_SCAN_HOOK_CALLS[] += 1; Int64(7))
+Base.:(==)(::Int64, ::_ScanHookInteger) = false
+Base.:(==)(::_ScanHookInteger, ::Int64) = false
+
+# In-memory byte-range sources: the plain one, and one that meters bytes.
+struct _BytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::_BytesSource) = length(s.data)
+Arrow.readrange(s::_BytesSource, off, len) = s.data[(off + 1):(off + len)]
+struct _MeteredSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+    fetched::Base.RefValue{Int64}
+end
+Arrow.sourcelength(s::_MeteredSource) = length(s.data)
+function Arrow.readrange(s::_MeteredSource, off, len)
+    s.fetched[] += len
+    return s.data[(off + 1):(off + len)]
+end
+# A source that logs every request, and a concurrent one whose reads finish
+# in reverse request order (the last-issued read of a round completes first)
+# while a counter records the most reads ever in flight.
+struct _LoggingSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+    requests::Vector{NTuple{2,Int64}}
+end
+Arrow.sourcelength(s::_LoggingSource) = length(s.data)
+# A Stream reads ahead on another task: log and inspect under one lock.
+const _LOG_LOCK = ReentrantLock()
+function Arrow.readrange(s::_LoggingSource, off, len)
+    @lock _LOG_LOCK push!(s.requests, (Int64(off), Int64(len)))
+    return s.data[(off + 1):(off + len)]
+end
+mutable struct _ConcurrentSource <: Arrow.AbstractArrowSource
+    const data::Vector{UInt8}
+    const limit::Int
+    @atomic inflight::Int
+    @atomic peak::Int
+    @atomic issued::Int
+    @atomic preferencequeries::Int
+end
+_ConcurrentSource(data, limit) = _ConcurrentSource(data, limit, 0, 0, 0, 0)
+Arrow.sourcelength(s::_ConcurrentSource) = length(s.data)
+function Arrow.concurrentreads(s::_ConcurrentSource)
+    @atomic s.preferencequeries += 1
+    return s.limit
+end
+function Arrow.readrange(s::_ConcurrentSource, off, len)
+    n = @atomic s.inflight += 1
+    while true
+        p = @atomic s.peak
+        (n <= p || (@atomicreplace s.peak p => n).success) && break
+    end
+    order = @atomic s.issued += 1
+    # Later requests of a round return sooner: results must land by request.
+    delaywidth = min(s.limit, 4)
+    sleep(0.002 * max(0, delaywidth - (order % delaywidth)))
+    @atomic s.inflight -= 1
+    return s.data[(off + 1):(off + len)]
+end
+# Sources that violate the contract in each way the reader must refuse.
+# A table with DataAPI metadata, as a DataFrame carries it.
+struct _MetaTable
+    columns::NamedTuple
+    metadata::Dict{String,String}
+    colmetadata::Dict{Symbol,Dict{String,String}}
+end
+Tables.istable(::Type{_MetaTable}) = true
+Tables.columnaccess(::Type{_MetaTable}) = true
+Tables.columns(t::_MetaTable) = t.columns
+DataAPI.metadatasupport(::Type{_MetaTable}) = (read=true, write=false)
+DataAPI.metadatakeys(t::_MetaTable) = keys(t.metadata)
+DataAPI.metadata(t::_MetaTable, k::AbstractString) = t.metadata[k]
+DataAPI.colmetadatasupport(::Type{_MetaTable}) = (read=true, write=false)
+DataAPI.colmetadatakeys(t::_MetaTable, c::Symbol) = keys(get(t.colmetadata, c, Dict()))
+DataAPI.colmetadata(t::_MetaTable, c::Symbol, k::AbstractString) = t.colmetadata[c][k]
+
+struct _ShortSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::_ShortSource) = length(s.data)
+Arrow.readrange(s::_ShortSource, off, len) = s.data[(off + 1):(off + max(0, len - 1))]
+struct _LongSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::_LongSource) = length(s.data)
+Arrow.readrange(s::_LongSource, off, len) = vcat(s.data[(off + 1):(off + len)], 0x00)
+struct _WrongTypeSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::_WrongTypeSource) = length(s.data)
+Arrow.readrange(s::_WrongTypeSource, off, len) = String(s.data[(off + 1):(off + len)])
+struct _BadLengthSource <: Arrow.AbstractArrowSource
+    reported::Any
+end
+Arrow.sourcelength(s::_BadLengthSource) = s.reported
+Arrow.readrange(s::_BadLengthSource, off, len) = zeros(UInt8, len)
+struct _BadConcurrencySource <: Arrow.AbstractArrowSource
+    preference::Any
+end
+Arrow.sourcelength(::_BadConcurrencySource) = 0
+Arrow.concurrentreads(s::_BadConcurrencySource) = s.preference
+Arrow.readrange(::_BadConcurrencySource, off, len) = zeros(UInt8, len)
+
+const MIXED = (
+    ints=Int64[1, 2, 3, 4],
+    floats=[1.5, missing, 3.5, 4.5],
+    strs=["a", "bb", missing, "dddd"],
+    dates=[Date(2024, 1, 1), Date(2025, 6, 15), missing, Date(1969, 12, 31)],
+    stamps=[
+        DateTime(2024, 1, 1, 12, 30),
+        missing,
+        DateTime(2000, 1, 1),
+        DateTime(1970, 1, 1),
+    ],
+    clocks=[Time(12, 30, 15), Time(0), missing, Time(23, 59, 59)],
+    spans=[Millisecond(250), missing, Millisecond(0), Millisecond(-10)],
+    lists=[[1, 2], Int64[], [3], missing],
+    pooled=Arrow.DictEncode(["lo", "hi", "lo", missing]),
+)
+
+function assert_mixed(t)
+    @test t.ints == MIXED.ints
+    @test isequal(t.floats, MIXED.floats)
+    @test isequal(t.strs, MIXED.strs)
+    @test isequal(t.dates, MIXED.dates)
+    @test isequal(t.stamps, MIXED.stamps)
+    @test isequal(t.clocks, MIXED.clocks)
+    @test isequal(t.spans, MIXED.spans)
+    @test isequal(t.lists, [Any[1, 2], Any[], Any[3], missing])
+    @test isequal(t.pooled, ["lo", "hi", "lo", missing])
+end
+
+# Bytes one warmed call of `f` requests from the allocator. `@allocated`
+# counts the usable size of each big block instead, and an allocator that
+# hands back a larger cached block (macOS malloc does) can nearly double
+# that. Top-level functions, so the probe measures `f`, not testset closure
+# boxing.
+function _requestedbytes(f)
+    f()
+    f()
+    Profile.Allocs.clear()
+    Profile.Allocs.@profile sample_rate = 1 f()
+    bytes = sum(a.size for a in Profile.Allocs.fetch().allocs; init=0)
+    Profile.Allocs.clear()
+    return bytes
+end
+
+_tableallocs(bytes) = _requestedbytes(() -> Arrow.Table(bytes))
+_writeallocs(path, tbl) = _requestedbytes(() -> Arrow.write(path, tbl))
+
+# `@allocated` or `@timed` written in the testset below would make Julia compile
+# the whole testset as one function before running it, which takes minutes; it
+# measures through these instead.
+_allocated(f, args...) = @allocated f(args...)
+_timed(f, args...; kwargs...) = @timed f(args...; kwargs...)
+
+@testset "Arrow facade" begin
+    @testset "file round-trip with metadata" begin
+        path = tempname()
+        Arrow.write(
+            path,
+            MIXED;
+            metadata=Dict("who" => "facade"),
+            colmetadata=Dict(:ints => Dict("unit" => "count")),
+        )
+        t = Arrow.Table(path)
+        assert_mixed(t)
+        @test Tables.istable(typeof(t))
+        @test Tables.columnnames(t) == collect(keys(MIXED))
+        @test DataAPI.metadata(t, "who") == "facade"
+        @test collect(DataAPI.metadatakeys(t)) == ["who"]
+        @test DataAPI.colmetadata(t, :ints, "unit") == "count"
+        @test_throws KeyError DataAPI.metadata(t, "absent")
+        # A released table refuses column access; a column taken before the
+        # release keeps the mapping alive and stays readable.
+        ints = t.ints
+        Arrow.release!(t)
+        @test_throws InvalidStateException t.ints
+        @test ints == MIXED.ints
+        rm(path)
+    end
+
+    @testset "stream format, IO sinks and sources" begin
+        io = IOBuffer()
+        Arrow.write(io, MIXED; file=false)
+        t = Arrow.Table(seekstart(io))
+        assert_mixed(t)
+    end
+
+    @testset "compression kwargs" begin
+        for compress in (:lz4, :zstd)
+            io = IOBuffer()
+            Arrow.write(io, MIXED; compress=compress)
+            assert_mixed(Arrow.Table(take!(io)))
+        end
+    end
+
+    @testset "partitions become record batches; Stream iterates them" begin
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            Tables.partitioner([(x=Int64[1, 2],), (x=Int64[3, 4],)]);
+            file=false,
+        )
+        bytes = take!(io)
+        s = Arrow.Stream(bytes)
+        @test length(s) == 2
+        parts = collect(s)
+        @test parts[1].x == [1, 2] && parts[2].x == [3, 4]
+        # Stream is a Tables.partitions source: writing it re-partitions.
+        io2 = IOBuffer()
+        Arrow.write(io2, Arrow.Stream(bytes); file=false)
+        @test length(Arrow.Stream(take!(io2))) == 2
+        # Release closes the public iterator for raw and compressed streams.
+        # Decompressed heap buffers must not bypass the same lifecycle gate.
+        for file in (false, true), compress in (:none, :lz4, :zstd)
+            closedio = IOBuffer()
+            Arrow.write(closedio, (x=Int64[1],); file=file, compress=compress)
+            closed = Arrow.Stream(take!(closedio))
+            Arrow.release!(closed)
+            Arrow.release!(closed)
+            @test_throws InvalidStateException first(closed)
+
+            partitionio = IOBuffer()
+            Arrow.write(
+                partitionio,
+                Tables.partitioner([(x=Int64[1],), (x=Int64[2],)]);
+                file=file,
+                compress=compress,
+            )
+            partitionstream = Arrow.Stream(take!(partitionio))
+            partition, state = iterate(partitionstream)
+            x = partition.x
+            @test x == [1]
+            Arrow.release!(partition)
+            @test_throws InvalidStateException partition.x
+            @test x == [1]
+            @test_throws InvalidStateException iterate(partitionstream, state)
+        end
+        # A path-backed file's mapping is never unmapped eagerly (columns may
+        # still read it): releasing a yielded batch closes the stream, and
+        # garbage collection unmaps once nothing reaches the mapping. The
+        # checks run in their own frame, so no temporary outlives them.
+        function releasemapped(path)
+            mappedstream = Arrow.Stream(path; mmap=true)
+            mappedregion = only(getfield(mappedstream, :regions))
+            @test getfield(getfield(mappedregion, :cell), :action) == C_NULL
+            mappedpartition, state = iterate(mappedstream)
+            x = mappedpartition.x
+            Arrow.release!(mappedpartition)
+            @test_throws InvalidStateException mappedpartition.x
+            @test x == [1]
+            @test_throws InvalidStateException iterate(mappedstream, state)
+            return nothing
+        end
+        path = tempname()
+        try
+            Arrow.write(path, Tables.partitioner([(x=Int64[1],), (x=Int64[2],)]); file=true)
+            releasemapped(path)
+        finally
+            rmmapped(path)
+        end
+        # Whole-table read concatenates.
+        @test Arrow.Table(bytes).x == [1, 2, 3, 4]
+        # A Stream is a sequence of tables, not one: whole-table Tables.jl
+        # access refuses instead of reading each batch as one row of vectors.
+        @test_throws ArgumentError Tables.columns(Arrow.Stream(bytes))
+        @test_throws ArgumentError Tables.rows(Arrow.Stream(bytes))
+        @test_throws ArgumentError Tables.columntable(Arrow.Stream(bytes))
+        @test_throws ArgumentError Tables.rowtable(Arrow.Stream(bytes))
+    end
+
+    @testset "a stream-format Stream reads one batch at a time" begin
+        tables = [(x=Int64[i, i + 1], s=["a$i", "a much longer value $i"]) for i = 1:3]
+        # Over a pipe, each batch is yielded while the writer still holds
+        # the next one: the writer waits for the reader before writing it.
+        pipe = Base.BufferStream()
+        seen = Channel{Int}(3)
+        writer = errormonitor(Threads.@spawn begin
+            Arrow.Writer(pipe; file=false) do w
+                for (k, tbl) in enumerate(tables)
+                    Arrow.write(w, tbl)
+                    k < length(tables) && take!(seen)
+                end
+            end
+            close(pipe)
+        end)
+        reader = Threads.@spawn begin
+            got = Int64[]
+            for (k, b) in enumerate(Arrow.Stream(pipe))
+                append!(got, b.x)
+                put!(seen, k)
+            end
+            got
+        end
+        done = timedwait(() -> istaskdone(reader), 120) == :ok
+        @test done && fetch(reader) == [1, 2, 2, 3, 3, 4]
+        # A failed or stuck reader must not leave the writer waiting.
+        close(seen)
+        done || close(pipe)
+        @test timedwait(() -> istaskdone(writer), 60) == :ok
+        io = IOBuffer()
+        Arrow.write(io, Tables.partitioner(tables); file=false)
+        bytes = take!(io)
+        # Over bytes the batches are framed in place: a length, and a second
+        # iteration starts over.
+        s = Arrow.Stream(bytes)
+        @test length(s) == 3
+        @test [b.x for b in s] == [b.x for b in s] == [[1, 2], [2, 3], [3, 4]]
+        @test_throws ArgumentError s[1]
+        # An IO is read once, and its batch count is not known up front.
+        once = Arrow.Stream(IOBuffer(bytes))
+        @test_throws ArgumentError length(once)
+        @test [b.s[2] for b in once] == ["a much longer value $i" for i = 1:3]
+        @test_throws ArgumentError iterate(once)
+        # A file-format Stream has random access.
+        fio = IOBuffer()
+        Arrow.write(fio, Tables.partitioner(tables); file=true)
+        f = Arrow.Stream(take!(fio))
+        @test length(f) == 3 && f[2].x == [2, 3] && f[3].s[1] == "a3"
+        @test_throws BoundsError f[4]
+        # A truncated stream yields the batches before the damage, then fails;
+        # the Stream stays stopped at the error.
+        for src in (bytes[1:(end - 24)], IOBuffer(bytes[1:(end - 24)]))
+            cut = Arrow.Stream(src)
+            b, state = iterate(cut)
+            @test b.x == [1, 2]
+            b, state = iterate(cut, state)
+            @test b.x == [2, 3]
+            @test_throws Arrow.ValidationError iterate(cut, state)
+            @test_throws ArgumentError iterate(cut, state)
+        end
+    end
+
+    @testset "facade reader limits" begin
+        fileio = IOBuffer()
+        Arrow.write(fileio, (x=Int64[1, 2],); file=true)
+        filebytes = take!(fileio)
+        streamio = IOBuffer()
+        Arrow.write(streamio, (x=Int64[1, 2],); file=false)
+        streambytes = take!(streamio)
+
+        configured = Arrow.Limits(
+            max_metadata_bytes=1024 * 1024,
+            max_messages=16,
+            max_concurrent_reads=3,
+        )
+        incompatible = Arrow.Limits(max_concurrent_reads=2)
+        too_tight = Arrow.Limits(max_metadata_bytes=0)
+
+        path = tempname()
+        open(path, "w") do io
+            Base.write(io, filebytes)
+        end
+        try
+            raw_sources = (
+                ("path mmap", () -> path, NamedTuple()),
+                ("path IO", () -> path, (mmap=false,)),
+                ("IO", () -> IOBuffer(copy(filebytes)), NamedTuple()),
+                ("stream IO", () -> IOBuffer(copy(streambytes)), NamedTuple()),
+                ("byte vector", () -> copy(filebytes), NamedTuple()),
+                ("AbstractArrowSource", () -> _BytesSource(copy(filebytes)), NamedTuple()),
+            )
+            for (name, makesource, kwargs) in raw_sources
+                @testset "$name" begin
+                    table = Arrow.Table(makesource(); limits=configured, kwargs...)
+                    @test table.x == [1, 2]
+                    stream = Arrow.Stream(makesource(); limits=configured, kwargs...)
+                    @test first(stream).x == [1, 2]
+                    @test getfield(stream, :src).limits == configured
+                    Arrow.release!(table)
+                    Arrow.release!(stream)
+
+                    @test_throws Arrow.AC.ValidationError Arrow.Table(
+                        makesource();
+                        limits=too_tight,
+                        kwargs...,
+                    )
+                    @test_throws Arrow.AC.ValidationError Arrow.Stream(
+                        makesource();
+                        limits=too_tight,
+                        kwargs...,
+                    )
+                end
+            end
+        finally
+            ispath(path) && rm(path)
+        end
+
+        opened_handles = (
+            (
+                "SourceFile",
+                Arrow.SourceFile(_BytesSource(copy(filebytes)); limits=configured),
+            ),
+            ("ArrowFile", Arrow.readfile(copy(filebytes); limits=configured)),
+            ("IPCStream", Arrow.readstream(copy(streambytes); limits=configured)),
+        )
+        for (name, handle) in opened_handles
+            @testset "$name" begin
+                @test Arrow.Table(handle).x == [1, 2]
+                @test Arrow.Table(handle; limits=configured).x == [1, 2]
+                stream = Arrow.Stream(handle)
+                @test first(stream).x == [1, 2]
+                @test getfield(stream, :src).limits == configured
+                @test first(Arrow.Stream(handle; limits=configured)).x == [1, 2]
+                @test_throws ArgumentError Arrow.Table(handle; limits=incompatible)
+                @test_throws ArgumentError Arrow.Stream(handle; limits=incompatible)
+            end
+        end
+
+        deferred = Arrow.Limits(max_array_length=1)
+        @test_throws Arrow.AC.ValidationError Arrow.Table(
+            Arrow.SourceFile(_BytesSource(copy(filebytes)); limits=deferred),
+        )
+        @test_throws Arrow.AC.ValidationError Arrow.Table(
+            Arrow.readfile(copy(filebytes); limits=deferred),
+        )
+
+        @static if VERSION >= v"1.11"
+            @test Base.ispublic(Arrow, :Limits)
+            @test Base.ispublic(Arrow, :AllocationLimitError)
+            @test Base.ispublic(Arrow, :release!)
+        end
+        @test !Base.isexported(Arrow, :Limits)
+        @test !Base.isexported(Arrow, :AllocationLimitError)
+        @test !Base.isexported(Arrow, :release!)
+    end
+
+    @testset "default limits scale with the input" begin
+        # Ordinary files read with the default limits whatever their size.
+        path = tempname()
+        try
+            Arrow.write(path, (a=collect(Int64, 1:20_000_000),))
+            t = Arrow.Table(path)
+            @test length(t.a) == 20_000_000 && t.a[end] == 20_000_000
+            Arrow.release!(t)
+            strings = [lpad(string(i), 64, 'x') for i = 1:1_000_000]
+            Arrow.write(path, (s=strings,))
+            t = Arrow.Table(path)
+            @test t.s == strings
+            Arrow.release!(t)
+            # An explicit ceiling still applies (a string column's payloads are
+            # 16 bytes per value: 16 MB here, over the mapped file's bytes).
+            @test_throws Arrow.AllocationLimitError Arrow.Table(
+                path;
+                limits=Arrow.Limits(max_total_allocated_bytes=8 * 1024^2),
+            )
+        finally
+            rm(path; force=true)
+        end
+        # A 464-byte file whose run-end encoded column claims ~1e9 rows reads
+        # as a run-end view: nothing proportional to the claimed length is
+        # allocated.
+        rf, rd = Arrow.AC.fromjulia("run_ends", Int32[999_999_999])
+        vf, vd = Arrow.AC.fromjulia("values", Int64[7])
+        ree = Arrow.AC.RunEndEncodedType()
+        f = Arrow.AC.Field("r", ree; nullable=false, children=[rf, vf])
+        d = Arrow.AC.ArrayData(
+            ree,
+            999_999_999,
+            Arrow.AC.BufferSlice[];
+            children=[rd, vd],
+            nullcount=0,
+        )
+        sch = Arrow.AC.Schema([f])
+        bytes = Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d])])
+        fbytes = Arrow.writefile(sch, [Arrow.AC.RecordBatch(sch, [d])])
+        @test length(bytes) < 1024
+        # Every source kind, including handles opened beforehand.
+        for source in (
+            bytes,
+            fbytes,
+            IOBuffer(bytes),
+            Arrow.readstream(copy(bytes)),
+            Arrow.readfile(copy(fbytes)),
+        )
+            r = Arrow.Table(source).r
+            @test length(r) == 999_999_999 && r[1] == 7 && r[end] == 7
+        end
+        stats = _timed(Arrow.Table, bytes)
+        @test stats.value isa Arrow.Table
+        @test stats.bytes < 64_000_000
+    end
+
+    @testset "offset keyword" begin
+        bytes = take!(Arrow.tobuffer(Tables.partitioner([(x=1:4,), (x=5:9,)]); file=true))
+        @test Arrow.Table(bytes; offset=2, limit=3).x == [3, 4, 5]
+        @test Arrow.Table(bytes; offset=7).x == [8, 9]
+        @test Arrow.Table(bytes; filter=Arrow.col(:x) > 2, offset=3).x == [6, 7, 8, 9]
+        @test reduce(
+            vcat,
+            [collect(t.x) for t in Arrow.Stream(bytes; offset=3, limit=4)],
+        ) == 4:7
+        @test Arrow.read(bytes, Tables.columntable; offset=8).x == [9]
+        @test_throws ArgumentError Arrow.Table(bytes; offset=-1)
+        @test_throws ArgumentError Arrow.Table(bytes; offset=1, scan=Tables.Scan())
+    end
+
+    @testset "read mistakes say what to do" begin
+        bytes = take!(Arrow.tobuffer((x=[1, 2],); file=true))
+        io = IOBuffer()
+        Arrow.write(io, (x=[1, 2],))
+        for read in (Arrow.Table, Arrow.Stream)
+            err = try
+                read(io)
+            catch e
+                e
+            end
+            @test err isa ArgumentError && occursin("seekstart(io)", err.msg)
+        end
+        messages = (
+            bytes[1:(end - 12)] => "an Arrow.Writer was not closed",
+            UInt8[] => "the input is empty",
+            UInt8[0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03] => "gzip",
+        )
+        for (input, message) in messages
+            err = try
+                Arrow.Table(input)
+            catch e
+                e
+            end
+            @test err isa Arrow.ValidationError && occursin(message, err.msg)
+        end
+        @test_throws ArgumentError Arrow.Table(bytes; select=Symbol[])
+        @test_throws ArgumentError Arrow.Table(bytes; select=())
+        @test isempty(Tables.columnnames(Arrow.Table(bytes; scan=Tables.Scan(select=()))))
+    end
+
+    @testset "scan pushdown through Arrow.Table" begin
+        io = IOBuffer()
+        Arrow.write(io, (x=collect(Int64, 1:100), y=string.(1:100)))
+        fb = take!(io)
+        t = Arrow.Table(
+            fb;
+            scan=Tables.Scan(select=(:y,), filter=Tables.colcmp(==, Tables.col(:x), 42)),
+        )
+        @test Tables.columnnames(t) == [:y]
+        @test t.y == ["42"]
+        # Stream-format input takes the post-decode path, same result.
+        io2 = IOBuffer()
+        Arrow.write(io2, (x=collect(Int64, 1:100), y=string.(1:100)); file=false)
+        t2 = Arrow.Table(
+            take!(io2);
+            scan=Tables.Scan(select=(:y,), filter=Tables.colcmp(==, Tables.col(:x), 42)),
+        )
+        @test t2.y == ["42"]
+        # Renames land as output names.
+        t3 = Arrow.Table(fb; scan=Tables.Scan(select=(:x => :renamed,), limit=2))
+        @test Tables.columnnames(t3) == [:renamed]
+        @test t3.renamed == [1, 2]
+    end
+
+    @testset "read keywords build one scan" begin
+        tbl = (a=collect(1:6), b=["x", "y", "z", "w", "v", "u"], c=collect(6.0:-1:1))
+        for file in (true, false)
+            io = IOBuffer()
+            Arrow.write(io, tbl; file=file)
+            bytes = take!(io)
+            @test Tables.columnnames(Arrow.Table(bytes; select=[:c, :a])) == [:c, :a]
+            @test Tables.columnnames(Arrow.Table(bytes; drop=[:b])) == [:a, :c]
+            @test Arrow.Table(bytes; filter=Arrow.col(:a) > 4).b == ["v", "u"]
+            @test Arrow.Table(
+                bytes;
+                filter=Arrow.colcmp(<=, Arrow.col(:c), 2.0),
+                limit=1,
+            ).a == [5]
+            @test Arrow.Table(bytes; filter=Arrow.colin(Arrow.col(:b), ("y", "w"))).a ==
+                  [2, 4]
+            @test isempty(Arrow.Table(bytes; filter=Arrow.isnull(Arrow.col(:a))).a)
+            @test Arrow.Table(bytes; limit=2).a == [1, 2]
+            @test Arrow.read(bytes, Tables.columntable; select=[:b]).b == tbl.b
+            @test_throws ArgumentError Arrow.Table(bytes; select=[:a], drop=[:b])
+            @test_throws ArgumentError Arrow.Table(
+                bytes;
+                limit=1,
+                scan=Tables.Scan(select=(:a,)),
+            )
+        end
+        @test Arrow.col === Tables.col && Arrow.colcmp === Tables.colcmp
+        @test Arrow.colin === Tables.colin && Arrow.isnull === Tables.isnull
+    end
+
+    @testset "a Stream describes its source without reading a batch" begin
+        tbl = (a=collect(1:3), b=["x", "y", "z"])
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            Tables.partitioner([tbl, tbl]);
+            file=true,
+            metadata=Dict("k" => "v"),
+            colmetadata=Dict(:a => Dict("ck" => "cv")),
+        )
+        s = Arrow.Stream(take!(io))
+        shown = sprint(show, MIME"text/plain"(), s)
+        @test startswith(
+            shown,
+            "Arrow.Stream with 2 record batches, 2 columns, and schema:",
+        )
+        @test occursin(":b", shown) && length(shown) < 300
+        @test Tables.columnnames(s) == [:a, :b]
+        @test Tables.schema(s).types == (Union{Missing,Int64}, Union{Missing,DataString})
+        @test DataAPI.nrow(s) == 6 && DataAPI.ncol(s) == 2
+        @test DataAPI.metadata(s, "k") == "v" && DataAPI.metadata(s) == Dict("k" => "v")
+        @test DataAPI.colmetadata(s, :a, "ck") == "cv"
+        @test DataAPI.colmetadata(s, :a) == Dict("ck" => "cv")
+        io = IOBuffer()
+        Arrow.write(io, tbl; file=false)
+        seekstart(io)
+        s = Arrow.Stream(io)
+        @test startswith(sprint(show, s), "Arrow.Stream with 2 columns and schema:")
+        @test Tables.columnnames(s) == [:a, :b]
+        @test_throws ArgumentError DataAPI.nrow(s)
+        @test first(s).b == tbl.b
+    end
+
+    @testset "Stream batches take the read keywords" begin
+        parts = [(x=collect(1:4) .+ 4k, s=string.(collect(1:4) .+ 4k)) for k = 0:2]
+        xs(stream) = reduce(vcat, [collect(t.x) for t in stream]; init=Int[])
+        for file in (true, false)
+            io = IOBuffer()
+            Arrow.write(io, Tables.partitioner(parts); file=file)
+            bytes = take!(io)
+            @test [Tables.columnnames(t) for t in Arrow.Stream(bytes; select=[:s])] == fill([:s], 3)
+            @test [Tables.columnnames(t) for t in Arrow.Stream(bytes; drop=[:s])] == fill([:x], 3)
+            @test xs(Arrow.Stream(bytes; filter=Arrow.col(:x) > 5)) == 6:12
+            # A window counts rows across batches and stops the iteration.
+            @test xs(Arrow.Stream(bytes; limit=6)) == 1:6
+            @test length(collect(Arrow.Stream(bytes; limit=6))) == 2
+            @test xs(Arrow.Stream(bytes; scan=Tables.Scan(offset=3, limit=6))) == 4:9
+            scan =
+                Tables.Scan(select=(:x => :y,), filter=Arrow.col(:x) > 1, offset=2, limit=5)
+            @test reduce(vcat, [collect(t.y) for t in Arrow.Stream(bytes; scan=scan)]) ==
+                  Arrow.Table(bytes; scan=scan).y ==
+                  4:8
+            s = Arrow.Stream(bytes; select=[:s], filter=Arrow.col(:x) > 5)
+            @test Tables.columnnames(s) == [:s]
+            @test Tables.schema(s).types == (Union{Missing,DataString},)
+            @test_throws ArgumentError DataAPI.nrow(s)
+            @test_throws ArgumentError Arrow.Stream(bytes; select=[:nope])
+            if file
+                @test s[2].s == ["6", "7", "8"]
+                @test DataAPI.nrow(Arrow.Stream(bytes; select=[:s])) == 12
+                @test_throws ArgumentError Arrow.Stream(bytes; limit=2)[1]
+            end
+        end
+    end
+
+    @testset "input that is not Arrow IPC data says so" begin
+        for bytes in
+            (collect(UInt8, 1:16), UInt8[0x10, 0, 0, 0, 1, 2, 3, 4], UInt8[1, 2, 3])
+            err = try
+                Arrow.Table(bytes)
+            catch e
+                e
+            end
+            @test err isa Arrow.ValidationError
+            @test startswith(
+                sprint(showerror, err),
+                "Arrow.ValidationError: not Arrow IPC data",
+            )
+        end
+        parquet = vcat(Vector{UInt8}("PAR1"), zeros(UInt8, 12))
+        err = @test_throws Arrow.ValidationError Arrow.Table(parquet)
+        @test occursin("it starts with PAR1, as a Parquet file does", err.value.msg)
+        # Streams written one after another read through Arrow.Stream.
+        io = IOBuffer()
+        Arrow.write(io, (a=[1],); file=false)
+        Arrow.write(io, (a=[2],); file=false)
+        bytes = take!(io)
+        err = @test_throws Arrow.ValidationError Arrow.Table(bytes)
+        @test occursin("an Arrow.Stream of an IO reads one stream", err.value.msg)
+        io = IOBuffer(bytes)
+        @test [b.a for b in Arrow.Stream(io)] == [[1]]
+        @test [b.a for b in Arrow.Stream(io)] == [[2]]
+    end
+
+    @testset "a source streams batches in windows and downloads whole in concurrent ranges" begin
+        # Four batches of 160 KB: a file pass reads them in one window after
+        # the tail, and serves a second pass and random access from it.
+        parts = [(a=collect(Int64, ((k - 1) * 20_000 + 1):(k * 20_000)),) for k = 1:4]
+        for file in (true, false)
+            bytes = take!(Arrow.write(IOBuffer(), Tables.partitioner(parts); file=file))
+            log = _LoggingSource(bytes, NTuple{2,Int64}[])
+            st = Arrow.Stream(log)
+            @test [b.a[1] for b in st] == [1, 20_001, 40_001, 60_001]
+            # A stream object reads forward, its readahead doubling.
+            @test length(log.requests) <= (file ? 2 : 2 + length(parts))
+            n = length(log.requests)
+            @test [b.a[end] for b in st] == [20_000, 40_000, 60_000, 80_000]
+            if file
+                @test length(log.requests) == n
+                @test st[3].a[1] == 40_001 && length(log.requests) == n
+                # The row count reads each batch's metadata, not its body.
+                @test DataAPI.nrow(st) == 80_000
+                @test length(log.requests) == n + length(parts)
+                @test maximum(last, log.requests[(n + 1):end]) < 1_000
+            else
+                # A second pass starts over.
+                @test length(log.requests) > n
+            end
+            kept = Arrow.Stream(log; filter=Arrow.col(:a) > 70_000, select=[:a])
+            @test sum(b -> length(b.a), kept) == 10_000
+        end
+        # Batches larger than a window are fetched one at a time, and at most
+        # one ahead of the batch in use: the third is not fetched while the
+        # first is in use.
+        large = [(a=collect(Int64, ((k - 1) * 1_200_000 + 1):(k * 1_200_000)),) for k = 1:3]
+        bytes = take!(Arrow.write(IOBuffer(), Tables.partitioner(large); file=true))
+        third = Arrow.readfile(bytes).recordblocks[3][1]
+        log = _LoggingSource(bytes, NTuple{2,Int64}[])
+        st = Arrow.Stream(log)
+        b1, _ = iterate(st)
+        @test b1.a[1] == 1
+        tailstart = length(bytes) - 65536
+        @test @lock _LOG_LOCK all(r -> sum(r) <= third || r[1] >= tailstart, log.requests)
+        @test sum(b -> length(b.a), st) == 3_600_000
+        # With concurrent reads, a whole-object read fetches the bytes before
+        # the tail in 8 MiB ranges at once, into one buffer.
+        big = take!(Arrow.write(IOBuffer(), (a=collect(Int64, 1:2_200_000),); file=true))
+        cs = _ConcurrentSource(big, 4)
+        @test Arrow.Table(cs).a == 1:2_200_000
+        @test (@atomic cs.issued) == 1 + cld(length(big) - 65536, 8 * 1024 * 1024)
+        @test (@atomic cs.peak) > 1
+    end
+
+    @testset "ranged source fetches only what the scan needs" begin
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            Tables.partitioner([
+                (a=collect(Int64, 1:1000), b=[string("v", i) for i = 1:1000]),
+                (a=collect(Int64, 1001:2000), b=[string("v", i) for i = 1001:2000]),
+            ]);
+            file=true,
+        )
+        fb = take!(io)
+        fetched = Ref(Int64(0))
+        src = _MeteredSource(fb, fetched)
+        rf = Arrow.SourceFile(src; tailbytes=1024, gapbytes=0)
+        t = Arrow.Table(rf; scan=Tables.Scan(select=(:b,), limit=3, offset=1500))
+        @test t.b == ["v1501", "v1502", "v1503"]
+        # The first batch is skipped entirely and column :a is never fetched.
+        @test fetched[] < length(fb) ÷ 2
+
+        # Request rounds through the public path over an object larger than
+        # the tail window: a pushable scan reads the tail once, then the
+        # surviving batches' metadata with their bodies (small bodies come
+        # whole), so the selected buffers need no third request; ranges
+        # inside the cached tail window are served from it without a request.
+        wide = [string("v", i, "-", repeat("x", 60)) for i = 1:2000]
+        wio = IOBuffer()
+        Arrow.write(
+            wio,
+            Tables.partitioner([
+                (a=collect(Int64, 1:1000), b=wide[1:1000]),
+                (a=collect(Int64, 1001:2000), b=wide[1001:2000]),
+            ]);
+            file=true,
+        )
+        wb = take!(wio)
+        @test length(wb) > 65536
+        log = _LoggingSource(wb, NTuple{2,Int64}[])
+        t2 = Arrow.Table(log; scan=Tables.Scan(select=(:a,), filter=Tables.col(:a) < 10))
+        @test t2.a == collect(1:9)
+        tailreq = (Int64(length(wb) - 65536), Int64(65536))
+        @test count(==(tailreq), log.requests) == 1
+        @test length(log.requests) == 2
+        # An object no larger than the tail window is entirely in hand after
+        # the tail read: every planned range is served from it.
+        small = _LoggingSource(fb, NTuple{2,Int64}[])
+        t3 = Arrow.Table(small; scan=Tables.Scan(select=(:a,), limit=3, offset=1500))
+        @test t3.a == [1501, 1502, 1503]
+        @test small.requests == [(Int64(0), Int64(length(fb)))]
+        # No scan reads the object whole: the cached tail plus the prefix,
+        # two requests and no range planning.
+        empty!(log.requests)
+        tw = Arrow.Table(log)
+        @test tw.a == 1:2000 && length(log.requests) == 2
+        @test sum(last, log.requests) == length(wb)
+
+        # An empty projection still uses the ranged path. The result keeps its
+        # row count and transfers much less than the whole object. The scan
+        # battery checks the exact no-body request plan.
+        emptyfetched = Ref(Int64(0))
+        emptyfile =
+            Arrow.SourceFile(_MeteredSource(wb, emptyfetched); tailbytes=1024, gapbytes=0)
+        tz = Arrow.Table(emptyfile; scan=Tables.Scan(select=()))
+        @test isempty(Tables.columnnames(tz))
+        @test Tables.rowcount(tz) == 2000
+        @test emptyfetched[] < length(wb) ÷ 2
+
+        # A filtered empty projection remains range-efficient. The scan
+        # battery checks that only the filter buffers are requested.
+        filterfetched = Ref(Int64(0))
+        filterfile =
+            Arrow.SourceFile(_MeteredSource(wb, filterfetched); tailbytes=1024, gapbytes=0)
+        tf =
+            Arrow.Table(filterfile; scan=Tables.Scan(select=(), filter=Tables.col(:a) < 10))
+        @test isempty(Tables.columnnames(tf))
+        @test Tables.rowcount(tf) == 9
+        @test filterfetched[] < length(wb) ÷ 2
+
+        # Concurrent reads: bounded by the source's limit, results placed by
+        # request even though later requests complete first.
+        cs = _ConcurrentSource(fb, 3)
+        cf = Arrow.SourceFile(cs; tailbytes=1024, gapbytes=0)
+        tc = Arrow.Table(cf; scan=Tables.Scan(select=(:a, :b)))
+        @test tc.a == 1:2000 && tc.b == [string("v", i) for i = 1:2000]
+        @test 1 < (@atomic cs.peak) <= 3
+        @test (@atomic cs.preferencequeries) == 1
+
+        # Limits cap both the worker count and active reads. The source
+        # preference is sampled once when the handle is constructed.
+        cappedsource = _ConcurrentSource(fb, 10_000)
+        capped = Arrow.SourceFile(
+            cappedsource;
+            limits=Arrow.Limits(max_concurrent_reads=2),
+            tailbytes=1024,
+            gapbytes=0,
+        )
+        cappedtable = Arrow.Table(capped; scan=Tables.Scan(select=(:a, :b)))
+        @test cappedtable.a == 1:2000
+        @test 1 < (@atomic cappedsource.peak) <= 2
+        @test (@atomic cappedsource.preferencequeries) == 1
+
+        # One SourceFile owns one handle-wide semaphore across overlapping
+        # scans, not one semaphore per scan operation.
+        serialsource = _ConcurrentSource(fb, 1)
+        serial = Arrow.SourceFile(serialsource; tailbytes=1024, gapbytes=0)
+        results = Vector{Any}(undef, 2)
+        @sync for i = 1:2
+            Threads.@spawn results[i] =
+                Arrow.Table(serial; scan=Tables.Scan(select=(:a, :b)))
+        end
+        @test all(t -> t.a == 1:2000, results)
+        @test (@atomic serialsource.peak) == 1
+        @test (@atomic serialsource.preferencequeries) == 1
+
+        # Contract violations fail closed with ValidationError, never a
+        # wrong table or a stray error type.
+        for bad in (_ShortSource(fb), _LongSource(fb), _WrongTypeSource(fb))
+            @test_throws Arrow.AC.ValidationError Arrow.Table(
+                bad;
+                scan=Tables.Scan(select=(:a,)),
+            )
+        end
+        for reported in (
+            -1,
+            Int128(typemax(Int64)) + 1,
+            Int128(typemin(Int64)) - 1,
+            3402.0,
+            1.5,
+            "3402",
+            nothing,
+        )
+            @test_throws Arrow.AC.ValidationError Arrow.Table(_BadLengthSource(reported))
+        end
+        @test_throws ArgumentError Arrow.SourceFile(
+            _BytesSource(fb);
+            limits=Arrow.Limits(max_concurrent_reads=0),
+        )
+        for preference in (0, -1, Int128(typemax(Int)) + 1, 1.0, 1.5, "2", nothing)
+            @test_throws Arrow.AC.ValidationError Arrow.SourceFile(
+                _BadConcurrencySource(preference),
+            )
+        end
+    end
+
+    @testset "scan compilation bounds request amplification" begin
+        # Scalar conversion has fourteen closed descriptor/unit tokens.
+        nvalues = 100_000
+        temporal_cases = (
+            (
+                Arrow.AC.Field("d", Arrow.AC.DateType(Arrow.AC.DAY); nullable=false),
+                Any[Date(2024, 1, 1) for _ = 1:nvalues],
+                Int32(Dates.value(Date(2024, 1, 1)) - Dates.value(Date(1970, 1, 1))),
+            ),
+            (
+                Arrow.AC.Field(
+                    "d64",
+                    Arrow.AC.DateType(Arrow.AC.MILLISECOND_DATE);
+                    nullable=false,
+                ),
+                Any[Date(2024, 1, 1) for _ = 1:nvalues],
+                Int64(1_704_067_200_000),
+            ),
+            (
+                Arrow.AC.Field(
+                    "timestamp",
+                    Arrow.AC.TimestampType(Arrow.AC.SECOND, nothing);
+                    nullable=false,
+                ),
+                Any[DateTime(1970, 1, 1, 0, 0, 1) for _ = 1:nvalues],
+                Int64(1),
+            ),
+            (
+                Arrow.AC.Field(
+                    "time",
+                    Arrow.AC.TimeType(Arrow.AC.SECOND, 32);
+                    nullable=false,
+                ),
+                Any[Time(1) for _ = 1:nvalues],
+                Int64(3_600),
+            ),
+            (
+                Arrow.AC.Field(
+                    "duration",
+                    Arrow.AC.DurationType(Arrow.AC.NANOSECOND);
+                    nullable=false,
+                ),
+                Any[isodd(i) ? Second(1) : Millisecond(1_000) for i = 1:nvalues],
+                Int64(1_000_000_000),
+            ),
+        )
+        # Retained-schema column construction hoists the same token through a
+        # function barrier. Vector{Any} inputs allocate only the final column,
+        # not one dynamically dispatched scalar box per row.
+        retainedneeded = Arrow.AC._materializedvectorbytes(Union{Missing,Int64}, nvalues)
+        for (field, values, expected) in temporal_cases
+            Arrow._retainedstorage(field.type, values, "temporal")
+            @test _allocated(Arrow._retainedstorage, field.type, values, "temporal") <=
+                  retainedneeded
+            @test all(
+                ==(Int64(expected)),
+                Arrow._retainedstorage(field.type, values, "temporal"),
+            )
+        end
+
+        # An integer has no timestamp public representation.
+        timestampfield = Arrow.AC.Field(
+            "timestamp",
+            Arrow.AC.TimestampType(Arrow.AC.MICROSECOND, nothing);
+            nullable=false,
+        )
+        @test Arrow._exactfacadevalue(
+            Arrow._facadetoken(timestampfield.type),
+            _InterruptingInteger(),
+        ) === nothing
+    end
+
+    @testset "exact range-fetch worker budgets" begin
+        ranges = NTuple{2,Int64}[(0, 1), (2, 1), (4, 1), (6, 1)]
+        V(T, n) = Arrow.AC._materializedvectorbytes(T, n)
+        O(n) = Arrow.AC._materializedobjectbytes(n)
+        needed =
+            V(NTuple{2,Int64}, 4) +
+            4 * V(UInt8, 1) +
+            V(Vector{UInt8}, 4) +
+            2 * 4096 +
+            O(sizeof(Arrow._SpanQueue)) +
+            V(Arrow.AC.BufferSlice, 4) +
+            O(sizeof(Arrow.AC.ReleaseCell)) +
+            4 * O(sizeof(Arrow.AC.OwnerRegion)) +
+            2 * V(Int64, 4)
+        function fetch(cap)
+            source = _ConcurrentSource(collect(UInt8, 0:15), 8)
+            handle = Arrow.SourceFile(
+                source;
+                limits=Arrow.Limits(max_concurrent_reads=2),
+                gapbytes=0,
+            )
+            return Arrow._fetchspans(handle, ranges, 0; budget=Arrow.AllocationBudget(cap)),
+            source
+        end
+        spans, source = fetch(needed)
+        @test [Arrow.AC.slicebytes(slice) for slice in spans.slices] == [[0x00], [0x02], [0x04], [0x06]]
+        @test (@atomic source.issued) == 4
+        @test_throws Arrow.AllocationLimitError fetch(needed - 1)
+
+        prefix = V(NTuple{2,Int64}, 4) + 4 * V(UInt8, 1) + V(Vector{UInt8}, 4)
+        source = _ConcurrentSource(collect(UInt8, 0:15), 8)
+        handle = Arrow.SourceFile(
+            source;
+            limits=Arrow.Limits(max_concurrent_reads=2),
+            gapbytes=0,
+        )
+        err = try
+            Arrow._fetchspans(
+                handle,
+                ranges,
+                0;
+                budget=Arrow.AllocationBudget(prefix + 2 * 4096 - 1),
+            )
+            nothing
+        catch e
+            e
+        end
+        @test err isa Arrow.AllocationLimitError
+        @test occursin("range-fetch workers", sprint(showerror, err))
+        @test (@atomic source.issued) == 0
+    end
+
+    @testset "ranged scans share one allocation budget" begin
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            Tables.partitioner([
+                (x=Int64[1, 2, 3, 4], y=["a", "b", "c", "d"]),
+                (x=Int64[5, 6, 7, 8], y=["e", "f", "g", "h"]),
+            ]);
+            file=true,
+        )
+        bytes = take!(io)
+        scan = Tables.Scan(select=(:x,), filter=Tables.col(:x) > 2, offset=1, limit=2)
+        ranged(limits) = Arrow.Table(
+            Arrow.SourceFile(_BytesSource(bytes); limits=limits, tailbytes=64, gapbytes=0);
+            scan=scan,
+        )
+        @test ranged(Arrow.Limits()).x == [4, 5]
+        @test_throws Arrow.AllocationLimitError ranged(
+            Arrow.Limits(max_total_allocated_bytes=4096),
+        )
+    end
+
+    @testset "the allocation limit error" begin
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            Tables.partitioner([(x=Int64[1, 2],), (x=Int64[3, 4],)]);
+            file=false,
+        )
+        bytes = take!(io)
+        # The displayed error names the limit and how to raise it.
+        err = try
+            Arrow.Table(bytes; limits=Arrow.Limits(max_total_allocated_bytes=64))
+        catch e
+            e
+        end
+        @test err isa Arrow.AllocationLimitError
+        shown = sprint(showerror, err)
+        @test occursin(err.msg, shown)
+        @test occursin("limits=Arrow.Limits(max_allocation_ratio=", shown)
+        @test occursin("max_total_allocated_bytes=", shown)
+    end
+
+    @testset "mmap path and release!" begin
+        path = tempname()
+        try
+            Arrow.write(path, (x=collect(Int64, 1:10),))
+
+            # Before parsing succeeds, the path reader owns the map. A parse
+            # error must revoke it instead of leaving the source file locked.
+            region = Arrow.AC.mmapregion(path)
+            limits = Arrow.Limits(max_metadata_bytes=0)
+            @test_throws Arrow.AC.ValidationError Arrow._unmaponerror(region, true) do
+                return Arrow._readfile(
+                    region,
+                    limits,
+                    Arrow._readbudget(limits, region.len),
+                )
+            end
+            @test_throws InvalidStateException Arrow.AC.sliceptr(
+                Arrow.AC.BufferSlice(region, 0, 1),
+            )
+
+            t = Arrow.Table(path)   # mmap by default for ARROW1 files (not on Windows)
+            x = t.x
+            @test x == 1:10
+            Arrow.release!(t)
+            @test_throws InvalidStateException t.x
+            @test x == 1:10
+        finally
+            ispath(path) && rm(path)
+        end
+    end
+
+    @testset "substrings and generic vectors convert" begin
+        io = IOBuffer()
+        subs = split("alpha,beta,gamma", ",")
+        Arrow.write(io, (s=subs, r=1:3); file=false)
+        t = Arrow.Table(take!(io))
+        @test t.s == ["alpha", "beta", "gamma"]
+        @test t.r == [1, 2, 3]
+    end
+
+    @testset "structs of named tuples" begin
+        io = IOBuffer()
+        Arrow.write(io, (st=[(a=1, b="x"), (a=2, b="y")],); file=false)
+        t = Arrow.Table(take!(io))
+        @test t.st == [(a=1, b="x"), (a=2, b="y")]
+        @test eltype(t.st) == @NamedTuple{a::Int64, b::Arrow.DataStrings.DataString}
+
+        Row = @NamedTuple{a::Int64, b::Union{Missing,String}}
+        nullable = Union{Missing,Row}[(a=1, b="x"), missing, (a=3, b=missing)]
+        expected = Any[(a=1, b="x"), missing, (a=3, b=missing)]
+        for file in (false, true)
+            io = IOBuffer()
+            Arrow.write(io, (st=nullable,); file)
+            bytes = take!(io)
+            field =
+                only((file ? Arrow.readfile(bytes) : Arrow.readstream(bytes)).schema.fields)
+            @test field.type isa Arrow.AC.StructType
+            @test field.nullable
+            @test !field.children[1].nullable
+            @test field.children[2].nullable
+            @test isequal(Arrow.Table(bytes).st, expected)
+        end
+
+        parts = Tables.partitioner((
+            (st=Union{Missing,Row}[missing],),
+            (st=Union{Missing,Row}[(a=2, b="visible")],),
+        ))
+        io = IOBuffer()
+        Arrow.write(io, parts; file=false)
+        @test isequal(Arrow.Table(take!(io)).st, Any[missing, (a=2, b="visible")])
+    end
+
+    @testset "partition drift is refused, not misbound" begin
+        io = IOBuffer()
+        @test_throws ArgumentError Arrow.write(
+            io,
+            Tables.partitioner([
+                (left=Int64[1], right=Int64[10]),
+                (right=Int64[20], left=Int64[2]),
+            ]);
+            file=false,
+        )
+        @test_throws ArgumentError Arrow.write(
+            io,
+            Tables.partitioner([(x=Int64[1],), (y=Int64[2],)]);
+            file=false,
+        )
+        # The schema comes from the first partition: a later Int32 column
+        # widens into its int64 field; a Float64 column cannot.
+        @test_throws ArgumentError Arrow.write(
+            io,
+            Tables.partitioner([(x=Int64[1],), (x=Float64[2.5],)]);
+            file=false,
+        )
+        bytes = take!(
+            Arrow.write(
+                IOBuffer(),
+                Tables.partitioner([(x=Int64[1],), (x=Int32[2],)]);
+                file=false,
+            ),
+        )
+        @test isequal(Arrow.Table(bytes).x, [1, 2])
+        @test eltype(Arrow.Table(bytes).x) === Union{Missing,Int64}
+    end
+
+    @testset "schema is the authority for facade eltypes" begin
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            (s=Union{Missing,String}["a", "b"], m=Union{Missing,String}[missing, missing]);
+            file=false,
+        )
+        t = Arrow.Table(take!(io))
+        @test eltype(t.s) == Union{Missing,DataString}
+        @test eltype(t.m) == Union{Missing,DataString}
+        # all-missing columns round-trip as their DECLARED type
+        io2 = IOBuffer()
+        Arrow.write(io2, t; file=false)
+        t2 = Arrow.Table(take!(io2))
+        @test eltype(t2.m) == Union{Missing,DataString}
+        @test isequal(t2.m, [missing, missing])
+        # zero-row typed columns, including via a scan with no matches
+        io3 = IOBuffer()
+        Arrow.write(io3, (x=Int64[1],); file=false)
+        b3 = take!(io3)
+        t3 = Arrow.Table(b3; scan=Tables.Scan(filter=Tables.colcmp(==, Tables.col(:x), 99)))
+        @test eltype(t3.x) == Int64 && isempty(t3.x)
+    end
+
+    @testset "typed schemas keep rowtable working; wide schemas stay stored" begin
+        # At or below _MAX_TYPED_SCHEMA_FIELDS the schema is typed, so
+        # NamedTuple materializers accept it.
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            (a=Int64[1, 2, 3], b=Union{Missing,String}["x", missing, "z"]);
+            file=false,
+        )
+        t = Arrow.Table(take!(io))
+        sch = Tables.schema(t)
+        @test !(sch isa Tables.Schema{nothing,nothing})
+        @test sch.names == (:a, :b)
+        @test sch.types == (Int64, Union{Missing,DataString})
+        rows = Tables.rowtable(t)
+        @test rows isa Vector{NamedTuple{(:a, :b),Tuple{Int64,Union{Missing,DataString}}}}
+        @test [r.a for r in rows] == [1, 2, 3]
+        @test isequal([r.b for r in rows], ["x", missing, "z"])
+        # Above the threshold the schema keeps names and types in values so
+        # compiler work cannot scale with input names; Tables.jl then refuses
+        # NamedTuple rows, pinned here deliberately.
+        ncols = Arrow._MAX_TYPED_SCHEMA_FIELDS + 1
+        wide = NamedTuple(Symbol("w", i) => Int64[i] for i = 1:ncols)
+        wio = IOBuffer()
+        Arrow.write(wio, wide; file=false)
+        tw = Arrow.Table(take!(wio))
+        wsch = Tables.schema(tw)
+        @test wsch isa Tables.Schema{nothing,nothing}
+        @test length(wsch.names) == ncols
+        @test wsch.types == fill(Int64, ncols)
+        @test_throws ArgumentError Tables.rowtable(tw)
+        widerr = try
+            Tables.rowtable(tw)
+            nothing
+        catch exception
+            exception
+        end
+        @test occursin("input table too wide", sprint(showerror, widerr))
+    end
+
+    @testset "temporal scans agree across formats and renames" begin
+        data = (
+            x=Int64[1, 2, 3],
+            date=[Date(2024, 1, 1), Date(2024, 1, 2), Date(2024, 1, 3)],
+            stamp=[
+                DateTime(1970, 1, 1),
+                DateTime(1970, 1, 1, 0, 0, 2),
+                DateTime(2001, 9, 9),
+            ],
+        )
+        fio = IOBuffer()
+        Arrow.write(fio, data)
+        sio = IOBuffer()
+        Arrow.write(sio, data; file=false)
+        scan = Tables.Scan(filter=Tables.colcmp(==, Tables.col(:date), Date(2024, 1, 3)))
+        want = Tables.scan(data, scan)
+        for bytes in (take!(fio), take!(sio))
+            got = Arrow.Table(bytes; scan=scan)
+            @test got.x == want.x
+            @test got.date == want.date && eltype(got.date) <: Union{Missing,Date}
+            @test got.stamp == want.stamp
+        end
+        # renamed temporal output still converts
+        rio = IOBuffer()
+        Arrow.write(rio, data)
+        tr = Arrow.Table(take!(rio); scan=Tables.Scan(select=(:date => :d,), limit=1))
+        @test tr.d == [Date(2024, 1, 1)]
+    end
+
+    @testset "ranged reads carry the schema" begin
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            (stamp=[DateTime(2020, 5, 5)],);
+            metadata=Dict("origin" => "ranged"),
+        )
+        fb = take!(io)
+        src = _BytesSource(fb)
+        t = Arrow.Table(src)
+        @test t.stamp == [DateTime(2020, 5, 5)]
+        Tms = Durations.Timestamp{Millisecond}
+        @test eltype(t.stamp) == Union{Missing,Tms} || eltype(t.stamp) == Tms
+        @test DataAPI.metadata(t, "origin") == "ranged"
+    end
+
+    @testset "facade rewrite preserves the retained schema" begin
+        # Build exotic units through the core writer, then facade-read and
+        # facade-rewrite; the logical schema must not drift.
+        micros = Union{Missing,Int64}[1, 1001]
+        f, d = Arrow.AC.fromjulia("us", micros)
+        t_us = Arrow.AC.TimestampType(Arrow.AC.MICROSECOND, nothing)
+        d_us = Arrow.AC._arraydata(
+            t_us,
+            d.len,
+            d.buffers,
+            0,
+            Arrow.AC.ArrayData[],
+            nothing,
+            d.owner,
+            Arrow.AC.nullcount(d),
+        )
+        f_us = Arrow.AC.Field("us", t_us; nullable=true)
+        sch = Arrow.AC.Schema([f_us]; metadata=["k" => "v"])
+        bytes = Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d_us], 2)])
+        t = Arrow.Table(bytes)
+        # sub-ms is exact: the counts read back as Timestamp{Microsecond}
+        us = Durations.Timestamp{Dates.Microsecond}
+        @test isequal(t.us, reinterpret(us, Int64[1, 1001]))
+        io = IOBuffer()
+        Arrow.write(io, t; file=false)
+        rt = Arrow.Table(take!(io))
+        rsch = getfield(rt, :schema)
+        @test rsch.fields[1].type isa Arrow.AC.TimestampType
+        @test rsch.fields[1].type.unit == Arrow.AC.MICROSECOND
+        @test DataAPI.metadata(rt, "k") == "v"   # schema metadata carried
+        @test isequal(rt.us, reinterpret(us, Int64[1, 1001]))
+        # dictionary columns round-trip as dictionaries, multi-partition,
+        # file format (one shared pool, no replacement refusal)
+        io2 = IOBuffer()
+        Arrow.write(
+            io2,
+            Tables.partitioner([
+                (d=Arrow.DictEncode(["a", "b"]),),
+                (d=Arrow.DictEncode(["b", "c"]),),
+            ]);
+            file=true,
+        )
+        t2 = Arrow.Table(take!(io2))
+        @test t2.d == ["a", "b", "b", "c"]
+        sch2 = getfield(t2, :schema)
+        @test sch2.fields[1].type isa Arrow.AC.DictionaryType
+        io3 = IOBuffer()
+        Arrow.write(io3, t2; file=true)
+        t3 = Arrow.Table(take!(io3))
+        @test getfield(t3, :schema).fields[1].type isa Arrow.AC.DictionaryType
+        @test t3.d == ["a", "b", "b", "c"]
+    end
+
+    @testset "aliased extension columns rewrite" begin
+        # Selecting one column twice shares its retained child fields; the
+        # rewrite still needs one Field object per schema position.
+        io = IOBuffer()
+        Arrow.write(io, (u=[Base.UUID(UInt128(i)) for i = 1:3],))
+        t = Arrow.Table(take!(io); scan=Tables.Scan(select=(:u, :u => :v)))
+        out = IOBuffer()
+        Arrow.write(out, t)
+        back = Arrow.Table(take!(out))
+        @test back.u == back.v == t.u
+    end
+
+    @testset "zero-column row counts survive" begin
+        # A zero-column three-row batch built at the core level: the facade
+        # read must preserve the count, and a facade round-trip must carry
+        # it back out (Table knows its row count even with no columns).
+        sch = Arrow.AC.Schema(Arrow.AC.Field[])
+        bytes = Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 3)])
+        t = Arrow.Table(bytes)
+        @test Tables.rowcount(t) == 3
+        @test isempty(Tables.columnnames(t))
+        io = IOBuffer()
+        Arrow.write(io, t; file=false)
+        t2 = Arrow.Table(take!(io))
+        @test Tables.rowcount(t2) == 3
+        @test length(t2) == 0
+        @test isempty(collect(t2))
+    end
+
+    @testset "a single-batch primitive column is materialized once" begin
+        # One 8 MB output vector, not a second public copy of it.
+        bytes = Arrow.tobuffer((a=collect(Int64, 1:1_000_000),)) |> take!
+        @test _tableallocs(bytes) < 12_000_000
+        nb =
+            Arrow.tobuffer((
+                a=Union{Missing,Float64}[isodd(i) ? missing : 1.0 for i = 1:1_000_000],
+            )) |> take!
+        # Julia 1.10 boxes in the per-element null punch, a separate cost.
+        VERSION >= v"1.12" && @test _tableallocs(nb) < 14_000_000
+        # An uncompressed write stages the 8 MB column in the message body,
+        # the batch message, and the output buffer, and no more often.
+        path = tempname()
+        try
+            @test _writeallocs(path, (a=collect(Int64, 1:1_000_000),)) < 30_000_000
+        finally
+            rm(path; force=true)
+        end
+    end
+
+    @testset "Table iterates its columns like other Tables.AbstractColumns" begin
+        # length counts columns, so iteration, values, and end indexing see
+        # every column exactly once whatever the row count.
+        t = Arrow.Table(Arrow.tobuffer((a=Int64[1, 2, 3, 4], b=["w", "x", "y", "z"])))
+        @test length(t) == 2
+        @test Tables.rowcount(t) == 4
+        @test collect(t) == [[1, 2, 3, 4], ["w", "x", "y", "z"]]
+        @test values(t) == collect(t)
+        @test t[end] == ["w", "x", "y", "z"]
+        wide = Arrow.Table(Arrow.tobuffer((a=Int64[1], b=["x"], c=[1.5])))
+        @test length(collect(wide)) == 3
+        @test [c[1] for c in wide] == Any[1, "x", 1.5]
+        empty = Arrow.Table(Arrow.tobuffer((a=Int64[],)))
+        @test length(empty) == 1
+        @test !isempty(empty)
+        @test Tables.rowcount(empty) == 0
+    end
+
+    @testset "DataAPI defaults and selectors" begin
+        io = IOBuffer()
+        Arrow.write(io, (x=Int64[1],); file=false, colmetadata=Dict(:x => Dict("u" => "1")))
+        t = Arrow.Table(take!(io))
+        @test DataAPI.metadata(t, "absent", "fallback") == "fallback"
+        @test DataAPI.colmetadata(t, 1, "u") == "1"
+        @test DataAPI.colmetadata(t, :x, "nope", :d) == :d
+        @test collect(first.(DataAPI.colmetadatakeys(t))) == [:x]
+
+        # Listing every column's metadata (what DataFrame(table) does) is
+        # linear in the column count, not quadratic.
+        n = 3000
+        wide = NamedTuple(Symbol("w", i) => Int64[i] for i = 1:n)
+        meta = Dict(Symbol("w", i) => ["k" => string(i)] for i = 1:10:n)
+        wio = IOBuffer()
+        Arrow.write(wio, wide; file=false, colmetadata=meta)
+        tw = Arrow.Table(take!(wio))
+        listed = collect(DataAPI.colmetadatakeys(tw))
+        @test length(listed) == length(meta)
+        @test DataAPI.colmetadata(tw, :w2991, "k") == "2991"
+        @test minimum(@elapsed(collect(DataAPI.colmetadatakeys(tw))) for _ = 1:3) < 0.2
+    end
+
+    @testset "temporal scans preserve cross-type predicate semantics" begin
+        data = (
+            x=Int64[1, 2, 3],
+            d32=[Date(1970, 1, 1), Date(1970, 1, 2), Date(1970, 1, 3)],
+            ts=[DateTime(2020, 1, 1), DateTime(2020, 1, 2), DateTime(2020, 1, 3)],
+        )
+        fio = IOBuffer()
+        Arrow.write(fio, data; file=true)
+        fb = take!(fio)
+        sio = IOBuffer()
+        Arrow.write(sio, data; file=false)
+        sb = take!(sio)
+        cases = [
+            # Date32 vs midnight DateTime: cross-type equality holds
+            Tables.Scan(
+                select=(:x,),
+                filter=Tables.colcmp(==, Tables.col(:d32), DateTime(1970, 1, 2)),
+            ),
+            # Timestamp vs Date
+            Tables.Scan(
+                select=(:x,),
+                filter=Tables.colcmp(==, Tables.col(:ts), Date(2020, 1, 2)),
+            ),
+            # non-midnight DateTime vs Date32: no exact representation
+            Tables.Scan(
+                select=(:x,),
+                filter=Tables.colcmp(==, Tables.col(:d32), DateTime(1970, 1, 2, 12)),
+            ),
+        ]
+        for scan in cases
+            want = Tables.scan(data, scan)
+            for bytes in (fb, sb)
+                got = Arrow.Table(bytes; scan=scan)
+                @test isequal(got.x, want.x)
+            end
+        end
+        # A raw integer for a temporal column is refused when the scan binds,
+        # as any literal of another kind than its column is.
+        rawint = Tables.Scan(select=(:x,), filter=Tables.colcmp(==, Tables.col(:d32), 1))
+        for bytes in (fb, sb)
+            @test_throws ArgumentError Arrow.Table(bytes; scan=rawint)
+        end
+        # Zone-free time literals against zone-free timestamps of every unit,
+        # whether or not the literal is exact in the column's unit or range.
+        t0 = DateTime(2020, 1, 2)
+        literals = (
+            t0,
+            t0 + Millisecond(500),
+            Date(2020, 1, 2),
+            Durations.Timestamp{Nanosecond}(t0) + Nanosecond(7),
+            DateTime(1500, 1, 1),
+        )
+        for P in (Second, Millisecond, Microsecond, Nanosecond)
+            tsdata = (ts=[Durations.Timestamp{P}(t0 + Second(k)) for k = -1:1],)
+            io = IOBuffer()
+            Arrow.write(io, tsdata; file=true)
+            bytes = take!(io)
+            for literal in literals, op in (==, !=, <, <=, >, >=)
+                scan = Tables.Scan(filter=Tables.colcmp(op, Tables.col(:ts), literal))
+                got = Arrow.Table(bytes; scan=scan).ts
+                @test isequal(collect(got), Tables.scan(tsdata, scan).ts)
+            end
+        end
+    end
+
+    @testset "temporal pushdown preserves the complete public domain" begin
+        function rawtemporal(t, values)
+            data = Arrow.AC.ArrayData(
+                t,
+                length(values),
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(values)];
+                nullcount=0,
+            )
+            field = Arrow.AC.Field("v", t; nullable=false)
+            schema = Arrow.AC.Schema([field])
+            batch = Arrow.AC.RecordBatch(schema, [data], length(values))
+            return field, Arrow.writefile(schema, [batch])
+        end
+        function assertmatches(bytes, scan)
+            full = Arrow.Table(copy(bytes))
+            want = Tables.scan(full, scan)
+            got = Arrow.Table(copy(bytes); scan=scan)
+            @test isequal(got.v, Tables.getcolumn(Tables.columns(want), :v))
+            @test Tables.rowcount(got) == Tables.rowcount(Tables.columns(want))
+        end
+
+        # A stored time of day outside [0, 24h) has no exact Dates.Time (which
+        # wraps modulo 24 hours), so reads, filtered or not, refuse it instead
+        # of aliasing it onto another time.
+        let (type, values, literal) =
+                (Arrow.AC.TimeType(Arrow.AC.SECOND, 32), Int32[0, 86_399], Time(0))
+            field, bytes = rawtemporal(type, values)
+            for scan in (
+                Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), literal)),
+                Tables.Scan(filter=Tables.colin(Tables.col(:v), (literal,))),
+            )
+                assertmatches(bytes, scan)
+                @test Tables.rowcount(Arrow.Table(copy(bytes); scan=scan)) == 1
+            end
+        end
+        for (type, values) in (
+            (Arrow.AC.TimeType(Arrow.AC.SECOND, 32), Int32[0, 86_400]),
+            (Arrow.AC.TimeType(Arrow.AC.MILLISECOND, 32), Int32[-1, 0]),
+            (Arrow.AC.TimeType(Arrow.AC.MICROSECOND, 64), Int64[0, typemax(Int64)]),
+            (Arrow.AC.TimeType(Arrow.AC.NANOSECOND, 64), Int64[86_400 * 10 ^ 9, 0]),
+        )
+            field, bytes = rawtemporal(type, values)
+            @test_throws Arrow.ValidationError Arrow.Table(copy(bytes))
+            scan = Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), Time(0)))
+            @test_throws Arrow.ValidationError Arrow.Table(copy(bytes); scan=scan)
+        end
+
+        # Every Timestamp{Second} count is a distinct public value, so an
+        # extreme count does not alias the epoch: equality matches one row.
+        let field_bytes = rawtemporal(
+                Arrow.AC.TimestampType(Arrow.AC.SECOND, nothing),
+                Int64[0, Int64(1) << 61],
+            )
+            field, bytes = field_bytes
+            for scan in (
+                Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), DateTime(1970, 1, 1))),
+                Tables.Scan(filter=Tables.colin(Tables.col(:v), (DateTime(1970, 1, 1),))),
+            )
+                assertmatches(bytes, scan)
+                @test Tables.rowcount(Arrow.Table(copy(bytes); scan=scan)) == 1
+            end
+        end
+
+        # Extreme Date64 and millisecond TIMESTAMP counts compare as their
+        # public values do, ordered comparisons included.
+        let field_bytes = rawtemporal(
+                Arrow.AC.DateType(Arrow.AC.MILLISECOND_DATE),
+                Int64[typemax(Int64), 0],
+            )
+            field, bytes = field_bytes
+            eqscan =
+                Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), DateTime(1970, 1, 1)))
+            assertmatches(bytes, eqscan)
+            ordered =
+                Tables.Scan(filter=Tables.colcmp(<, Tables.col(:v), DateTime(1970, 1, 1)))
+            assertmatches(bytes, ordered)
+        end
+        let field_bytes = rawtemporal(
+                Arrow.AC.TimestampType(Arrow.AC.MILLISECOND, nothing),
+                Int64[typemax(Int64), 0],
+            )
+            field, bytes = field_bytes
+            for op in (==, <)
+                scan = Tables.Scan(
+                    filter=Tables.colcmp(op, Tables.col(:v), DateTime(1970, 1, 1)),
+                )
+                assertmatches(bytes, scan)
+            end
+        end
+
+        # Duration literals coarser and finer than the column's unit compare
+        # as public values do; a finer one can overflow while Julia promotes
+        # a stored value, in a scan as in the generic executor.
+        duration = Arrow.AC.DurationType(Arrow.AC.SECOND)
+        field, bytes = rawtemporal(duration, Int64[60])
+        coarse = Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), Minute(1)))
+        assertmatches(bytes, coarse)
+        coarsein = Tables.Scan(filter=Tables.colin(Tables.col(:v), (Minute(1),)))
+        assertmatches(bytes, coarsein)
+        finer = Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), Millisecond(60_000)))
+        assertmatches(bytes, finer)
+        finerin = Tables.Scan(filter=Tables.colin(Tables.col(:v), (Millisecond(60_000),)))
+        assertmatches(bytes, finerin)
+
+        field, bytes = rawtemporal(duration, Int64[typemin(Int64)])
+        overflow =
+            Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), Millisecond(-1_000_000)))
+        @test_throws InexactError Tables.scan(Arrow.Table(copy(bytes)), overflow)
+        @test_throws InexactError Arrow.Table(copy(bytes); scan=overflow)
+
+        # Scan planning must never execute a permissive conversion hook. An
+        # integer literal has no timestamp public representation: binding
+        # refuses it without consulting the hook.
+        field, bytes =
+            rawtemporal(Arrow.AC.TimestampType(Arrow.AC.MICROSECOND, nothing), Int64[7])
+        literal = _ScanHookInteger()
+        hookscan = Tables.Scan(filter=Tables.colcmp(==, Tables.col(:v), literal))
+        _SCAN_HOOK_CALLS[] = 0
+        @test_throws ArgumentError Arrow._ScanPlan(hookscan, [field])
+        @test_throws ArgumentError Arrow.Table(copy(bytes); scan=hookscan)
+        @test _SCAN_HOOK_CALLS[] == 0
+    end
+
+    @testset "retained rewrite is schema identity" begin
+        # Non-nullable temporal descriptors stay non-nullable; Date64 works.
+        vals = Int64[0, 86_400_000]
+        t64 = Arrow.AC.DateType(Arrow.AC.MILLISECOND_DATE)
+        d64 = Arrow.AC._arraydata(
+            t64,
+            2,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(vals)],
+            0,
+            Arrow.AC.ArrayData[],
+            nothing,
+            nothing,
+            0,
+        )
+        fld = Arrow.AC.Field("d", t64; nullable=false)
+        sch = Arrow.AC.Schema([fld])
+        bytes = Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d64], 2)])
+        t = Arrow.Table(bytes)
+        @test t.d == [DateTime(1970, 1, 1), DateTime(1970, 1, 2)]
+        io = IOBuffer()
+        Arrow.write(io, t; file=false)
+        rt = getfield(Arrow.Table(take!(io)), :schema)
+        @test rt.fields[1].type isa Arrow.AC.DateType
+        @test rt.fields[1].type.unit == Arrow.AC.MILLISECOND_DATE
+        @test rt.fields[1].nullable == false
+        # Retained dictionary identity: index width and ordered survive.
+        pool = ["a", "b"]
+        pf, pd = Arrow.AC.fromjulia("d", pool)
+        dt = Arrow.AC.DictionaryType(Arrow.AC.IntType(8, true), pf.type, true)
+        idx = Int8[0, 1, 0]
+        dd = Arrow.AC.ArrayData(
+            dt,
+            3,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(idx)];
+            dictionary=pd,
+            nullcount=0,
+        )
+        df = Arrow.AC.Field("d", dt; nullable=false)
+        dsch = Arrow.AC.Schema([df])
+        dbytes = Arrow.writestream(dsch, [Arrow.AC.RecordBatch(dsch, [dd], 3)])
+        dt2 = Arrow.Table(dbytes)
+        io2 = IOBuffer()
+        Arrow.write(io2, dt2; file=false)
+        rsch = getfield(Arrow.Table(take!(io2)), :schema)
+        rdt = rsch.fields[1].type
+        @test rdt isa Arrow.AC.DictionaryType
+        @test rdt.indextype.bits == 8 && rdt.ordered == true
+        @test rsch.fields[1].nullable == false
+    end
+
+    @testset "replaced facade columns are refused" begin
+        io = IOBuffer()
+        Arrow.write(io, (d=[Date(2024, 1, 1)], p=Arrow.DictEncode(["x"])))
+        t = Arrow.Table(take!(io))
+        broken = Arrow.Table(
+            getfield(t, :names),
+            AbstractVector[Int64[100], Int64[7]],
+            getfield(t, :lookup),
+            getfield(t, :schema),
+            Arrow.AC.OwnerRegion[],
+            1,
+        )
+        io2 = IOBuffer()
+        @test_throws ArgumentError Arrow.write(io2, broken; file=false)
+    end
+
+    @testset "type overrides and renamed schemas" begin
+        io = IOBuffer()
+        Arrow.write(
+            io,
+            (x=Union{Missing,Int64}[1, missing], d=[Date(2024, 1, 1), Date(2024, 1, 2)]),
+        )
+        fb = take!(io)
+        t = Arrow.Table(
+            fb;
+            scan=Tables.Scan(select=(:x => Union{Missing,Float64}, :d => Date)),
+        )
+        @test isequal(t.x, Union{Missing,Float64}[1.0, missing])
+        @test t.d == [Date(2024, 1, 1), Date(2024, 1, 2)]
+        # a renamed output binds ITS OWN field in the stored schema
+        tr = Arrow.Table(fb; scan=Tables.Scan(select=(:d => :when,)))
+        rsch = getfield(tr, :schema)
+        @test length(rsch.fields) == 1
+        @test rsch.fields[1].name == "when"
+        @test rsch.fields[1].type isa Arrow.AC.DateType
+        io3 = IOBuffer()
+        Arrow.write(io3, tr; file=false)
+        back = getfield(Arrow.Table(take!(io3)), :schema)
+        @test back.fields[1].type isa Arrow.AC.DateType
+    end
+
+    @testset "empty projections keep row counts" begin
+        io = IOBuffer()
+        Arrow.write(io, (x=collect(Int64, 1:5),); file=false)
+        t = Arrow.Table(take!(io); scan=Tables.Scan(select=(), filter=Tables.col(:x) > 2))
+        @test isempty(Tables.columnnames(t))
+        @test Tables.rowcount(t) == 3
+    end
+
+    @testset "DataAPI missing columns are errors" begin
+        io = IOBuffer()
+        Arrow.write(io, (x=Int64[1],); file=false)
+        t = Arrow.Table(take!(io))
+        @test_throws ArgumentError DataAPI.colmetadatakeys(t, :nope)
+        @test_throws ArgumentError DataAPI.colmetadata(t, :nope, "k")
+    end
+
+    @testset "lowering honors the facade comparison domain" begin
+        # Sub-ms timestamps materialize as Timestamp{Microsecond}: a DateTime
+        # literal compares by instant, and a raw integer is refused.
+        us = Union{Missing,Int64}[1_000_000, 2_000_000]
+        f, d = Arrow.AC.fromjulia("us", us)
+        t_us = Arrow.AC.TimestampType(Arrow.AC.MICROSECOND, nothing)
+        d_us = Arrow.AC._arraydata(
+            t_us,
+            2,
+            d.buffers,
+            0,
+            Arrow.AC.ArrayData[],
+            nothing,
+            nothing,
+            0,
+        )
+        sch = Arrow.AC.Schema([Arrow.AC.Field("us", t_us; nullable=true)])
+        bytes = Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d_us], 2)])
+        data = (
+            us=Union{Missing,Durations.Timestamp{Microsecond}}[
+                reinterpret(Durations.Timestamp{Microsecond}, x) for
+                x in Int64[1_000_000, 2_000_000]
+            ],
+        )
+        scan = Tables.Scan(
+            filter=Tables.colcmp(==, Tables.col(:us), DateTime(1970, 1, 1, 0, 0, 1)),
+        )
+        got = Arrow.Table(bytes; scan=scan)
+        @test isequal(got.us, Tables.scan(data, scan).us)
+        @test length(got.us) == 1
+        @test_throws ArgumentError Arrow.Table(
+            bytes;
+            scan=Tables.Scan(filter=Tables.colcmp(==, Tables.col(:us), 2_000_000)),
+        )
+        # Out-of-range and cross-Period literals fall back, matching the
+        # authority instead of throwing.
+        pdata = (d=[Date(2024, 1, 1)], s=[Second(30)])
+        io = IOBuffer()
+        Arrow.write(io, pdata)
+        pb = take!(io)
+        for scan in (
+            Tables.Scan(filter=Tables.colcmp(==, Tables.col(:d), Date(6_000_000, 1, 1))),
+            Tables.Scan(filter=Tables.colcmp(==, Tables.col(:s), Month(1))),
+        )
+            want = Tables.scan(pdata, scan)
+            got = Arrow.Table(pb; scan=scan)
+            @test Tables.rowcount(got) == Tables.rowcount(Tables.columns(want))
+        end
+
+        # Exact-conversion failures select the public-domain fallback. Process
+        # control and resource failures must still escape immediately.
+        ok, original = Arrow._facadetostorage(t_us, big(typemax(Int64)) + 1)
+        @test !ok
+        @test original == big(typemax(Int64)) + 1
+        # Epoch subtraction must reject, not wrap, a DateTime whose exact
+        # storage delta falls below Int64.
+        extreme = DateTime(Dates.UTM(typemin(Int64)))
+        for t in (
+            Arrow.AC.DateType(Arrow.AC.MILLISECOND_DATE),
+            Arrow.AC.TimestampType(Arrow.AC.MILLISECOND, nothing),
+        )
+            ok, original = Arrow._facadetostorage(t, extreme)
+            @test !ok
+            @test original === extreme
+        end
+        dur_s = Arrow.AC.DurationType(Arrow.AC.SECOND)
+        @test_throws InterruptException Arrow._facadetostorage(dur_s, _InterruptingPeriod())
+        @test_throws OutOfMemoryError Arrow._facadetostorage(dur_s, _OutOfMemoryPeriod())
+    end
+
+    @testset "native Timestamp and ZonedTimestamp columns" begin
+        Ts = Durations.Timestamp
+        Zts = Durations.ZonedTimestamp
+        Denver = Zts{Microsecond,Symbol("America/Denver")}
+
+        # Every zone-naive unit reads as Timestamp{P}; a written DateTime
+        # column reads back as Timestamp{Millisecond} with equal instants.
+        for (P, unit) in (
+            (Second, Arrow.AC.SECOND),
+            (Millisecond, Arrow.AC.MILLISECOND),
+            (Microsecond, Arrow.AC.MICROSECOND),
+            (Nanosecond, Arrow.AC.NANOSECOND),
+        )
+            col = [Ts{P}(2026, 1, 1), Ts{P}(2026, 1, 2)]
+            tp = Arrow.Table(take!(Arrow.tobuffer((c=col,))))
+            @test getfield(tp, :schema).fields[1].type ==
+                  Arrow.AC.TimestampType(unit, nothing)
+            @test eltype(tp.c) == Ts{P} && tp.c == col
+        end
+        dts = [DateTime(2026, 1, 1), DateTime(2026, 1, 2)]
+        tdt = Arrow.Table(take!(Arrow.tobuffer((c=dts,))))
+        @test eltype(tdt.c) == Ts{Millisecond}
+        @test tdt.c == dts && tdt.c == Ts{Millisecond}.(dts)
+
+        # Fresh writes round-trip zero-conversion at each resolution, with
+        # and without missing; the descriptor carries the unit and zone.
+        ncol = [Ts{Nanosecond}(2026, 1, 1), Ts{Nanosecond}(2026, 1, 2)]
+        zcol = [Denver(Ts{Microsecond}(2026, 1, i), Dates.UTC) for i = 1:4]
+        bytes = take!(Arrow.tobuffer((n=ncol, z=zcol[1:2], mz=[zcol[3], missing])))
+        t = Arrow.Table(copy(bytes))
+        sch = getfield(t, :schema)
+        @test sch.fields[1].type == Arrow.AC.TimestampType(Arrow.AC.NANOSECOND, nothing)
+        @test sch.fields[2].type ==
+              Arrow.AC.TimestampType(Arrow.AC.MICROSECOND, "America/Denver")
+        @test eltype(t.n) == Ts{Nanosecond} && t.n == ncol
+        @test eltype(t.z) == Denver && t.z == zcol[1:2]
+        @test eltype(t.mz) == Union{Missing,Denver}
+        @test isequal(collect(t.mz), [zcol[3], missing])
+        # retained rewrite keeps unit, zone, and values
+        rt = Arrow.Table(take!(Arrow.tobuffer(Arrow.Table(copy(bytes)))))
+        @test eltype(rt.z) == Denver && rt.z == zcol[1:2] && rt.n == ncol
+
+        # One column, one zone and one resolution: abstract eltypes refuse.
+        mixed = [zcol[1], Durations.astimezone(zcol[2], :UTC)]
+        @test_throws ArgumentError Arrow.tobuffer((m=mixed,))
+        # mixed naive resolutions PROMOTE to the finer unit and write cleanly
+        units = [Ts{Nanosecond}(2026, 1, 1), Ts{Microsecond}(2026, 1, 2)]
+        @test eltype(units) == Ts{Nanosecond}
+        tu = Arrow.Table(take!(Arrow.tobuffer((u=units,))))
+        @test eltype(tu.u) == Ts{Nanosecond} && tu.u == units
+        # a declared-abstract column writes as its values' one resolution; a
+        # non-Arrow resolution refuses
+        ta = Arrow.Table(take!(Arrow.tobuffer((u=Ts[Ts{Nanosecond}(2026)],))))
+        @test eltype(ta.u) == Ts{Nanosecond}
+        @test_throws ArgumentError Arrow._instantunit(Ts{Dates.Minute})
+
+        # Zoned scans push down every operator; literals convert exactly
+        # across zones and units. Zone-free literals refuse on this zone
+        # (only UTC takes them), and a raw count matches nothing.
+        zbytes = take!(Arrow.tobuffer((z=zcol,)))
+        zfield = getfield(Arrow.Table(copy(zbytes)), :schema).fields[1]
+        for (filter, want) in (
+            (Tables.colcmp(>, Tables.col(:z), zcol[2]), zcol[3:4]),
+            (
+                Tables.colcmp(==, Tables.col(:z), Durations.astimezone(zcol[2], :UTC)),
+                zcol[2:2],
+            ),
+            (
+                Tables.colcmp(
+                    <=,
+                    Tables.col(:z),
+                    Zts{Nanosecond,:UTC}(Ts{Nanosecond}(zcol[2].utc), Dates.UTC),
+                ),
+                zcol[1:2],
+            ),
+        )
+            scan = Tables.Scan(; filter)
+            @test collect(Arrow.Table(copy(zbytes); scan).z) == want
+        end
+        for naive in (DateTime(2026, 1, 2), Ts{Microsecond}(2026, 1, 2))
+            scan = Tables.Scan(filter=Tables.colcmp(==, Tables.col(:z), naive))
+            @test_throws ArgumentError Arrow.Table(copy(zbytes); scan)
+        end
+        # A raw integer, or a zoned literal against a zone-naive column, is
+        # refused when the scan binds.
+        rawscan =
+            Tables.Scan(filter=Tables.colcmp(==, Tables.col(:z), Dates.value(zcol[2])))
+        @test_throws ArgumentError Arrow._ScanPlan(rawscan, [zfield])
+        @test_throws ArgumentError Arrow.Table(copy(zbytes); scan=rawscan)
+        nbytes = take!(Arrow.tobuffer((n=ncol,)))
+        nscan = Tables.Scan(filter=Tables.colcmp(==, Tables.col(:n), zcol[1]))
+        @test_throws ArgumentError Arrow.Table(copy(nbytes); scan=nscan)
+        # a nanosecond zoned literal that truncates on a microsecond column
+        # has no exact storage form; public evaluation still answers exactly
+        sub = Zts{Nanosecond,:UTC}(Ts{Nanosecond}(zcol[2].utc) + Nanosecond(1), Dates.UTC)
+        subscan = Tables.Scan(filter=Tables.colcmp(<, Tables.col(:z), sub))
+        @test collect(Arrow.Table(copy(zbytes); scan=subscan).z) == zcol[1:2]
+
+        # The Arrow spec reads an EMPTY timezone string as zone-naive.
+        et = Arrow.AC.TimestampType(Arrow.AC.NANOSECOND, "")
+        ed = Arrow.AC.ArrayData(
+            et,
+            1,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[7])];
+            nullcount=0,
+        )
+        esch = Arrow.AC.Schema([Arrow.AC.Field("e", et; nullable=false)])
+        etbl = Arrow.Table(Arrow.writefile(esch, [Arrow.AC.RecordBatch(esch, [ed])]))
+        @test eltype(etbl.e) == Ts{Nanosecond}
+        @test Dates.value(etbl.e[1]) == 7
+
+        # Empty columns declare the same eltype as populated ones.
+        ebytes = take!(Arrow.tobuffer((n=Ts{Nanosecond}[], z=Denver[])))
+        et2 = Arrow.Table(ebytes)
+        @test eltype(et2.n) == Ts{Nanosecond} && isempty(et2.n)
+        @test eltype(et2.z) == Denver && isempty(et2.z)
+    end
+
+    @testset "leaf conversion authorities agree" begin
+        # `_publicleafscalar` (dynamic rows) and `_postconvert` (whole
+        # columns) must convert identically for every convertible leaf.
+        AC2 = Arrow.AC
+        cases = Any[
+            (AC2.DateType(AC2.DAY), Int32[0, 19000]),
+            (AC2.DateType(AC2.MILLISECOND_DATE), Int64[0, 86_400_000]),
+            (AC2.TimeType(AC2.SECOND, 32), Int32[0, 86_399]),
+            (AC2.TimeType(AC2.NANOSECOND, 64), Int64[0, 1]),
+            (AC2.DurationType(AC2.MICROSECOND), Int64[-5, 7]),
+            (AC2.IntervalType(AC2.YEAR_MONTH), Int32[3, -2]),
+            (
+                AC2.IntervalType(AC2.MONTH_DAY_NANO),
+                [(months=Int32(1), days=Int32(2), nanos=Int64(3))],
+            ),
+            (AC2.DecimalType(10, 2, 64), Int64[12345, -7]),
+            (AC2.TimestampType(AC2.SECOND, nothing), Int64[0, 42]),
+            (AC2.TimestampType(AC2.NANOSECOND, nothing), Int64[typemin(Int64), 9]),
+            (AC2.TimestampType(AC2.MICROSECOND, "America/Denver"), Int64[0, -1]),
+            (AC2.TimestampType(AC2.MILLISECOND, "+07:00"), Int64[5]),
+        ]
+        for (t, xs) in cases
+            converted = Arrow._postconvert(t, collect(xs))
+            for (x, c) in zip(xs, converted)
+                s = Arrow._publicleafscalar(t, x)
+                @test s === c || isequal(s, c) && typeof(s) === typeof(c)
+            end
+            @test Arrow._isconvertibleleaf(t)
+        end
+        @test !Arrow._isconvertibleleaf(Arrow.AC.IntType(64, true))
+        @test !Arrow._isconvertibleleaf(Arrow.AC.Utf8Type(false))
+    end
+
+    @testset "overrides preserve missing and re-infer on rewrite" begin
+        io = IOBuffer()
+        Arrow.write(io, (x=Union{Missing,Int64}[1, missing],))
+        fb = take!(io)
+        t = Arrow.Table(fb; scan=Tables.Scan(select=(:x => Float64,)))
+        @test isequal(t.x, Union{Missing,Float64}[1.0, missing])
+        # rewrite after an override re-infers the column cleanly
+        io2 = IOBuffer()
+        Arrow.write(io2, t; file=false)
+        t2 = Arrow.Table(take!(io2))
+        @test isequal(t2.x, Union{Missing,Float64}[1.0, missing])
+        @test getfield(t2, :schema).fields[1].type isa Arrow.AC.FloatType
+    end
+
+    @testset "zero-field counts across all paths" begin
+        sch = Arrow.AC.Schema(Arrow.AC.Field[])
+        bytes = Arrow.writefile(sch, [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 3)])
+        for source in (bytes, _BytesSource(bytes))
+            t = Arrow.Table(source; scan=Tables.Scan())
+            @test Tables.rowcount(t) == 3
+            tw = Arrow.Table(source; scan=Tables.Scan(limit=1, offset=1))
+            @test Tables.rowcount(tw) == 1
+        end
+    end
+
+    @testset "override subsumption is a no-op; zero-field filters count" begin
+        io = IOBuffer()
+        Arrow.write(io, (x=Union{Missing,Int64}[1, 2], s=Union{Missing,String}["a", "b"]))
+        fb = take!(io)
+        # nullable source, no observed missing: supertype/no-op overrides
+        # keep the DECLARED element type, exactly like Tables.scan.
+        t = Arrow.Table(fb; scan=Tables.Scan(select=(:x => Int64, :s => AbstractString)))
+        @test eltype(t.x) == Union{Missing,Int64}
+        @test eltype(t.s) == Union{Missing,DataString}
+        io2 = IOBuffer()
+        Arrow.write(io2, t; file=false)   # rewrites cleanly, metadata intact
+        @test isequal(Arrow.Table(take!(io2)).x, [1, 2])
+        # zero-field: filters and validation apply
+        sch = Arrow.AC.Schema(Arrow.AC.Field[])
+        zb = Arrow.writefile(sch, [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 3)])
+        tz = Arrow.Table(
+            zb;
+            scan=Tables.Scan(
+                filter=Tables.colcmp(==, Tables.col(:nope), 1),
+                validate=false,
+            ),
+        )
+        @test Tables.rowcount(tz) == 0
+        @test_throws ArgumentError Arrow.Table(
+            zb;
+            scan=Tables.Scan(filter=Tables.colcmp(==, Tables.col(:nope), 1)),
+        )
+        # ranged zero-field honors SourceFile limits
+        rfz = Arrow.SourceFile(_BytesSource(zb); limits=Arrow.Limits(max_array_length=2))
+        @test_throws Arrow.AC.ValidationError Arrow.Table(rfz)
+    end
+
+    @testset "replaced columns are refused before value access" begin
+        io = IOBuffer()
+        Arrow.write(io, (n=Int64[1], s=["x"], p=Arrow.DictEncode(["x"])))
+        t = Arrow.Table(take!(io))
+        for (col, bad) in ((:n, ["oops"]), (:s, Int64[1]), (:p, Int64[7]))
+            cols = AbstractVector[c for c in getfield(t, :columns)]
+            cols[getfield(t, :lookup)[col]] = bad
+            broken = Arrow.Table(
+                getfield(t, :names),
+                cols,
+                getfield(t, :lookup),
+                getfield(t, :schema),
+                Arrow.AC.OwnerRegion[],
+                1,
+            )
+            io2 = IOBuffer()
+            @test_throws ArgumentError Arrow.write(io2, broken; file=false)
+        end
+        # missing into a non-nullable retained dictionary is refused
+        pool = ["a"]
+        pf, pd = Arrow.AC.fromjulia("d", pool)
+        dt = Arrow.AC.DictionaryType(Arrow.AC.IntType(32, true), pf.type, false)
+        dd = Arrow.AC.ArrayData(
+            dt,
+            1,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int32[0])];
+            dictionary=pd,
+            nullcount=0,
+        )
+        df = Arrow.AC.Field("d", dt; nullable=false)
+        dsch = Arrow.AC.Schema([df])
+        dbytes = Arrow.writestream(dsch, [Arrow.AC.RecordBatch(dsch, [dd], 1)])
+        td = Arrow.Table(dbytes)
+        cols = AbstractVector[Union{Missing,String}[missing]]
+        brokend = Arrow.Table(
+            getfield(td, :names),
+            cols,
+            getfield(td, :lookup),
+            getfield(td, :schema),
+            Arrow.AC.OwnerRegion[],
+            1,
+        )
+        io3 = IOBuffer()
+        @test_throws ArgumentError Arrow.write(io3, brokend; file=false)
+    end
+
+    @testset "override conversions follow the authority exactly" begin
+        io = IOBuffer()
+        Arrow.write(io, (a=Int64[1, 2], b=Union{Missing,Int64}[1, 2]))
+        fb = take!(io)
+        # Real conversions: requested type exact, missing only when observed.
+        t = Arrow.Table(
+            fb;
+            scan=Tables.Scan(select=(:a => Union{Missing,Float64}, :b => Float64)),
+        )
+        @test eltype(t.a) == Union{Missing,Float64}
+        @test eltype(t.b) == Float64
+        # Zero-field: true-valued and unmatched-reference filters keep rows.
+        sch = Arrow.AC.Schema(Arrow.AC.Field[])
+        zb = Arrow.writefile(sch, [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 3)])
+        t2 = Arrow.Table(
+            zb;
+            scan=Tables.Scan(filter=Tables.isnull(Tables.col(:gone)), validate=false),
+        )
+        @test Tables.rowcount(t2) == 3
+        t3 = Arrow.Table(
+            zb;
+            scan=Tables.Scan(
+                filter=Tables.isnull(Tables.col(:gone)),
+                validate=false,
+                limit=1,
+                offset=1,
+            ),
+        )
+        @test Tables.rowcount(t3) == 1
+        # List => AbstractVector is a no-op: values, retained field, and
+        # metadata all survive. List => Vector copies each row view.
+        io4 = IOBuffer()
+        Arrow.write(
+            io4,
+            (l=[[1, 2], [3]],);
+            file=false,
+            colmetadata=Dict(:l => Dict("k" => "v")),
+        )
+        lb = take!(io4)
+        t4 = Arrow.Table(lb; scan=Tables.Scan(select=(:l => AbstractVector,)))
+        @test isequal(t4.l, [[1, 2], [3]])
+        rsch = getfield(t4, :schema)
+        @test length(rsch.fields) == 1
+        @test rsch.fields[1].type isa Arrow.AC.ListType
+        @test DataAPI.colmetadata(t4, :l, "k") == "v"
+        t5 = Arrow.Table(lb; scan=Tables.Scan(select=(:l => Vector,)))
+        @test t5.l == [[1, 2], [3]] && eltype(t5.l) <: Vector
+    end
+
+    @testset "zero-field scans hold on every path" begin
+        sch = Arrow.AC.Schema(Arrow.AC.Field[])
+        zb = Arrow.writefile(sch, [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 3)])
+        for (scan, want) in (
+            (Tables.Scan(filter=Tables.AlwaysTrue()), 3),
+            (Tables.Scan(filter=Tables.AlwaysTrue(), limit=1, offset=1), 1),
+            (Tables.Scan(filter=Tables.isnull(Tables.col(:gone)), validate=false), 3),
+            (Tables.Scan(filter=Tables.AlwaysFalse()), 0),
+        )
+            @test Tables.rowcount(Arrow.Table(copy(zb); scan=scan)) == want
+            @test Tables.rowcount(Arrow.Table(_BytesSource(zb); scan=scan)) == want
+        end
+        # The facade path allocates nothing proportional to a hostile count:
+        # a tiny file claiming a million rows answers limit=1 instantly.
+        big = Arrow.writefile(
+            sch,
+            [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 1_000_000)],
+        )
+        # Warm first: compiling the scan is not part of the per-row cost.
+        Arrow.Table(big; scan=Tables.Scan(filter=Tables.AlwaysTrue(), limit=1))
+        stats =
+            _timed(Arrow.Table, big; scan=Tables.Scan(filter=Tables.AlwaysTrue(), limit=1))
+        @test Tables.rowcount(stats.value) == 1
+        @test stats.bytes < 1_000_000
+        # The metadata-only ranged read keeps the reader trust boundary: a
+        # corrupted continuation prefix rejects exactly as the full reader
+        # rejects it.
+        bad = copy(zb)
+        bad[65:68] .= 0x00
+        @test_throws Arrow.AC.ValidationError Arrow.Table(copy(bad))
+        @test_throws Arrow.AC.ValidationError Arrow.Table(
+            _BytesSource(copy(bad));
+            scan=Tables.Scan(),
+        )
+        # Header reads share ONE cumulative budget, as Limits documents:
+        # many tiny batches refuse under a bound one batch fits.
+        many = Arrow.writefile(
+            sch,
+            [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 1) for _ = 1:200],
+        )
+        tight = Arrow.Limits(max_total_allocated_bytes=6000)
+        @test_throws Arrow.AllocationLimitError Arrow.Table(
+            copy(many);
+            limits=tight,
+            scan=Tables.Scan(),
+        )
+        @test_throws Arrow.AllocationLimitError Arrow.Table(
+            Arrow.SourceFile(_BytesSource(copy(many)); limits=tight);
+            scan=Tables.Scan(),
+        )
+        # A zero-field schema declares no dictionary ids: a footer listing a
+        # well-framed dictionary block is orphaned, and the metadata-only
+        # ranged read rejects it exactly as the full reader does.
+        f0 = Arrow.readfile(copy(zb))
+        (roff, rmetalen, rbodylen) = f0.recordblocks[1]
+        recbytes = zb[(Int(roff) + 1):Int(roff + rmetalen + rbodylen)]
+        dataend = Int(roff + rmetalen + rbodylen)
+        doctored = copy(zb[1:dataend])
+        append!(doctored, recbytes)
+        append!(doctored, reinterpret(UInt8, UInt32[Arrow.CONTINUATION, UInt32(0)]))
+        fbb = Arrow.FB.Builder(1024)
+        schoff = Arrow._metaschema!(fbb, sch, Base.IdDict{Arrow.AC.Field,Int64}(), Int64[])
+        Arrow.Meta.footerStartDictionariesVector(fbb, 1)
+        Arrow.Meta.createBlock(fbb, Int64(dataend), Int32(rmetalen), rbodylen)
+        dictvec = Arrow.FB.endvector!(fbb, 1)
+        Arrow.Meta.footerStartRecordBatchesVector(fbb, 1)
+        Arrow.Meta.createBlock(fbb, roff, Int32(rmetalen), rbodylen)
+        recordvec = Arrow.FB.endvector!(fbb, 1)
+        Arrow.Meta.footerStart(fbb)
+        Arrow.Meta.footerAddVersion(fbb, Arrow.Meta.MetadataVersion.V5)
+        Arrow.Meta.footerAddSchema(fbb, schoff)
+        Arrow.Meta.footerAddDictionaries(fbb, dictvec)
+        Arrow.Meta.footerAddRecordBatches(fbb, recordvec)
+        Arrow.FB.finish!(fbb, Arrow.Meta.footerEnd(fbb))
+        ftr = collect(Arrow.FB.finishedbytes(fbb))
+        append!(doctored, ftr)
+        append!(doctored, reinterpret(UInt8, Int32[Int32(length(ftr))]))
+        append!(doctored, Arrow.FILE_MAGIC)
+        @test_throws Arrow.AC.ValidationError Arrow.Table(copy(doctored))
+        @test_throws Arrow.AC.ValidationError Arrow.Table(
+            _BytesSource(copy(doctored));
+            scan=Tables.Scan(),
+        )
+        # Structural binding is unconditional: an unsupported predicate node
+        # rejects even with validate=false, on every facade path.
+        zs = Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, Arrow.AC.ArrayData[], 3)])
+        for source in (zb, zs, _BytesSource(zb))
+            @test_throws ArgumentError Arrow.Table(
+                source;
+                scan=Tables.Scan(filter=Tables.OpNode(:custom, Any[]), validate=false),
+            )
+        end
+    end
+
+    @testset "list columns rewrite after materialization" begin
+        io = IOBuffer()
+        Arrow.write(io, (l=[[1, 2], Int64[], [3]],); file=false)
+        t = Arrow.Table(take!(io))
+        io2 = IOBuffer()
+        Arrow.write(io2, t; file=false)
+        t2 = Arrow.Table(take!(io2))
+        @test isequal(t2.l, [Any[1, 2], Any[], Any[3]])
+        # empty list column with a retained field keeps descriptor+metadata
+        io3 = IOBuffer()
+        Arrow.write(
+            io3,
+            (l=Vector{Int64}[],);
+            file=false,
+            colmetadata=Dict(:l => Dict("k" => "v")),
+        )
+        lb = take!(io3)
+        t3 = Arrow.Table(lb; scan=Tables.Scan(select=(:l => AbstractVector,)))
+        rsch = getfield(t3, :schema)
+        @test length(rsch.fields) == 1
+        @test rsch.fields[1].type isa Arrow.AC.ListType
+        @test DataAPI.colmetadata(t3, :l, "k") == "v"
+        # The full transition matrix: empty and nonempty list facades from
+        # every input path rewrite cleanly to both output formats — the
+        # retained child descriptor supplies the element type observation
+        # cannot (zero-row, all-empty-rows, and nested shapes included).
+        for rows in (
+            Vector{Int64}[],
+            [[1, 2], Int64[], [3]],
+            [Int64[], Int64[]],
+            [[Int64[1, 2]], [Int64[]]],
+        )
+            iof = IOBuffer()
+            Arrow.write(iof, (l=rows,); file=true)
+            fbb = take!(iof)
+            ios = IOBuffer()
+            Arrow.write(ios, (l=rows,); file=false)
+            sbb = take!(ios)
+            for src in (Arrow.Table(fbb), Arrow.Table(sbb), Arrow.Table(_BytesSource(fbb)))
+                for file in (true, false)
+                    out = IOBuffer()
+                    Arrow.write(out, src; file=file)
+                    back = Arrow.Table(take!(out))
+                    @test isequal(collect(Any, back.l), collect(Any, rows))
+                    bsch = getfield(back, :schema)
+                    @test bsch.fields[1].type isa Arrow.AC.ListType
+                end
+            end
+        end
+        # An EMPTY real conversion drops the stale source descriptor (the
+        # declared facade type decides, exactly as a nonempty column would)
+        # and the rewrite re-infers from the public-domain values.
+        io5 = IOBuffer()
+        Arrow.write(io5, (a=Int64[],); file=false)
+        eb = take!(io5)
+        tec = Arrow.Table(eb; scan=Tables.Scan(select=(:a => Float64,)))
+        @test eltype(Tables.getcolumn(tec, :a)) === Float64
+        @test isempty(getfield(tec, :schema).fields)
+        out5 = IOBuffer()
+        Arrow.write(out5, tec; file=true)
+        @test eltype(Arrow.Table(take!(out5)).a) === Float64
+        tes = Arrow.Table(lb; scan=Tables.Scan(select=(:l => String,)))
+        @test isempty(getfield(tes, :schema).fields)
+        # Retained identity is RECURSIVE: names, nullability, metadata, and
+        # list WIDTH survive a rewrite at every level (the natural builder
+        # only emits small lists — imposition rebuilds retained large
+        # offsets), for row-bearing and zero-row columns alike.
+        leafd = Arrow.AC.ArrayData(
+            Arrow.AC.IntType(64, true),
+            3,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[10, 20, 30])],
+        )
+        innerd = Arrow.AC.ArrayData(
+            Arrow.AC.ListType(false),
+            2,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int32[0, 2, 3])];
+            children=[leafd],
+        )
+        outerd = Arrow.AC.ArrayData(
+            Arrow.AC.ListType(true),
+            2,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[0, 1, 2])];
+            children=[innerd],
+        )
+        leaff = Arrow.AC.Field("item", Arrow.AC.IntType(64, true); nullable=false)
+        innerf = Arrow.AC.Field(
+            "inner",
+            Arrow.AC.ListType(false);
+            nullable=true,
+            metadata=["ik" => "iv"],
+            children=[leaff],
+        )
+        outerf = Arrow.AC.Field(
+            "l",
+            Arrow.AC.ListType(true);
+            nullable=false,
+            metadata=["ok" => "ov"],
+            children=[innerf],
+        )
+        nsch = Arrow.AC.Schema([outerf])
+        for nrows in (2, 0)
+            data =
+                nrows == 0 ?
+                Arrow.AC.ArrayData(
+                    Arrow.AC.ListType(true),
+                    0,
+                    [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[0])];
+                    children=[
+                        Arrow.AC.ArrayData(
+                            Arrow.AC.ListType(false),
+                            0,
+                            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int32[0])];
+                            children=[
+                                Arrow.AC.ArrayData(
+                                    Arrow.AC.IntType(64, true),
+                                    0,
+                                    [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[])],
+                                ),
+                            ],
+                        ),
+                    ],
+                ) : outerd
+            nb = Arrow.writestream(
+                nsch,
+                [Arrow.AC.RecordBatch(nsch, Arrow.AC.ArrayData[data], nrows)],
+            )
+            tsrc = Arrow.Table(nb)
+            outn = IOBuffer()
+            Arrow.write(outn, tsrc; file=false)
+            tback = Arrow.Table(take!(outn))
+            @test isequal(tback.l, tsrc.l)
+            fb1 = getfield(tback, :schema).fields[1]
+            @test fb1.type == Arrow.AC.ListType(true)
+            @test fb1.metadata !== nothing && ("ok" => "ov") in fb1.metadata
+            fi = fb1.children[1]
+            @test fi.name == "inner" && fi.type == Arrow.AC.ListType(false)
+            @test fi.nullable
+            @test fi.metadata !== nothing && ("ik" => "iv") in fi.metadata
+            @test fi.children[1].name == "item"
+        end
+        # Every vector-materializing descriptor decides keep/drop the same
+        # for empty and nonempty columns: Binary rows are Vector{UInt8}, so
+        # => Vector subsumes and keeps the field either way.
+        for (n, offs, bytes) in
+            ((2, Int32[0, 2, 3], UInt8[1, 2, 3]), (0, Int32[0], UInt8[]))
+            bd = Arrow.AC.ArrayData(
+                Arrow.AC.BinaryType(false),
+                n,
+                [
+                    Arrow.AC.BufferSlice(),
+                    Arrow.AC._databuffer(offs),
+                    Arrow.AC._databuffer(bytes),
+                ],
+            )
+            bf = Arrow.AC.Field(
+                "b",
+                Arrow.AC.BinaryType(false);
+                nullable=false,
+                metadata=["bk" => "bv"],
+            )
+            bsch = Arrow.AC.Schema([bf])
+            bb = Arrow.writestream(
+                bsch,
+                [Arrow.AC.RecordBatch(bsch, Arrow.AC.ArrayData[bd], n)],
+            )
+            tb = Arrow.Table(bb; scan=Tables.Scan(select=(:b => AbstractVector,)))
+            bsch2 = getfield(tb, :schema)
+            @test length(bsch2.fields) == 1
+            @test bsch2.fields[1].type isa Arrow.AC.BinaryType
+            @test DataAPI.colmetadata(tb, :b, "bk") == "bv"
+        end
+        # The declared row domain covers EVERY closed materializer (the
+        # Core _value methods are the authority), including Field-aware
+        # compositions; empty and nonempty columns decide keep/drop alike.
+        @test Arrow._declaredbasetype(Arrow.AC.ListViewType(false)) === Vector{Any}
+        @test Arrow._declaredbasetype(Arrow.AC.DecimalType(9, 2, 32)) ===
+              DataDecimals.Decimal32{2}
+        @test Arrow._declaredbasetype(Arrow.AC.DecimalType(38, 2, 128)) ===
+              DataDecimals.Decimal128{2}
+        @test Arrow._declaredbasetype(Arrow.AC.IntervalType(Arrow.AC.YEAR_MONTH)) ===
+              Durations.Duration
+        @test Arrow._declaredbasetype(Arrow.AC.IntervalType(Arrow.AC.DAY_TIME)) ===
+              Durations.Duration
+        dleaf = Arrow.AC.Field("v", Arrow.AC.BinaryType(false); nullable=true)
+        druns = Arrow.AC.Field("run_ends", Arrow.AC.IntType(32, true); nullable=false)
+        dref = Arrow.AC.Field(
+            "d",
+            Arrow.AC.DictionaryType(
+                Arrow.AC.IntType(32, true),
+                Arrow.AC.RunEndEncodedType(),
+                false,
+            );
+            nullable=true,
+            children=[druns, dleaf],
+        )
+        @test Arrow._declaredeltype(dref) === Union{Missing,Vector{UInt8}}
+        u1 = Arrow.AC.Field(
+            "u",
+            Arrow.AC.UnionType(Arrow.AC.DenseMode, Int8[0]);
+            nullable=false,
+            children=[Arrow.AC.Field("a", Arrow.AC.IntType(64, true); nullable=false)],
+        )
+        @test Arrow._declaredeltype(u1) === Int64
+        # The declared domain equals the ACTUAL container type: convertible
+        # leaves declare their PUBLIC type at every depth, and a
+        # multi-child union declares the mixed-population join.
+        dtf = Arrow.AC.Field("values", Arrow.AC.DateType(Arrow.AC.DAY); nullable=true)
+        rnf = Arrow.AC.Field("run_ends", Arrow.AC.IntType(32, true); nullable=false)
+        reef0 = Arrow.AC.Field(
+            "r",
+            Arrow.AC.RunEndEncodedType();
+            nullable=false,
+            children=[rnf, dtf],
+        )
+        @test Arrow._declaredeltype(reef0) === Union{Missing,Date}
+        @test Arrow._declaredeltype(reef0, false) === Union{Missing,Int32}
+        huf = Arrow.AC.Field(
+            "u",
+            Arrow.AC.UnionType(Arrow.AC.SparseMode, Int8[0, 1]);
+            nullable=false,
+            children=[
+                Arrow.AC.Field("a", Arrow.AC.IntType(64, true); nullable=false),
+                Arrow.AC.Field("b", Arrow.AC.Utf8Type(false); nullable=false),
+            ],
+        )
+        @test Arrow._declaredeltype(huf) === Any
+        # REE<Date32> end-to-end: public Date rows; a `=> Date` override is
+        # a subsuming no-op that keeps the retained field for empty and
+        # nonempty columns alike.
+        for (n, runs, vals) in
+            ((3, Int32[2, 3], Int32[19000, 19001]), (0, Int32[], Int32[]))
+            vd = Arrow.AC.ArrayData(
+                Arrow.AC.DateType(Arrow.AC.DAY),
+                length(vals),
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(vals)],
+            )
+            rd = Arrow.AC.ArrayData(
+                Arrow.AC.IntType(32, true),
+                length(runs),
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(runs)],
+            )
+            reed = Arrow.AC.ArrayData(
+                Arrow.AC.RunEndEncodedType(),
+                n,
+                Arrow.AC.BufferSlice[];
+                children=[rd, vd],
+                nullcount=0,
+            )
+            rsch0 = Arrow.AC.Schema([reef0])
+            rb = Arrow.writestream(
+                rsch0,
+                [Arrow.AC.RecordBatch(rsch0, Arrow.AC.ArrayData[reed], n)],
+            )
+            if n > 0
+                got = Arrow.Table(rb).r
+                @test eltype(got) == Union{Missing,Date}
+                @test got == Date.(
+                    Dates.UTD.(Int64[19000, 19000, 19001] .+ Dates.value(Date(1970, 1, 1))),
+                )
+            end
+            tre = Arrow.Table(rb; scan=Tables.Scan(select=(:r => Date,)))
+            rsch2 = getfield(tre, :schema)
+            @test length(rsch2.fields) == 1
+            @test rsch2.fields[1].type isa Arrow.AC.RunEndEncodedType
+        end
+        # Mixed heterogeneous union: rows are a small Union of the children's
+        # types, so a union target covering them keeps the field, empty or not.
+        for n in (2, 0)
+            tid = Arrow.AC._databuffer(Int8[0, 1][1:n])
+            uad = Arrow.AC.ArrayData(
+                Arrow.AC.IntType(64, true),
+                n,
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[5, 6][1:n])],
+            )
+            ubd = Arrow.AC.ArrayData(
+                Arrow.AC.Utf8Type(false),
+                n,
+                [
+                    Arrow.AC.BufferSlice(),
+                    Arrow.AC._databuffer(Int32[0, 1, 2][1:(n + 1)]),
+                    Arrow.AC._databuffer(UInt8[0x61, 0x62][1:n]),
+                ],
+            )
+            uud = Arrow.AC.ArrayData(
+                Arrow.AC.UnionType(Arrow.AC.SparseMode, Int8[0, 1]),
+                n,
+                [tid];
+                children=[uad, ubd],
+                nullcount=0,
+            )
+            usch0 = Arrow.AC.Schema([huf])
+            ub0 = Arrow.writestream(
+                usch0,
+                [Arrow.AC.RecordBatch(usch0, Arrow.AC.ArrayData[uud], n)],
+            )
+            tuo = Arrow.Table(
+                ub0;
+                scan=Tables.Scan(select=(:u => Union{Integer,AbstractString},)),
+            )
+            @test length(getfield(tuo, :schema).fields) == 1
+        end
+        # End-to-end: Decimal64 rows are shared decimals — an => Real override
+        # keeps the retained field for empty and nonempty columns alike.
+        for (n, vals) in ((2, Int64[1234, 5678]), (0, Int64[]))
+            dd = Arrow.AC.ArrayData(
+                Arrow.AC.DecimalType(10, 2, 64),
+                n,
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(vals)],
+            )
+            df = Arrow.AC.Field(
+                "dec",
+                Arrow.AC.DecimalType(10, 2, 64);
+                nullable=false,
+                metadata=["dk" => "dv"],
+            )
+            dsch = Arrow.AC.Schema([df])
+            db = Arrow.writestream(
+                dsch,
+                [Arrow.AC.RecordBatch(dsch, Arrow.AC.ArrayData[dd], n)],
+            )
+            td = Arrow.Table(db; scan=Tables.Scan(select=(:dec => Real,)))
+            dsch2 = getfield(td, :schema)
+            @test length(dsch2.fields) == 1
+            @test dsch2.fields[1].type isa Arrow.AC.DecimalType
+            @test DataAPI.colmetadata(td, :dec, "dk") == "dv"
+        end
+        # A coefficient outside the declared precision reads as stored, as in
+        # Arrow C++, at the top level and inside a list.
+        let t = Arrow.AC.DecimalType(3, 2, 64)
+            D = DataDecimals.Decimal{3,2,Int64}
+            dd = Arrow.AC.ArrayData(
+                t,
+                2,
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[100, 1000])],
+            )
+            dsch = Arrow.AC.Schema([Arrow.AC.Field("dec", t; nullable=false)])
+            db = Arrow.writestream(dsch, [Arrow.AC.RecordBatch(dsch, [dd], 2)])
+            @test Arrow.Table(db).dec == reinterpret(D, Int64[100, 1000])
+            item = Arrow.AC.Field("item", t; nullable=false)
+            lt = Arrow.AC.ListType(false)
+            ld = Arrow.AC.ArrayData(
+                lt,
+                1,
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int32[0, 2])];
+                children=[dd],
+            )
+            lsch =
+                Arrow.AC.Schema([Arrow.AC.Field("l", lt; nullable=false, children=[item])])
+            lb = Arrow.writestream(lsch, [Arrow.AC.RecordBatch(lsch, [ld], 1)])
+            @test only(Arrow.Table(lb).l) == reinterpret(D, Int64[100, 1000])
+        end
+        # Identity-strict at every depth: a replaced list column refuses,
+        # never coerces (convert would turn true into Int64(1)).
+        io6 = IOBuffer()
+        Arrow.write(io6, (l=[[1, 2]],); file=false)
+        trl = Arrow.Table(take!(io6))
+        cols = AbstractVector[c for c in getfield(trl, :columns)]
+        cols[1] = Any[Any[true, false]]
+        swapped = Arrow.Table(
+            getfield(trl, :names),
+            cols,
+            getfield(trl, :lookup),
+            getfield(trl, :schema),
+            Arrow.AC.OwnerRegion[],
+            1,
+        )
+        @test_throws ArgumentError Arrow.write(IOBuffer(), swapped; file=false)
+    end
+
+    @testset "typed read routing serves every valid layout" begin
+        # NullType columns (claim = Missing) and homogeneous unions (claim
+        # joins to a concrete type Core refuses) must ride the dynamic
+        # path.
+        nd = Arrow.AC.ArrayData(Arrow.AC.NullType(), 2, Arrow.AC.BufferSlice[]; nullcount=2)
+        nf = Arrow.AC.Field("n", Arrow.AC.NullType(); nullable=true)
+        nsch = Arrow.AC.Schema([nf])
+        nb =
+            Arrow.writestream(nsch, [Arrow.AC.RecordBatch(nsch, Arrow.AC.ArrayData[nd], 2)])
+        @test isequal(Arrow.Table(nb).n, [missing, missing])
+        tid = Arrow.AC._databuffer(Int8[0, 1])
+        ua = Arrow.AC.ArrayData(
+            Arrow.AC.IntType(64, true),
+            2,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[10, 20])],
+        )
+        ub_ = Arrow.AC.ArrayData(
+            Arrow.AC.IntType(64, true),
+            2,
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[30, 40])],
+        )
+        uud = Arrow.AC.ArrayData(
+            Arrow.AC.UnionType(Arrow.AC.SparseMode, Int8[0, 1]),
+            2,
+            [tid];
+            children=[ua, ub_],
+            nullcount=0,
+        )
+        uf = Arrow.AC.Field(
+            "u",
+            Arrow.AC.UnionType(Arrow.AC.SparseMode, Int8[0, 1]);
+            nullable=false,
+            children=[
+                Arrow.AC.Field("a", Arrow.AC.IntType(64, true); nullable=false),
+                Arrow.AC.Field("b", Arrow.AC.IntType(64, true); nullable=false),
+            ],
+        )
+        usch = Arrow.AC.Schema([uf])
+        ubz = Arrow.writestream(
+            usch,
+            [Arrow.AC.RecordBatch(usch, Arrow.AC.ArrayData[uud], 2)],
+        )
+        @test Arrow.Table(ubz).u == [10, 40]
+        # Dictionary- and REE-wrapped unions route dynamic too.
+        @test !Arrow._typedroutable(
+            Arrow.AC.Field(
+                "r",
+                Arrow.AC.RunEndEncodedType();
+                nullable=false,
+                children=[
+                    Arrow.AC.Field("run_ends", Arrow.AC.IntType(32, true); nullable=false),
+                    uf,
+                ],
+            ),
+        )
+        @test !Arrow._typedroutable(
+            Arrow.AC.Field(
+                "d",
+                Arrow.AC.DictionaryType(Arrow.AC.IntType(32, true), uf.type, false);
+                nullable=false,
+                children=collect(Arrow.AC.Field, uf.children),
+            ),
+        )
+    end
+
+    @testset "errors are clean" begin
+        @test_throws ArgumentError Arrow.write(IOBuffer(), Tables.partitioner(NamedTuple[]))
+
+        # Nested facade conversions recurse: SubString and Date fields of a
+        # NamedTuple write the same descriptors they write at the top level.
+        TextRow = @NamedTuple{text::SubString{String}}
+        text = SubString("nested", 1, 4)
+        for values in (TextRow[(text=text,)], Union{Missing,TextRow}[(text=text,), missing])
+            t = Arrow.Table(take!(Arrow.tobuffer((st=values,))))
+            @test only(skipmissing(t.st)).text == "nest"
+        end
+
+        DateRow = @NamedTuple{day::Date}
+        for values in (
+            DateRow[(day=Date(2024, 1, 1),)],
+            Union{Missing,DateRow}[(day=Date(2024, 1, 1),), missing],
+        )
+            t = Arrow.Table(take!(Arrow.tobuffer((st=values,))))
+            @test only(skipmissing(t.st)).day == Date(2024, 1, 1)
+        end
+
+        # A declared timezone becomes a Symbol type parameter; one that no
+        # Symbol can hold, or past the per-name bound, is invalid input.
+        for zone in ("UT\0C", "Z"^5000)
+            zt = Arrow.AC.TimestampType(Arrow.AC.MILLISECOND, zone)
+            zd = Arrow.AC.ArrayData(
+                zt,
+                1,
+                [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int64[0])],
+            )
+            zs = Arrow.AC.Schema([Arrow.AC.Field("t", zt; nullable=false)])
+            zb = Arrow.writestream(zs, [Arrow.AC.RecordBatch(zs, [zd], 1)])
+            @test_throws Arrow.ValidationError Arrow.Table(zb)
+        end
+
+        # Footer Block extents near typemax(Int64) are invalid input, not an
+        # arithmetic overflow, on every read path.
+        io = IOBuffer()
+        Arrow.write(io, (x=Int64[1, 2],); file=true)
+        good = take!(io)
+        (offset, metalen, bodylen) = Arrow.readfile(copy(good)).recordblocks[1]
+        block = reinterpret(UInt8, [offset, Int64(metalen), bodylen])
+        at = findlast(block, good)
+        @test at !== nothing
+        for (slot, forged) in ((0, typemax(Int64) - 7), (16, typemax(Int64) - 7))
+            bad = copy(good)
+            bad[first(at) .+ (slot:(slot + 7))] .= reinterpret(UInt8, [forged])
+            @test_throws Arrow.ValidationError Arrow.Table(bad)
+            @test_throws Arrow.ValidationError Arrow.Table(
+                _BytesSource(bad);
+                scan=Tables.Scan(select=(:x,)),
+            )
+        end
+    end
+
+    @testset "advisory nullability: nulls under a non-nullable field read" begin
+        # Field nullability is advisory at the reader tier (the semantic
+        # validation IPC applies accepts such data, as the reference
+        # implementation does). A non-nullable field whose batch holds a
+        # null therefore READS, as a missing-capable column, on every
+        # entry: a whole read, a scan, and a scan of an opened reader — for
+        # primitives and through a run-end-encoded wrapper.
+        AC = Arrow.AC
+        f = AC.Field("x", AC.IntType(64, true); nullable=false)
+        d = AC.ArrayData(
+            AC.IntType(64, true),
+            2,
+            [AC._databuffer(UInt8[0b10]), AC._databuffer(Int64[0, 7])];
+            nullcount=1,
+        )
+        sch = AC.Schema([f])
+        bytes = Arrow.writefile(sch, AC.RecordBatch[AC.RecordBatch(sch, [d], 2)])
+        @test isequal(Arrow.Table(bytes).x, [missing, 7])
+        @test eltype(Arrow.Table(bytes).x) === Union{Missing,Int64}
+        @test isequal(Arrow.Table(bytes; scan=Tables.Scan()).x, [missing, 7])
+        for handle in (Arrow.readfile(bytes), Arrow.SourceFile(_BytesSource(bytes)))
+            got = Arrow.Table(handle; scan=Tables.Scan())
+            @test isequal(got.x, [missing, 7])
+            @test eltype(got.x) === Union{Missing,Int64}
+        end
+        rf, rd = AC.fromjulia("run_ends", Int32[1, 2])
+        vf0, vd = AC.fromjulia("values", Union{Missing,Int64}[missing, 7])
+        vf = AC.Field("values", vf0.type; nullable=false)
+        t = AC.RunEndEncodedType()
+        ref = AC.Field("r", t; children=[rf, vf])
+        red = AC.ArrayData(t, 2, AC.BufferSlice[]; children=[rd, vd], nullcount=0)
+        sch2 = AC.Schema([ref])
+        bytes2 = Arrow.writefile(sch2, AC.RecordBatch[AC.RecordBatch(sch2, [red], 2)])
+        @test isequal(Arrow.Table(bytes2).r, [missing, 7])
+        for handle in (Arrow.readfile(bytes2), Arrow.SourceFile(_BytesSource(bytes2)))
+            @test isequal(Arrow.Table(handle; scan=Tables.Scan()).r, [missing, 7])
+        end
+        # a dictionary column: a null-free pool under a non-nullable field is
+        # Missing-free; a pool holding a null (the schema's one flag cannot
+        # declare it) reads missing-capable
+        df0, dd = AC.fromjulia_dict("d", ["lo", "hi"], [0, 1, 0])
+        df = AC.Field(
+            "d",
+            df0.type;
+            nullable=false,
+            children=collect(AC.Field, df0.children),
+        )
+        schd = AC.Schema([df])
+        bytesd = Arrow.writefile(schd, AC.RecordBatch[AC.RecordBatch(schd, [dd], 3)])
+        @test Arrow.Table(bytesd).d == ["lo", "hi", "lo"]
+        @test eltype(Arrow.Table(bytesd).d) === DataString
+        pf0, pd = AC.fromjulia_dict("d", Union{Missing,String}["lo", missing], [0, 1, 0])
+        pf = AC.Field(
+            "d",
+            pf0.type;
+            nullable=false,
+            children=collect(AC.Field, pf0.children),
+        )
+        schp = AC.Schema([pf])
+        bytesp = Arrow.writefile(schp, AC.RecordBatch[AC.RecordBatch(schp, [pd], 3)])
+        @test isequal(Arrow.Table(bytesp).d, ["lo", missing, "lo"])
+        @test eltype(Arrow.Table(bytesp).d) === Union{Missing,DataString}
+        # a conforming batch keeps the declared, Missing-free type
+        cf, cd = AC.fromjulia("c", Int64[1, 2])
+        schc = AC.Schema([cf])
+        bytesc = Arrow.writefile(schc, AC.RecordBatch[AC.RecordBatch(schc, [cd], 2)])
+        @test eltype(Arrow.Table(bytesc).c) === Int64
+    end
+
+    @testset "empty column types do not depend on batch structure" begin
+        # A schema-only source and a source with one zero-row batch give
+        # every column the same element type, for the closed scalars and
+        # through the transparent wrappers.
+        AC = Arrow.AC
+        cases = [
+            (
+                "bin",
+                AC.BinaryType(false),
+                () -> AC.ArrayData(
+                    AC.BinaryType(false),
+                    0,
+                    [AC.BufferSlice(), AC._databuffer(Int32[0]), AC._databuffer(UInt8[])];
+                    nullcount=0,
+                ),
+                DataStrings.DataBytes,
+            ),
+            (
+                "fsb",
+                AC.FixedSizeBinaryType(2),
+                () -> AC.ArrayData(
+                    AC.FixedSizeBinaryType(2),
+                    0,
+                    [AC.BufferSlice(), AC._databuffer(UInt8[])];
+                    nullcount=0,
+                ),
+                NTuple{2,UInt8},
+            ),
+            (
+                "d128",
+                AC.DecimalType(10, 2, 128),
+                () -> AC.ArrayData(
+                    AC.DecimalType(10, 2, 128),
+                    0,
+                    [AC.BufferSlice(), AC._databuffer(Int128[])];
+                    nullcount=0,
+                ),
+                DataDecimals.Decimal{10,2,Int128},
+            ),
+            (
+                "d64",
+                AC.DecimalType(10, 2, 64),
+                () -> AC.ArrayData(
+                    AC.DecimalType(10, 2, 64),
+                    0,
+                    [AC.BufferSlice(), AC._databuffer(Int64[])];
+                    nullcount=0,
+                ),
+                DataDecimals.Decimal{10,2,Int64},
+            ),
+            (
+                "iym",
+                AC.IntervalType(AC.YEAR_MONTH),
+                () -> AC.ArrayData(
+                    AC.IntervalType(AC.YEAR_MONTH),
+                    0,
+                    [AC.BufferSlice(), AC._databuffer(Int32[])];
+                    nullcount=0,
+                ),
+                Durations.Duration,
+            ),
+            (
+                "imdn",
+                AC.IntervalType(AC.MONTH_DAY_NANO),
+                () -> AC.ArrayData(
+                    AC.IntervalType(AC.MONTH_DAY_NANO),
+                    0,
+                    [AC.BufferSlice(), AC._databuffer(UInt8[])];
+                    nullcount=0,
+                ),
+                Durations.Duration,
+            ),
+        ]
+        for (name, t, mk, want) in cases
+            f = AC.Field(name, t; nullable=false)
+            sch = AC.Schema([f])
+            so = Arrow.Table(Arrow.writefile(sch, AC.RecordBatch[]))
+            zr = Arrow.Table(
+                Arrow.writefile(sch, AC.RecordBatch[AC.RecordBatch(sch, [mk()], 0)]),
+            )
+            @test eltype(Tables.getcolumn(so, 1)) === want
+            @test eltype(Tables.getcolumn(zr, 1)) === want
+            @test length(Tables.getcolumn(so, 1)) == 0 == length(Tables.getcolumn(zr, 1))
+        end
+        # transparent REE over Int64: the values child's type, both ways
+        rf, rd = AC.fromjulia("run_ends", Int32[])
+        vf, vd = AC.fromjulia("values", Int64[])
+        t = AC.RunEndEncodedType()
+        ref = AC.Field("r", t; children=[rf, vf])
+        sch = AC.Schema([ref])
+        so = Arrow.Table(Arrow.writefile(sch, AC.RecordBatch[]))
+        red = AC.ArrayData(t, 0, AC.BufferSlice[]; children=[rd, vd], nullcount=0)
+        zr =
+            Arrow.Table(Arrow.writefile(sch, AC.RecordBatch[AC.RecordBatch(sch, [red], 0)]))
+        @test eltype(so.r) === Int64 === eltype(zr.r)
+        # composites: the typed row, both ways
+        lf, ld = AC.fromjulia("l", Vector{Int64}[])
+        schl = AC.Schema([lf])
+        Row = Arrow.ListValue{Int64}
+        @test eltype(Arrow.Table(Arrow.writefile(schl, AC.RecordBatch[])).l) === Row
+        @test eltype(
+            Arrow.Table(
+                Arrow.writefile(schl, AC.RecordBatch[AC.RecordBatch(schl, [ld], 0)]),
+            ).l,
+        ) === Row
+    end
+
+    @testset "type mappings: bytes, 128-bit ints, UUIDs, periods, abstract columns" begin
+        rt(t; kw...) = Arrow.Table(take!(Arrow.write(IOBuffer(), t; kw...)))
+        fieldof(t) = getfield(t, :schema).fields[1]
+        label(f) = Arrow._fieldmetavalue(f, "ARROW:extension:name")
+        # Byte vectors are Binary; byte tuples FixedSizeBinary.
+        for col in ([UInt8[1, 2], UInt8[]], [codeunits("ab"), codeunits("")])
+            t = rt((; x=col))
+            @test fieldof(t).type == Arrow.AC.BinaryType(false)
+            @test t.x == collect.(col)
+        end
+        long = collect(0x01:0x20)
+        bv = DataStrings.BytesVector{DataBytes}(
+            [
+                DataStrings.inline_payload(UInt8[1, 2], 1, 2),
+                DataStrings.inline_payload(UInt8[], 1, 0),
+                DataStrings.view_payload(long, 1, 32, 0, 0),
+            ],
+            [long],
+        )
+        for (sv, type) in
+            ((false, Arrow.AC.BinaryType(false)), (true, Arrow.AC.ViewType(false)))
+            t = rt((; x=bv); stringview=sv)
+            @test fieldof(t).type == type
+            @test t.x == [UInt8[1, 2], UInt8[], collect(0x01:0x20)]
+        end
+        t = rt((; x=[(0x01, 0x02, 0x03), (0x04, 0x05, 0x06)]))
+        @test fieldof(t).type == Arrow.AC.FixedSizeBinaryType(3)
+        @test t.x == [(0x01, 0x02, 0x03), (0x04, 0x05, 0x06)]
+        # UUID: canonical arrow.uuid, big-endian bytes; fresh and retained.
+        u = Union{Missing,UUID}[UUID("00112233-4455-6677-8899-aabbccddeeff"), missing]
+        t = rt((; x=u))
+        f = fieldof(t)
+        @test f.type == Arrow.AC.FixedSizeBinaryType(16) && label(f) == "arrow.uuid"
+        bytes =
+            Arrow.readfile(take!(Arrow.write(IOBuffer(), (; x=u); file=true)))[1].columns[1]
+        @test Arrow.AC.loadat(Arrow.AC.rolebuffer(bytes, Arrow.AC.DATA), UInt8, 0) == 0x00
+        @test Arrow.AC.loadat(Arrow.AC.rolebuffer(bytes, Arrow.AC.DATA), UInt8, 15) == 0xff
+        @test isequal(collect(t.x), u) && isequal(collect(rt(t).x), u)
+        # 128-bit integers: FixedSizeBinary(16) with a Julia label.
+        for (T, name) in ((Int128, "JuliaLang.Int128"), (UInt128, "JuliaLang.UInt128"))
+            col = T[typemin(T), one(T), typemax(T)]
+            t = rt((; x=col))
+            @test label(fieldof(t)) == name
+            @test eltype(t.x) == T && t.x == col && rt(t).x == col
+        end
+        # Larger periods: exact durations and year-month intervals that read back
+        # as the same period type.
+        for (col, type) in (
+            ([Day(2), Day(-1)], Arrow.AC.DurationType(Arrow.AC.SECOND)),
+            ([Week(1)], Arrow.AC.DurationType(Arrow.AC.SECOND)),
+            ([Hour(3)], Arrow.AC.DurationType(Arrow.AC.SECOND)),
+            ([Minute(-5)], Arrow.AC.DurationType(Arrow.AC.SECOND)),
+            ([Month(14)], Arrow.AC.IntervalType(Arrow.AC.YEAR_MONTH)),
+            ([Year(-2)], Arrow.AC.IntervalType(Arrow.AC.YEAR_MONTH)),
+        )
+            t = rt((; x=col))
+            @test fieldof(t).type == type
+            @test eltype(t.x) == eltype(col) && t.x == col && rt(t).x == col
+        end
+        @test_throws OverflowError Arrow.tobuffer((; x=[Week(typemax(Int64))]))
+        # Abstract columns narrow to their values' types.
+        t = rt((; x=Real[1, 2]))
+        @test eltype(t.x) == Int64 && t.x == [1, 2]
+        for col in (Any[1, "a", 2.5, missing], Real[1, 2.5])
+            t = rt((; x=col))
+            @test fieldof(t).type isa Arrow.AC.UnionType
+            @test isequal(collect(t.x), col)
+        end
+        t = rt((; x=Any[[1], ["a", "b"]]))
+        @test isequal(collect(t.x), [[1], ["a", "b"]])
+        @test_throws ArgumentError Arrow.tobuffer((;
+            x=Any[
+                Int8(1),
+                Int16(2),
+                Int32(3),
+                Int64(4),
+                UInt8(5),
+                UInt16(6),
+                UInt32(7),
+                UInt64(8),
+                9.0,
+            ]
+        ))
+    end
+
+    @testset "canonical extension reads" begin
+        AC = Arrow.AC
+        ext(name) = ["ARROW:extension:name" => name, "ARROW:extension:metadata" => ""]
+        function onecolumn(f, d; kw...)
+            sch = AC.Schema([f])
+            return Arrow.Table(Arrow.writefile(sch, [AC.RecordBatch(sch, [d])]); kw...)
+        end
+        _, d8 = AC.fromjulia("x", Int8[0, 1, 7])
+        t = onecolumn(
+            AC.Field("x", AC.IntType(8, true); nullable=false, metadata=ext("arrow.bool8")),
+            d8,
+        )
+        @test eltype(t.x) == Bool && t.x == [false, true, true]
+        # A rewrite keeps the label and stores the values as 0 and 1.
+        bytes = take!(Arrow.write(IOBuffer(), t; file=true))
+        f = only(Arrow.readfile(bytes).schema.fields)
+        @test f.type == AC.IntType(8, true)
+        @test Dict(f.metadata)["ARROW:extension:name"] == "arrow.bool8"
+        @test Arrow.Table(bytes).x == [false, true, true]
+        # On uint8 storage the label is not arrow.bool8's: the column reads,
+        # and rewrites, as its stored bytes.
+        _, du8 = AC.fromjulia("x", UInt8[0, 254])
+        f = AC.Field("x", AC.IntType(8, false); nullable=false, metadata=ext("arrow.bool8"))
+        empty!(Arrow._WARNED_EXTENSIONS)
+        t = @test_logs (:warn, r"unsupported ARROW:extension:name") onecolumn(f, du8)
+        @test t.x == [0x00, 0xfe]
+        @test Arrow.Table(take!(Arrow.write(IOBuffer(), t))).x == [0x00, 0xfe]
+        _, ds = AC.fromjulia("x", ["{\"a\": 1}", "[]"])
+        for name in ("arrow.json", "arrow.opaque")
+            f = AC.Field("x", AC.Utf8Type(false); nullable=false, metadata=ext(name))
+            t = @test_logs min_level = Logging.Warn onecolumn(f, ds)
+            @test t.x == ["{\"a\": 1}", "[]"]
+        end
+        # An unknown extension warns once per process.
+        name = "example.unknown.$(time_ns())"
+        f = AC.Field("x", AC.Utf8Type(false); nullable=false, metadata=ext(name))
+        @test_logs (:warn, r"unsupported ARROW:extension:name") onecolumn(f, ds)
+        @test_logs min_level = Logging.Warn onecolumn(f, ds)
+        # Labels that read as their storage read as its columns: strings as
+        # a StringVector (or `stringtype`), integers as a view; a rewrite
+        # keeps the label.
+        for label in ("arrow.json", "arrow.opaque", name)
+            f = AC.Field("x", AC.Utf8Type(false); nullable=false, metadata=ext(label))
+            t = onecolumn(f, ds)
+            @test t.x isa StringVector && eltype(t.x) == DataStrings.DataString
+            @test eltype(onecolumn(f, ds; stringtype=String).x) == String
+            back = Arrow.readfile(take!(Arrow.write(IOBuffer(), t; file=true)))
+            @test Dict(only(back.schema.fields).metadata)["ARROW:extension:name"] == label
+        end
+        # So does a name some code already made a Symbol, when no
+        # ArrowTypes.jl `JuliaType` method takes it.
+        Symbol(name)
+        f = AC.Field("x", AC.Utf8Type(false); nullable=false, metadata=ext(name))
+        @test onecolumn(f, ds).x isa StringVector
+        _, d32 = AC.fromjulia("x", Int32[1, 2, 3])
+        f = AC.Field("x", AC.IntType(32, true); nullable=false, metadata=ext(name))
+        t = onecolumn(f, d32)
+        @test t.x isa Arrow.Primitive && t.x == [1, 2, 3]
+    end
+
+    @testset "time zones: filter literals and the per-read cap" begin
+        AC = Arrow.AC
+        utc(x...) = Durations.ZonedTimestamp{Dates.Microsecond,:UTC}(x...)
+        denver = Durations.ZonedTimestamp{Dates.Microsecond,Symbol("America/Denver")}
+        ts = [utc(2019, 12, 31), utc(2020, 1, 1, 12)]
+        bytes = take!(Arrow.write(IOBuffer(), (u=ts, d=denver.(ts), n=[1, 2])))
+        rows(f) = Arrow.Table(bytes; scan=Tables.Scan(filter=f)).n
+        # A zone-free literal on a UTC column is that UTC wall time.
+        for lit in (
+            Dates.DateTime(2020),
+            Dates.Date(2020),
+            Durations.Timestamp{Dates.Millisecond}(2020),
+            utc(2020),
+        )
+            @test rows(Tables.colcmp(>=, Tables.col(:u), lit)) == [2]
+        end
+        @test rows(Tables.colin(Tables.col(:u), [Dates.DateTime(2020, 1, 1, 12)])) == [2]
+        @test rows(Tables.colin(Tables.col(:u), Set([Dates.DateTime(2020, 1, 1, 12)]))) ==
+              [2]
+        # An inexact literal for the column's unit compares exactly.
+        later = Durations.Timestamp{Dates.Nanosecond}(2020, 1, 1, 12) + Dates.Nanosecond(1)
+        @test isempty(rows(Tables.colcmp(>=, Tables.col(:u), later)))
+        # Another zone needs a zoned literal, and the error shows one.
+        err = try
+            rows(Tables.colcmp(>=, Tables.col(:d), Dates.DateTime(2020)))
+        catch e
+            e
+        end
+        @test err isa ArgumentError && occursin(
+            "Durations.ZonedTimestamp{Dates.Microsecond,:UTC}(2020, 1, 1)",
+            err.msg,
+        )
+        @test rows(Tables.colcmp(>=, Tables.col(:d), utc(2020))) == [2]
+        # One read may bring at most 1,024 zones the process has not seen.
+        tag = string(time_ns())
+        zoned(n) = AC.Schema([
+            AC.Field("t$i", AC.TimestampType(AC.SECOND, "Test/$tag-$n-$i"); nullable=true) for i = 1:n
+        ])
+        @test_throws Arrow.ValidationError Arrow.Table(
+            Arrow.writefile(zoned(1025), AC.RecordBatch[]),
+        )
+        @test length(
+            Tables.columnnames(Arrow.Table(Arrow.writefile(zoned(3), AC.RecordBatch[]))),
+        ) == 3
+    end
+
+    @testset "read views write back from their own buffers" begin
+        AC = Arrow.AC
+        n = 3000
+        src = (;
+            i=[isodd(k) ? missing : k for k = 1:n],
+            d=[k % 5 == 0 ? missing : Dates.Date(2020) + Dates.Day(k) for k = 1:n],
+            b=[k % 7 == 0 ? missing : iseven(k) for k = 1:n],
+            s=[k % 3 == 0 ? missing : repeat("s", k % 40) for k = 1:n],
+        )
+        t = Arrow.Table(take!(Arrow.write(IOBuffer(), src; batchsize=1000)))
+        cols = (; i=t.i, d=t.d, b=t.b, s=t.s)
+        # A batch that is one read batch reuses its buffers.
+        chunk = first(t.i.arrays)
+        _, d = Arrow._constructpart("i", chunk)
+        @test AC.sliceptr(d.buffers[2]) == AC.sliceptr(AC.rolebuffer(chunk.owner, AC.DATA))
+        for batchsize in (1000, 777, 5000)
+            back = Arrow.Table(take!(Arrow.write(IOBuffer(), cols; batchsize)))
+            @test all(
+                c -> isequal(collect(getproperty(back, c)), getproperty(src, c)),
+                keys(src),
+            )
+        end
+        # A string batch read in order is a slice of the read buffer; strings
+        # appended one by one (short ones only inline) are copied.
+        _, sd = Arrow._constructpart("s", view(t.s, 1:1000))
+        @test any(
+            b -> AC._storageroot(b) === AC.rolebuffer(sd, AC.DATA).region.root,
+            t.s.buffers,
+        )
+        appended = DataStrings.StringVector(src.s)
+        for batchsize in (3, 1000)
+            back = Arrow.Table(take!(Arrow.write(IOBuffer(), (; s=appended); batchsize)))
+            @test isequal(collect(back.s), src.s)
+        end
+        # An edited value never writes the read buffer's stale bytes: a short
+        # value lives in its payload (the buffer keeps the old bytes), a long
+        # one moves to an edit buffer.
+        rows = view(t.s, 1:1000)
+        for (row, value) in ((2, "sx"), (5, "a value longer than twelve bytes"))
+            t.s[row] = value
+            back = Arrow.Table(take!(Arrow.write(IOBuffer(), (; s=rows))))
+            @test back.s[row] == value
+            @test isequal(collect(back.s), collect(rows))
+        end
+    end
+
+    @testset "ntasks: the same bytes on any number of tasks" begin
+        n = 40_000
+        src = (;
+            i=collect(1:n),
+            s=[isodd(k) ? "short$k" : "a longer string value $k" for k = 1:n],
+            l=[collect(1:(k % 4)) for k = 1:n],
+            r=[(a=k, b=string(k)) for k = 1:n],
+            d=Arrow.DictEncode([string(k % 7) for k = 1:n]),
+        )
+        for compress in (nothing, :lz4, :zstd), file in (true, false)
+            one = take!(
+                Arrow.write(IOBuffer(), src; compress, file, ntasks=1, batchsize=9000),
+            )
+            many = take!(
+                Arrow.write(IOBuffer(), src; compress, file, ntasks=4, batchsize=9000),
+            )
+            @test one == many
+        end
+        @test_throws ArgumentError Arrow.write(IOBuffer(), src; ntasks=-1)
+        # Each task compresses with its own codec state, and which task gets
+        # which buffer varies; an LZ4 frame must not depend on what its
+        # task's state compressed before.
+        text = Vector{UInt8}(join(["str$(k % 1000)_" * "x"^(k % 13) for k = 1:50_000]))
+        lz4(st, v) = GC.@preserve v copy(
+            Arrow._compressbytes(st, Arrow.CODEC_LZ4_FRAME, pointer(v), length(v)),
+        )
+        fresh, used = Arrow.EncodeState(), Arrow.EncodeState()
+        lz4(used, reverse(text))
+        @test lz4(fresh, text) == lz4(used, text)
+        # With several failing columns, the error is the first column's.
+        for ntasks in (1, 4)
+            err = try
+                Arrow.write(
+                    IOBuffer(),
+                    (; a=fill(Any[], 100_000), c=fill(Any[], 100_000));
+                    ntasks,
+                )
+                nothing
+            catch e
+                e
+            end
+            @test err isa ArgumentError && startswith(err.msg, "column a (child item)")
+        end
+    end
+
+    @testset "colmetadata names columns by Symbol or string" begin
+        write1(tbl; kw...) = Arrow.Table(take!(Arrow.write(IOBuffer(), tbl; kw...)))
+        back = write1(
+            (a=[1], b=[2]);
+            colmetadata=Dict("a" => Dict("unit" => "m")),
+            metadata=Dict("version" => 2),
+        )
+        @test DataAPI.colmetadata(back, :a, "unit") == "m"
+        @test isempty(collect(DataAPI.colmetadatakeys(back, :b)))
+        # Values that are not strings are written as they print, as DataAPI
+        # metadata is.
+        @test DataAPI.metadata(back, "version") == "2"
+        back = write1((a=[1],); colmetadata=Dict(:a => Dict("scale" => 1.5)))
+        @test DataAPI.colmetadata(back, :a, "scale") == "1.5"
+        # A name that is not a column is an error, as in dictencode.
+        err = @test_throws ArgumentError write1(
+            (a=[1],);
+            colmetadata=Dict(:A => Dict("unit" => "m")),
+        )
+        @test occursin("colmetadata names column A", err.value.msg)
+    end
+
+    @testset "metadata defaults to the table's DataAPI metadata" begin
+        t = _MetaTable(
+            (; a=[1, 2], u=[UUIDs.UUID(1), UUIDs.UUID(2)]),
+            Dict("source" => "test", "ARROW:schema" => "dropped"),
+            Dict(:a => Dict("unit" => "m"), :u => Dict("ARROW:extension:name" => "x.y")),
+        )
+        back = Arrow.Table(take!(Arrow.write(IOBuffer(), t)))
+        @test DataAPI.metadata(back) == Dict("source" => "test")
+        @test DataAPI.colmetadata(back, :a, "unit") == "m"
+        # The reserved ARROW: keys stay the writer's: u keeps its arrow.uuid label.
+        @test DataAPI.colmetadata(back, :u, "ARROW:extension:name") == "arrow.uuid"
+        @test back.u == t.columns.u
+        # Keywords win over the table's metadata.
+        kw = Arrow.Table(take!(Arrow.write(IOBuffer(), t; metadata=["k" => "v"])))
+        @test DataAPI.metadata(kw) == Dict("k" => "v")
+    end
+
+    @testset "strings that are not UTF-8 are refused, naming the column and row" begin
+        bad = String(UInt8[0x61, 0xff])
+        msg(t; kw...) =
+            try
+                Arrow.write(IOBuffer(), t; kw...)
+                ""
+            catch e
+                e isa ArgumentError ? e.msg : sprint(showerror, e)
+            end
+        utf8msg(at) = "column $at holds a string that is not valid UTF-8"
+        @test startswith(msg((; s=["ok", bad])), utf8msg("s row 2"))
+        @test occursin("Vector{UInt8}", msg((; s=["ok", bad])))
+        @test startswith(msg((; s=["ok", bad]); stringview=true), utf8msg("s row 2"))
+        @test startswith(msg((; s=[fill("ok", 5); bad]); batchsize=2), utf8msg("s row 6"))
+        parts = Tables.partitioner([(; s=["a"]), (; s=["b", bad])])
+        @test startswith(msg(parts), utf8msg("s row 2 of partition 2"))
+        @test startswith(msg((; s=[["ok"], ["a", bad]])), utf8msg("s (child item) row 2"))
+        @test startswith(
+            msg((; s=[(a=1, b="ok"), (a=2, b=bad)])),
+            utf8msg("s (child b) row 2"),
+        )
+        @test startswith(
+            msg((; s=[Dict("ok" => 1), Dict(bad => 2)])),
+            utf8msg("s (child entries.key) row 2"),
+        )
+        @test startswith(msg((; s=Arrow.DictEncode(["ok", "ok", bad]))), utf8msg("s row 3"))
+        @test startswith(msg((; s=[:ok, Symbol(bad)])), utf8msg("s row 2"))
+        # Rows split inside one character: the bytes are UTF-8 together, not apart.
+        halves = [String(UInt8[0xc3]), String(UInt8[0xa9])]
+        @test startswith(msg((; s=halves)), utf8msg("s row 1"))
+        @test msg((; s=["é", "日本", "a", ""])) == ""
+        io = IOBuffer()
+        @test_throws ArgumentError Arrow.Writer(io) do w
+            Arrow.write(w, (; s=["ok"]))
+            Arrow.write(w, (; s=[bad]))
+        end
+        stream = take!(Arrow.write(IOBuffer(), (; s=["ok"]); file=false))
+        err = try
+            Arrow.append(IOBuffer(stream; read=true, write=true), (; s=["a", bad]))
+            nothing
+        catch e
+            e
+        end
+        @test err isa ArgumentError && startswith(err.msg, utf8msg("s row 2"))
+        # A table read from a file that holds such a string rewrites only as binary.
+        f, d = Arrow.AC.fromjulia("s", ["ok", bad])
+        sch = Arrow.AC.Schema([f])
+        src = Arrow.Table(Arrow.writestream(sch, [Arrow.AC.RecordBatch(sch, [d], 2)]))
+        @test startswith(msg(src), utf8msg("s row 2"))
+    end
+
+    @testset "errors name the column and say what to do" begin
+        msg(t) =
+            try
+                Arrow.write(IOBuffer(), t)
+                ""
+            catch e
+                sprint(showerror, e)
+            end
+        @test startswith(
+            msg((; mixed=Any[1, 1.0, "x", 'c', :s, 0x01, Int16(2), Int32(3), true])),
+            "ArgumentError: column mixed holds values of more than 8 types",
+        )
+        @test occursin("column m holds Matrix{Int64} values", msg((; m=[[1 2; 3 4]])))
+        @test occursin("column a has no values to infer an Arrow type", msg((; a=Any[])))
+        @test occursin(
+            "column b holds BigInt values, which have no Arrow type",
+            msg((; b=[big(1)])),
+        )
+    end
+
+    @testset "write knobs: batchsize, compresslevel, dictencode, largelists" begin
+        AC = Arrow.AC
+        nbatches(bytes) = length(Arrow.Stream(bytes))
+        function types(bytes)
+            core = view(bytes, 1:6) == b"ARROW1" ? Arrow.readfile : Arrow.readstream
+            return [f.type for f in core(bytes).schema.fields]
+        end
+        t = (; a=collect(1:10), s=[isodd(i) ? "x$i" : missing for i = 1:10])
+        for (batchsize, n) in ((1, 10), (3, 4), (10, 1), (11, 1))
+            bytes = take!(Arrow.write(IOBuffer(), t; batchsize, file=true))
+            @test nbatches(bytes) == n
+            back = Arrow.Table(bytes)
+            @test back.a == t.a && isequal(collect(back.s), t.s)
+        end
+        @test nbatches(
+            take!(Arrow.write(IOBuffer(), (; a=zeros(Int8, (1 << 20) + 1)); file=true)),
+        ) == 2
+        # A partition with no rows adds no record batch.
+        parts = Tables.partitioner([(; a=collect(1:5)), (; a=Int[]), (; a=[6, 7])])
+        bytes = take!(Arrow.write(IOBuffer(), parts; batchsize=2, file=true))
+        f = Arrow.readfile(bytes)
+        @test [f[i].nrows for i = 1:length(f)] == [2, 2, 1, 2]
+        @test Arrow.Table(bytes).a == 1:7
+        @test_throws ArgumentError Arrow.write(IOBuffer(), t; batchsize=0)
+        io = IOBuffer()
+        Arrow.Writer(io; batchsize=4) do w
+            Arrow.write(w, t)
+            Arrow.write(w, t)
+        end
+        @test nbatches(take!(io)) == 6
+        # compression levels change the bytes, not the values
+        big = (; a=repeat(collect(1:1000), 50))
+        for compress in (:lz4, :zstd)
+            sizes = map((1, 9)) do compresslevel
+                bytes = take!(Arrow.write(IOBuffer(), big; compress, compresslevel))
+                @test Arrow.Table(bytes).a == big.a
+                length(bytes)
+            end
+            @test sizes[1] != sizes[2]
+        end
+        @test_throws ArgumentError Arrow.write(IOBuffer(), t; compresslevel=3)
+        # dictencode: every column, or the named ones
+        dt = (; a=[1, 2, 1], s=["x", "y", "x"])
+        isdict(bytes) = [ty isa AC.DictionaryType for ty in types(bytes)]
+        @test isdict(take!(Arrow.write(IOBuffer(), dt; dictencode=true))) == [true, true]
+        @test isdict(take!(Arrow.write(IOBuffer(), dt; dictencode=[:s]))) == [false, true]
+        @test isdict(take!(Arrow.write(IOBuffer(), dt; dictencode=["a"]))) == [true, false]
+        @test_throws ArgumentError Arrow.write(IOBuffer(), dt; dictencode=[:nope])
+        plain = Arrow.Table(take!(Arrow.write(IOBuffer(), dt)))
+        bytes = take!(Arrow.write(IOBuffer(), plain; dictencode=[:s]))
+        @test isdict(bytes) == [false, true] && Arrow.Table(bytes).s == dt.s
+        # 64-bit offsets only on request
+        lt = (; s=["a", "bb"], b=[UInt8[1], UInt8[]], l=[[1, 2], [3]])
+        @test types(take!(Arrow.write(IOBuffer(), lt))) ==
+              [AC.Utf8Type(false), AC.BinaryType(false), AC.ListType(false)]
+        bytes = take!(Arrow.write(IOBuffer(), lt; largelists=true))
+        @test types(bytes) == [AC.Utf8Type(true), AC.BinaryType(true), AC.ListType(true)]
+        back = Arrow.Table(bytes)
+        @test back.s == lt.s && back.b == lt.b && back.l == lt.l
+    end
+
+    @testset "batches whose offsets would pass Int32 are cut smaller" begin
+        # A later batch overflows after an earlier batch has been published.
+        # Only that batch and the remaining rows need to be cut smaller.
+        calls = Ref(0)
+        columns = AbstractVector[collect(1:10)]
+        batches = Vector{Int}[]
+        Arrow._eachbatch(columns, 10, 4) do cols, nrows
+            calls[] += 1
+            calls[] == 2 && throw(Arrow._OffsetOverflow("s", 1, 3))
+            @test length(only(cols)) == nrows
+            push!(batches, collect(only(cols)))
+        end
+        @test calls[] == 5
+        @test batches == [[1, 2, 3, 4], [5, 6], [7, 8], [9, 10]]
+
+        empty!(batches)
+        Arrow._eachbatch(columns, 10, 4) do cols, _
+            length(only(cols)) > 3 && throw(Arrow._OffsetOverflow("s", 1, 4))
+            push!(batches, collect(only(cols)))
+        end
+        @test batches == [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
+        # a single value too large for 32-bit offsets says how to write it
+        err = try
+            Arrow._eachbatch(columns, 10, 4) do cols, _
+                throw(Arrow._OffsetOverflow("s", 1, 1))
+            end
+        catch e
+            e
+        end
+        @test err isa ArgumentError && occursin("largelists=true", err.msg)
+    end
+
+    @testset "DataStrings columns write as utf8, or as Utf8View zero-copy" begin
+        # A StringVector's memory IS a Utf8View array: payloads are the
+        # views buffer, its byte buffers the variadic data buffers. Build one
+        # the way the CSV kernel does (inline ≤12, else a view into buffer 0
+        # or the `extra` buffer 1) and check the writer wraps rather than
+        # materializes, the file carries Utf8View, and the facade reads it
+        # back as a StringVector.
+        buf = Vector{UInt8}(codeunits("id,s\n1,abcd\n2,thirteen-byte\n3,\n"))
+        extra = Vector{UInt8}(codeunits("she said \"hi\" and left"))
+        long1 = first(findfirst(codeunits("thirteen-byte"), buf))
+        abcd = first(findfirst(codeunits("abcd"), buf))
+        payloads = StringPayload[
+            DataStrings.inline_payload(buf, abcd, 4),
+            DataStrings.view_payload(buf, long1, 13, 0, long1 - 1),
+            DataStrings.PAYLOAD_MISSING,
+            DataStrings.view_payload(extra, 1, length(extra), 1, 0),
+        ]
+        col = StringVector{Union{Missing,DataString}}(payloads, buf, extra)
+        expected = ["abcd", "thirteen-byte", missing, "she said \"hi\" and left"]
+        # By default the bytes are packed into one utf8 column.
+        f, _ = Arrow._constructcolumn(:s, col)
+        @test f.type == Arrow.AC.Utf8Type(false) && f.nullable
+        io = IOBuffer()
+        Arrow.write(io, (id=[1, 2, 3, 4], s=col); file=true)
+        bytes = take!(io)
+        @test Arrow.readfile(bytes).schema.fields[2].type == Arrow.AC.Utf8Type(false)
+        @test isequal(Arrow.Table(bytes).s, expected)
+        # stringview=true writes the column's own memory as Utf8View.
+        f, d = Arrow._constructcolumn(:s, col; stringview=true)
+        @test f.type == Arrow.AC.ViewType(true) && f.nullable
+        @test d.buffers[2].region.root === Arrow.AC._storageroot(payloads) # views: the payload vector itself
+        @test d.buffers[3].region.root === Arrow.AC._storageroot(buf)
+        @test d.buffers[4].region.root === Arrow.AC._storageroot(extra)
+        Arrow.write(io, (id=[1, 2, 3, 4], s=col); stringview=true, file=true)
+        bytes = take!(io)
+        @test Arrow.readfile(bytes).schema.fields[2].type == Arrow.AC.ViewType(true)
+        t = Arrow.Table(bytes)
+        @test eltype(t.s) === Union{Missing,DataString}
+        @test isequal(t.s, expected)
+        # a non-nullable column declares non-nullable
+        col0 = StringVector{DataString}(payloads[[1, 2]], buf, extra)
+        f0, _ = Arrow._constructcolumn(:s, col0)
+        @test !f0.nullable
+        Arrow.write(io, (s=col0,))
+        @test Arrow.Table(take!(io)).s == ["abcd", "thirteen-byte"]
+        # an all-inline column may have ZERO data buffers — the format allows
+        # a Utf8View with no variadic buffers, and the wire carries exactly
+        # the fixed validity + views pair
+        inl = StringVector{DataString}(
+            [
+                DataStrings.inline_payload(buf, abcd, 4),
+                DataStrings.inline_payload(buf, abcd, 2),
+            ],
+            Vector{Vector{UInt8}}(),
+        )
+        fi, di = Arrow._constructcolumn(:s, inl; stringview=true)
+        @test length(di.buffers) == 2
+        Arrow.write(io, (s=inl,); stringview=true, file=true)
+        bytes0 = take!(io)
+        @test Arrow.Table(bytes0).s == ["abcd", "ab"]
+        af = Arrow.readfile(bytes0)
+        @test af.schema.fields[1].type == Arrow.AC.ViewType(true)
+        @test length(af[1].columns[1].buffers) == 2         # no variadic buffers on the wire
+    end
+end
+
+end # module FacadeTests
diff --git a/test/fixtures-cdata/README.md b/test/fixtures-cdata/README.md
new file mode 100644
index 00000000..c58d540c
--- /dev/null
+++ b/test/fixtures-cdata/README.md
@@ -0,0 +1,27 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements. See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership. The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied. See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# C data interface fixtures
+
+`matrix.arrows` is an IPC stream pyarrow 25.0.1 wrote with `make_matrix.py`
+(`python3 make_matrix.py matrix.arrows`): 54 columns covering every type the C
+data interface carries, with nulls in every nullable column, schema metadata,
+and two record batches. The C data battery reads it with `Arrow.Table`, sends
+it through both C interfaces in both directions, and compares the result with
+that IPC read.
diff --git a/test/fixtures-cdata/make_matrix.py b/test/fixtures-cdata/make_matrix.py
new file mode 100644
index 00000000..f4a2c04d
--- /dev/null
+++ b/test/fixtures-cdata/make_matrix.py
@@ -0,0 +1,81 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Builds a pyarrow table covering the C data type matrix and writes it as IPC stream bytes.
+import datetime as dt, decimal, sys
+import pyarrow as pa
+
+n = 7
+def nul(xs):  # every third value null
+    return [None if i % 3 == 1 else x for i, x in enumerate(xs)]
+
+cols = {}
+for t in [pa.int8(), pa.int16(), pa.int32(), pa.int64(), pa.uint8(), pa.uint16(), pa.uint32(), pa.uint64()]:
+    cols[f"{t}"] = pa.array(nul(list(range(n))), type=t)
+cols["float16"] = pa.array(nul([1.5, 2.5, 3.5, 4.5, 5.5, 6.5, 7.5]), type=pa.float32()).cast(pa.float16())
+cols["float32"] = pa.array(nul([1.5 * i for i in range(n)]), type=pa.float32())
+cols["float64"] = pa.array(nul([1.25 * i for i in range(n)]), type=pa.float64())
+cols["bool"] = pa.array(nul([i % 2 == 0 for i in range(n)]), type=pa.bool_())
+cols["null"] = pa.nulls(n)
+words = ["a", "", "héllo", "a much longer string than twelve bytes", "x", "yy", "zzz"]
+cols["utf8"] = pa.array(nul(words), type=pa.string())
+cols["large_utf8"] = pa.array(nul(words), type=pa.large_string())
+cols["utf8_view"] = pa.array(nul(words), type=pa.string_view())
+cols["binary"] = pa.array(nul([w.encode() for w in words]), type=pa.binary())
+cols["large_binary"] = pa.array(nul([w.encode() for w in words]), type=pa.large_binary())
+cols["binary_view"] = pa.array(nul([w.encode() for w in words]), type=pa.binary_view())
+cols["fixed_binary3"] = pa.array(nul([bytes([i, i, i]) for i in range(n)]), type=pa.binary(3))
+cols["date32"] = pa.array(nul([dt.date(2020, 1, 1 + i) for i in range(n)]), type=pa.date32())
+cols["date64"] = pa.array(nul([dt.date(2020, 1, 1 + i) for i in range(n)]), type=pa.date64())
+cols["time32s"] = pa.array(nul([i * 60 for i in range(n)]), type=pa.time32("s"))
+cols["time32ms"] = pa.array(nul([i * 60000 for i in range(n)]), type=pa.time32("ms"))
+cols["time64us"] = pa.array(nul([i * 1000 for i in range(n)]), type=pa.time64("us"))
+cols["time64ns"] = pa.array(nul([i * 1000 for i in range(n)]), type=pa.time64("ns"))
+for u in ["s", "ms", "us", "ns"]:
+    cols[f"ts_{u}"] = pa.array(nul([i * 1000 for i in range(n)]), type=pa.timestamp(u))
+cols["ts_ns_utc"] = pa.array(nul([i * 10**12 for i in range(n)]), type=pa.timestamp("ns", tz="UTC"))
+cols["ts_us_ny"] = pa.array(nul([i * 10**9 for i in range(n)]), type=pa.timestamp("us", tz="America/New_York"))
+cols["ts_ms_offset"] = pa.array(nul([i * 10**6 for i in range(n)]), type=pa.timestamp("ms", tz="+05:30"))
+for u in ["s", "ms", "us", "ns"]:
+    cols[f"dur_{u}"] = pa.array(nul([i * 7 for i in range(n)]), type=pa.duration(u))
+cols["interval_mdn"] = pa.array(nul([pa.scalar((i, i + 1, i * 1000), type=pa.month_day_nano_interval()).as_py() for i in range(n)]), type=pa.month_day_nano_interval())
+cols["decimal128"] = pa.array(nul([decimal.Decimal(f"{i}.{i}5") for i in range(n)]), type=pa.decimal128(10, 3))
+cols["decimal256"] = pa.array(nul([decimal.Decimal(f"-{i}.{i}5") for i in range(n)]), type=pa.decimal256(40, 3))
+cols["decimal32"] = pa.array(nul([decimal.Decimal(f"{i}.5") for i in range(n)]), type=pa.decimal32(5, 1))
+cols["decimal64"] = pa.array(nul([decimal.Decimal(f"{i}.25") for i in range(n)]), type=pa.decimal64(12, 2))
+cols["list_i64"] = pa.array(nul([list(range(i)) for i in range(n)]), type=pa.list_(pa.int64()))
+cols["large_list_str"] = pa.array(nul([[w] * (i % 3) for i, w in enumerate(words)]), type=pa.large_list(pa.string()))
+cols["fixed_list"] = pa.array(nul([[i, i + 1] for i in range(n)]), type=pa.list_(pa.int32(), 2))
+cols["list_view"] = pa.array(nul([list(range(i)) for i in range(n)]), type=pa.list_view(pa.int32()))
+cols["struct"] = pa.array(nul([{"a": i, "b": words[i]} for i in range(n)]), type=pa.struct([("a", pa.int32()), ("b", pa.string())]))
+cols["map"] = pa.array(nul([[(words[i], i)] * (i % 3) for i in range(n)]), type=pa.map_(pa.string(), pa.int64()))
+cols["dict_str"] = pa.array(nul([words[i % 3] for i in range(n)])).dictionary_encode()
+cols["dict_ordered"] = pa.DictionaryArray.from_arrays(pa.array(nul([i % 2 for i in range(n)]), type=pa.int8()), pa.array(["lo", "hi"]), ordered=True)
+cols["sparse_union"] = pa.UnionArray.from_sparse(pa.array([0, 1, 0, 1, 0, 1, 0], type=pa.int8()), [pa.array(list(range(n))), pa.array(words)])
+cols["dense_union"] = pa.UnionArray.from_dense(pa.array([0, 1, 0, 1, 0, 1, 0], type=pa.int8()), pa.array([0, 0, 1, 1, 2, 2, 3], type=pa.int32()), [pa.array([1, 2, 3, 4]), pa.array(["a", "b", "c"])])
+cols["ree"] = pa.RunEndEncodedArray.from_arrays(pa.array([2, 5, 7], type=pa.int32()), pa.array([1.5, None, 3.5]))
+cols["list_struct"] = pa.array(nul([[{"x": i}] * (i % 2) for i in range(n)]), type=pa.list_(pa.struct([("x", pa.int64())])))
+
+tbl = pa.table(cols)
+tbl = tbl.replace_schema_metadata({"origin": "pyarrow", "k": "v"})
+# two batches so stream paths see more than one
+batches = tbl.to_batches(max_chunksize=4)
+sink = pa.BufferOutputStream()
+with pa.ipc.new_stream(sink, tbl.schema) as w:
+    for b in batches:
+        w.write_batch(b)
+open(sys.argv[1], "wb").write(sink.getvalue().to_pybytes())
+print(len(tbl.columns), "columns,", tbl.num_rows, "rows,", len(batches), "batches")
diff --git a/test/fixtures-cdata/matrix.arrows b/test/fixtures-cdata/matrix.arrows
new file mode 100644
index 00000000..d9885975
Binary files /dev/null and b/test/fixtures-cdata/matrix.arrows differ
diff --git a/test/fixtures-dictionaries/README.md b/test/fixtures-dictionaries/README.md
new file mode 100644
index 00000000..8f002d4d
--- /dev/null
+++ b/test/fixtures-dictionaries/README.md
@@ -0,0 +1,31 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements. See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership. The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied. See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+# Dictionary IPC fixtures
+
+Generated with PyArrow 25.0.1 by `test/support/generate_dictionary_fixtures.py`.
+Run the generator from any directory with PyArrow installed. Normal Julia tests
+read these frozen bytes and do not require Python.
+
+The delta fixtures contain three record batches and two delta messages. They
+cover primitive and nested pools, null indices and pool entries, stream and
+file formats, and uncompressed/LZ4/Zstd bodies. The replacement fixtures cover
+issue #610 with V4 and V5 schemas that omit the dictionary replacement feature.
+
+These files are test data produced by the adjacent Apache-licensed generator.
diff --git a/test/fixtures-dictionaries/bool-file-None.arrowbytes b/test/fixtures-dictionaries/bool-file-None.arrowbytes
new file mode 100644
index 00000000..59229272
Binary files /dev/null and b/test/fixtures-dictionaries/bool-file-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/bool-file-lz4.arrowbytes b/test/fixtures-dictionaries/bool-file-lz4.arrowbytes
new file mode 100644
index 00000000..6a34820d
Binary files /dev/null and b/test/fixtures-dictionaries/bool-file-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/bool-file-zstd.arrowbytes b/test/fixtures-dictionaries/bool-file-zstd.arrowbytes
new file mode 100644
index 00000000..51912e89
Binary files /dev/null and b/test/fixtures-dictionaries/bool-file-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/bool-stream-None.arrowbytes b/test/fixtures-dictionaries/bool-stream-None.arrowbytes
new file mode 100644
index 00000000..dba77090
Binary files /dev/null and b/test/fixtures-dictionaries/bool-stream-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/bool-stream-lz4.arrowbytes b/test/fixtures-dictionaries/bool-stream-lz4.arrowbytes
new file mode 100644
index 00000000..7679450f
Binary files /dev/null and b/test/fixtures-dictionaries/bool-stream-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/bool-stream-zstd.arrowbytes b/test/fixtures-dictionaries/bool-stream-zstd.arrowbytes
new file mode 100644
index 00000000..8aee6f05
Binary files /dev/null and b/test/fixtures-dictionaries/bool-stream-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/delta-V4-file.arrowbytes b/test/fixtures-dictionaries/delta-V4-file.arrowbytes
new file mode 100644
index 00000000..e85acb72
Binary files /dev/null and b/test/fixtures-dictionaries/delta-V4-file.arrowbytes differ
diff --git a/test/fixtures-dictionaries/delta-V4-stream.arrowbytes b/test/fixtures-dictionaries/delta-V4-stream.arrowbytes
new file mode 100644
index 00000000..c860e46e
Binary files /dev/null and b/test/fixtures-dictionaries/delta-V4-stream.arrowbytes differ
diff --git a/test/fixtures-dictionaries/int-file-None.arrowbytes b/test/fixtures-dictionaries/int-file-None.arrowbytes
new file mode 100644
index 00000000..81828036
Binary files /dev/null and b/test/fixtures-dictionaries/int-file-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/int-file-lz4.arrowbytes b/test/fixtures-dictionaries/int-file-lz4.arrowbytes
new file mode 100644
index 00000000..61950576
Binary files /dev/null and b/test/fixtures-dictionaries/int-file-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/int-file-zstd.arrowbytes b/test/fixtures-dictionaries/int-file-zstd.arrowbytes
new file mode 100644
index 00000000..b928db47
Binary files /dev/null and b/test/fixtures-dictionaries/int-file-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/int-stream-None.arrowbytes b/test/fixtures-dictionaries/int-stream-None.arrowbytes
new file mode 100644
index 00000000..249bc5e6
Binary files /dev/null and b/test/fixtures-dictionaries/int-stream-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/int-stream-lz4.arrowbytes b/test/fixtures-dictionaries/int-stream-lz4.arrowbytes
new file mode 100644
index 00000000..a0c8a89b
Binary files /dev/null and b/test/fixtures-dictionaries/int-stream-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/int-stream-zstd.arrowbytes b/test/fixtures-dictionaries/int-stream-zstd.arrowbytes
new file mode 100644
index 00000000..0b2719a1
Binary files /dev/null and b/test/fixtures-dictionaries/int-stream-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/list-file-None.arrowbytes b/test/fixtures-dictionaries/list-file-None.arrowbytes
new file mode 100644
index 00000000..81b0ff74
Binary files /dev/null and b/test/fixtures-dictionaries/list-file-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/list-file-lz4.arrowbytes b/test/fixtures-dictionaries/list-file-lz4.arrowbytes
new file mode 100644
index 00000000..2be757f3
Binary files /dev/null and b/test/fixtures-dictionaries/list-file-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/list-file-zstd.arrowbytes b/test/fixtures-dictionaries/list-file-zstd.arrowbytes
new file mode 100644
index 00000000..b8b1a707
Binary files /dev/null and b/test/fixtures-dictionaries/list-file-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/list-stream-None.arrowbytes b/test/fixtures-dictionaries/list-stream-None.arrowbytes
new file mode 100644
index 00000000..c0a8b02f
Binary files /dev/null and b/test/fixtures-dictionaries/list-stream-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/list-stream-lz4.arrowbytes b/test/fixtures-dictionaries/list-stream-lz4.arrowbytes
new file mode 100644
index 00000000..04355731
Binary files /dev/null and b/test/fixtures-dictionaries/list-stream-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/list-stream-zstd.arrowbytes b/test/fixtures-dictionaries/list-stream-zstd.arrowbytes
new file mode 100644
index 00000000..23465182
Binary files /dev/null and b/test/fixtures-dictionaries/list-stream-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/replacement-V4.arrowbytes b/test/fixtures-dictionaries/replacement-V4.arrowbytes
new file mode 100644
index 00000000..537a9fa6
Binary files /dev/null and b/test/fixtures-dictionaries/replacement-V4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/replacement-V5.arrowbytes b/test/fixtures-dictionaries/replacement-V5.arrowbytes
new file mode 100644
index 00000000..d337f124
Binary files /dev/null and b/test/fixtures-dictionaries/replacement-V5.arrowbytes differ
diff --git a/test/fixtures-dictionaries/strings-file-None.arrowbytes b/test/fixtures-dictionaries/strings-file-None.arrowbytes
new file mode 100644
index 00000000..4d4d2265
Binary files /dev/null and b/test/fixtures-dictionaries/strings-file-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/strings-file-lz4.arrowbytes b/test/fixtures-dictionaries/strings-file-lz4.arrowbytes
new file mode 100644
index 00000000..74aeca3f
Binary files /dev/null and b/test/fixtures-dictionaries/strings-file-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/strings-file-zstd.arrowbytes b/test/fixtures-dictionaries/strings-file-zstd.arrowbytes
new file mode 100644
index 00000000..be5ae8cb
Binary files /dev/null and b/test/fixtures-dictionaries/strings-file-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/strings-stream-None.arrowbytes b/test/fixtures-dictionaries/strings-stream-None.arrowbytes
new file mode 100644
index 00000000..e71500d0
Binary files /dev/null and b/test/fixtures-dictionaries/strings-stream-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/strings-stream-lz4.arrowbytes b/test/fixtures-dictionaries/strings-stream-lz4.arrowbytes
new file mode 100644
index 00000000..22f249bc
Binary files /dev/null and b/test/fixtures-dictionaries/strings-stream-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/strings-stream-zstd.arrowbytes b/test/fixtures-dictionaries/strings-stream-zstd.arrowbytes
new file mode 100644
index 00000000..c8625dbd
Binary files /dev/null and b/test/fixtures-dictionaries/strings-stream-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/struct-file-None.arrowbytes b/test/fixtures-dictionaries/struct-file-None.arrowbytes
new file mode 100644
index 00000000..41100938
Binary files /dev/null and b/test/fixtures-dictionaries/struct-file-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/struct-file-lz4.arrowbytes b/test/fixtures-dictionaries/struct-file-lz4.arrowbytes
new file mode 100644
index 00000000..bcf3e9c1
Binary files /dev/null and b/test/fixtures-dictionaries/struct-file-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/struct-file-zstd.arrowbytes b/test/fixtures-dictionaries/struct-file-zstd.arrowbytes
new file mode 100644
index 00000000..8f8088a4
Binary files /dev/null and b/test/fixtures-dictionaries/struct-file-zstd.arrowbytes differ
diff --git a/test/fixtures-dictionaries/struct-stream-None.arrowbytes b/test/fixtures-dictionaries/struct-stream-None.arrowbytes
new file mode 100644
index 00000000..18229099
Binary files /dev/null and b/test/fixtures-dictionaries/struct-stream-None.arrowbytes differ
diff --git a/test/fixtures-dictionaries/struct-stream-lz4.arrowbytes b/test/fixtures-dictionaries/struct-stream-lz4.arrowbytes
new file mode 100644
index 00000000..c6c9bd2c
Binary files /dev/null and b/test/fixtures-dictionaries/struct-stream-lz4.arrowbytes differ
diff --git a/test/fixtures-dictionaries/struct-stream-zstd.arrowbytes b/test/fixtures-dictionaries/struct-stream-zstd.arrowbytes
new file mode 100644
index 00000000..a30bebec
Binary files /dev/null and b/test/fixtures-dictionaries/struct-stream-zstd.arrowbytes differ
diff --git a/test/fixtures-polars/README.md b/test/fixtures-polars/README.md
new file mode 100644
index 00000000..82dabf22
--- /dev/null
+++ b/test/fixtures-polars/README.md
@@ -0,0 +1,32 @@
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one
+  or more contributor license agreements. See the NOTICE file
+  distributed with this work for additional information
+  regarding copyright ownership. The ASF licenses this file
+  to you under the Apache License, Version 2.0 (the
+  "License"); you may not use this file except in compliance
+  with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing,
+  software distributed under the License is distributed on an
+  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+  KIND, either express or implied. See the License for the
+  specific language governing permissions and limitations
+  under the License.
+-->
+
+
+# Polars IPC fixtures
+
+Generated with Polars 1.43.2 by `test/support/generate_polars_fixtures.py`.
+Normal Julia tests read these frozen bytes and do not require Python.
+
+Polars writes the IPC file format with string views, `large_list`, and
+`uint32` dictionary indices, and writes the leading Schema message without
+the stream framing the format specifies; readers take the schema from the
+footer. `int128.arrowbytes` holds Polars' 128-bit integers, which use the
+non-standard integer bit width 128.
+
+These files are test data produced by the adjacent Apache-licensed generator.
diff --git a/test/fixtures-polars/default.arrowbytes b/test/fixtures-polars/default.arrowbytes
new file mode 100644
index 00000000..1d2ef5e0
Binary files /dev/null and b/test/fixtures-polars/default.arrowbytes differ
diff --git a/test/fixtures-polars/int128.arrowbytes b/test/fixtures-polars/int128.arrowbytes
new file mode 100644
index 00000000..25ede010
Binary files /dev/null and b/test/fixtures-polars/int128.arrowbytes differ
diff --git a/test/fixtures-polars/lz4.arrowbytes b/test/fixtures-polars/lz4.arrowbytes
new file mode 100644
index 00000000..5fc286ed
Binary files /dev/null and b/test/fixtures-polars/lz4.arrowbytes differ
diff --git a/test/fixtures-polars/stream.arrowbytes b/test/fixtures-polars/stream.arrowbytes
new file mode 100644
index 00000000..32ad82b5
Binary files /dev/null and b/test/fixtures-polars/stream.arrowbytes differ
diff --git a/test/fixtures-polars/zstd.arrowbytes b/test/fixtures-polars/zstd.arrowbytes
new file mode 100644
index 00000000..8db8bd77
Binary files /dev/null and b/test/fixtures-polars/zstd.arrowbytes differ
diff --git a/test/fixtures2x/all-null-dict.arrowbytes b/test/fixtures2x/all-null-dict.arrowbytes
new file mode 100644
index 00000000..793208cd
Binary files /dev/null and b/test/fixtures2x/all-null-dict.arrowbytes differ
diff --git a/test/fixtures2x/categorical-column.arrowbytes b/test/fixtures2x/categorical-column.arrowbytes
new file mode 100644
index 00000000..ecd84215
Binary files /dev/null and b/test/fixtures2x/categorical-column.arrowbytes differ
diff --git a/test/fixtures2x/categorical-missing.arrowbytes b/test/fixtures2x/categorical-missing.arrowbytes
new file mode 100644
index 00000000..fb89aad4
Binary files /dev/null and b/test/fixtures2x/categorical-missing.arrowbytes differ
diff --git a/test/fixtures2x/colmeta-plain.arrowbytes b/test/fixtures2x/colmeta-plain.arrowbytes
new file mode 100644
index 00000000..ad0ad034
Binary files /dev/null and b/test/fixtures2x/colmeta-plain.arrowbytes differ
diff --git a/test/fixtures2x/decimal-over-precision.arrowbytes b/test/fixtures2x/decimal-over-precision.arrowbytes
new file mode 100644
index 00000000..fa6a806b
Binary files /dev/null and b/test/fixtures2x/decimal-over-precision.arrowbytes differ
diff --git a/test/fixtures2x/dict-ext-metadata.arrowbytes b/test/fixtures2x/dict-ext-metadata.arrowbytes
new file mode 100644
index 00000000..43bed36f
Binary files /dev/null and b/test/fixtures2x/dict-ext-metadata.arrowbytes differ
diff --git a/test/fixtures2x/dict-replacement-first.arrowbytes b/test/fixtures2x/dict-replacement-first.arrowbytes
new file mode 100644
index 00000000..a3e598f0
Binary files /dev/null and b/test/fixtures2x/dict-replacement-first.arrowbytes differ
diff --git a/test/fixtures2x/dict-replacement-second.arrowbytes b/test/fixtures2x/dict-replacement-second.arrowbytes
new file mode 100644
index 00000000..4548b55a
Binary files /dev/null and b/test/fixtures2x/dict-replacement-second.arrowbytes differ
diff --git a/test/fixtures2x/empty-dict.arrowbytes b/test/fixtures2x/empty-dict.arrowbytes
new file mode 100644
index 00000000..1697466b
Binary files /dev/null and b/test/fixtures2x/empty-dict.arrowbytes differ
diff --git a/test/fixtures2x/empty-string-list.arrowbytes b/test/fixtures2x/empty-string-list.arrowbytes
new file mode 100644
index 00000000..e839eea5
Binary files /dev/null and b/test/fixtures2x/empty-string-list.arrowbytes differ
diff --git a/test/fixtures2x/float-zero-signs-nan.arrowbytes b/test/fixtures2x/float-zero-signs-nan.arrowbytes
new file mode 100644
index 00000000..2fba7fa5
Binary files /dev/null and b/test/fixtures2x/float-zero-signs-nan.arrowbytes differ
diff --git a/test/fixtures2x/incompressible-bytes.arrowbytes b/test/fixtures2x/incompressible-bytes.arrowbytes
new file mode 100644
index 00000000..8bd9fb05
Binary files /dev/null and b/test/fixtures2x/incompressible-bytes.arrowbytes differ
diff --git a/test/fixtures2x/int64-empty-lz4.arrowbytes b/test/fixtures2x/int64-empty-lz4.arrowbytes
new file mode 100644
index 00000000..6d5ed1c2
Binary files /dev/null and b/test/fixtures2x/int64-empty-lz4.arrowbytes differ
diff --git a/test/fixtures2x/int64-empty-zstd.arrowbytes b/test/fixtures2x/int64-empty-zstd.arrowbytes
new file mode 100644
index 00000000..a2dc49e9
Binary files /dev/null and b/test/fixtures2x/int64-empty-zstd.arrowbytes differ
diff --git a/test/fixtures2x/int64-empty.arrowbytes b/test/fixtures2x/int64-empty.arrowbytes
new file mode 100644
index 00000000..2e693746
Binary files /dev/null and b/test/fixtures2x/int64-empty.arrowbytes differ
diff --git a/test/fixtures2x/int64-strings-two-batches.arrowbytes b/test/fixtures2x/int64-strings-two-batches.arrowbytes
new file mode 100644
index 00000000..177009d4
Binary files /dev/null and b/test/fixtures2x/int64-strings-two-batches.arrowbytes differ
diff --git a/test/fixtures2x/int64-ten-thousand.arrowbytes b/test/fixtures2x/int64-ten-thousand.arrowbytes
new file mode 100644
index 00000000..37bcdca8
Binary files /dev/null and b/test/fixtures2x/int64-ten-thousand.arrowbytes differ
diff --git a/test/fixtures2x/int64-three-zstd.arrowbytes b/test/fixtures2x/int64-three-zstd.arrowbytes
new file mode 100644
index 00000000..e4f3f29c
Binary files /dev/null and b/test/fixtures2x/int64-three-zstd.arrowbytes differ
diff --git a/test/fixtures2x/int64-three.arrowbytes b/test/fixtures2x/int64-three.arrowbytes
new file mode 100644
index 00000000..0c2e2cad
Binary files /dev/null and b/test/fixtures2x/int64-three.arrowbytes differ
diff --git a/test/fixtures2x/int64-two-batches.arrowbytes b/test/fixtures2x/int64-two-batches.arrowbytes
new file mode 100644
index 00000000..f9cfa016
Binary files /dev/null and b/test/fixtures2x/int64-two-batches.arrowbytes differ
diff --git a/test/fixtures2x/large-zeros-two-partitions.arrowbytes b/test/fixtures2x/large-zeros-two-partitions.arrowbytes
new file mode 100644
index 00000000..04f676e2
Binary files /dev/null and b/test/fixtures2x/large-zeros-two-partitions.arrowbytes differ
diff --git a/test/fixtures2x/large-zeros-zstd-two-partitions.arrowbytes b/test/fixtures2x/large-zeros-zstd-two-partitions.arrowbytes
new file mode 100644
index 00000000..f9df8b69
Binary files /dev/null and b/test/fixtures2x/large-zeros-zstd-two-partitions.arrowbytes differ
diff --git a/test/fixtures2x/large-zeros-zstd.arrowbytes b/test/fixtures2x/large-zeros-zstd.arrowbytes
new file mode 100644
index 00000000..9e3f4157
Binary files /dev/null and b/test/fixtures2x/large-zeros-zstd.arrowbytes differ
diff --git a/test/fixtures2x/map-default-keyssorted.arrowbytes b/test/fixtures2x/map-default-keyssorted.arrowbytes
new file mode 100644
index 00000000..77d16241
Binary files /dev/null and b/test/fixtures2x/map-default-keyssorted.arrowbytes differ
diff --git a/test/fixtures2x/mixed-two-partitions-file.arrowbytes b/test/fixtures2x/mixed-two-partitions-file.arrowbytes
new file mode 100644
index 00000000..0e240b35
Binary files /dev/null and b/test/fixtures2x/mixed-two-partitions-file.arrowbytes differ
diff --git a/test/fixtures2x/mixed-two-partitions-lz4.arrowbytes b/test/fixtures2x/mixed-two-partitions-lz4.arrowbytes
new file mode 100644
index 00000000..7892ee92
Binary files /dev/null and b/test/fixtures2x/mixed-two-partitions-lz4.arrowbytes differ
diff --git a/test/fixtures2x/mixed-two-partitions-zstd.arrowbytes b/test/fixtures2x/mixed-two-partitions-zstd.arrowbytes
new file mode 100644
index 00000000..c6ce8a8f
Binary files /dev/null and b/test/fixtures2x/mixed-two-partitions-zstd.arrowbytes differ
diff --git a/test/fixtures2x/mixed-two-partitions.arrowbytes b/test/fixtures2x/mixed-two-partitions.arrowbytes
new file mode 100644
index 00000000..d16ab19e
Binary files /dev/null and b/test/fixtures2x/mixed-two-partitions.arrowbytes differ
diff --git a/test/fixtures2x/null-column-zero-rows.arrowbytes b/test/fixtures2x/null-column-zero-rows.arrowbytes
new file mode 100644
index 00000000..07a27ceb
Binary files /dev/null and b/test/fixtures2x/null-column-zero-rows.arrowbytes differ
diff --git a/test/fixtures2x/nullable-int64-sixteen.arrowbytes b/test/fixtures2x/nullable-int64-sixteen.arrowbytes
new file mode 100644
index 00000000..3b35c541
Binary files /dev/null and b/test/fixtures2x/nullable-int64-sixteen.arrowbytes differ
diff --git a/test/fixtures2x/nullable-struct-child.arrowbytes b/test/fixtures2x/nullable-struct-child.arrowbytes
new file mode 100644
index 00000000..22508a6d
Binary files /dev/null and b/test/fixtures2x/nullable-struct-child.arrowbytes differ
diff --git a/test/fixtures2x/pooled-view-dict.arrowbytes b/test/fixtures2x/pooled-view-dict.arrowbytes
new file mode 100644
index 00000000..0f0549da
Binary files /dev/null and b/test/fixtures2x/pooled-view-dict.arrowbytes differ
diff --git a/test/fixtures2x/schema-field-metadata.arrowbytes b/test/fixtures2x/schema-field-metadata.arrowbytes
new file mode 100644
index 00000000..7e264112
Binary files /dev/null and b/test/fixtures2x/schema-field-metadata.arrowbytes differ
diff --git a/test/fixtures2x/shared-nested-dict.arrowbytes b/test/fixtures2x/shared-nested-dict.arrowbytes
new file mode 100644
index 00000000..dbcabd50
Binary files /dev/null and b/test/fixtures2x/shared-nested-dict.arrowbytes differ
diff --git a/test/fixtures2x/single-string.arrowbytes b/test/fixtures2x/single-string.arrowbytes
new file mode 100644
index 00000000..c538b517
Binary files /dev/null and b/test/fixtures2x/single-string.arrowbytes differ
diff --git a/test/fixtures2x/stats-two-batches.arrowbytes b/test/fixtures2x/stats-two-batches.arrowbytes
new file mode 100644
index 00000000..95d5ca1d
Binary files /dev/null and b/test/fixtures2x/stats-two-batches.arrowbytes differ
diff --git a/test/fixtures2x/stats-wrong-schema.arrowbytes b/test/fixtures2x/stats-wrong-schema.arrowbytes
new file mode 100644
index 00000000..85216858
Binary files /dev/null and b/test/fixtures2x/stats-wrong-schema.arrowbytes differ
diff --git a/test/fixtures2x/two-int64-columns.arrowbytes b/test/fixtures2x/two-int64-columns.arrowbytes
new file mode 100644
index 00000000..7246b266
Binary files /dev/null and b/test/fixtures2x/two-int64-columns.arrowbytes differ
diff --git a/test/fixtures2x/union-dense.arrowbytes b/test/fixtures2x/union-dense.arrowbytes
new file mode 100644
index 00000000..113b1d67
Binary files /dev/null and b/test/fixtures2x/union-dense.arrowbytes differ
diff --git a/test/fixtures2x/union-sparse.arrowbytes b/test/fixtures2x/union-sparse.arrowbytes
new file mode 100644
index 00000000..a4200b0f
Binary files /dev/null and b/test/fixtures2x/union-sparse.arrowbytes differ
diff --git a/test/fixtures2x/wide-two-batches.arrowbytes b/test/fixtures2x/wide-two-batches.arrowbytes
new file mode 100644
index 00000000..22ad32c0
Binary files /dev/null and b/test/fixtures2x/wide-two-batches.arrowbytes differ
diff --git a/test/fuzz.jl b/test/fuzz.jl
new file mode 100644
index 00000000..212efc8f
--- /dev/null
+++ b/test/fuzz.jl
@@ -0,0 +1,163 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Standalone seeded fuzz driver over the public IPC read paths: run
+# `julia --project=. test/fuzz.jl --help` for the lanes and replay options.
+
+include(joinpath(@__DIR__, "support", "SeededFuzz.jl"))
+import .SeededFuzz
+
+const MAX_REPLAY_BYTES = 8 * 1024 * 1024
+
+function _readmutation(path::AbstractString)
+    filesize(path) <= MAX_REPLAY_BYTES ||
+        throw(ArgumentError("mutation file exceeds the 8 MiB replay limit: $path"))
+    bytes = open(path, "r") do io
+        read(io, MAX_REPLAY_BYTES + 1)
+    end
+    length(bytes) <= MAX_REPLAY_BYTES ||
+        throw(ArgumentError("mutation file grew beyond the 8 MiB replay limit: $path"))
+    return bytes
+end
+
+function _usage(io::IO=stdout)
+    println(
+        io,
+        """
+        Usage: julia --project=. test/fuzz.jl [options]
+
+          --seed VALUE       Master UInt64 seed (decimal or 0x-prefixed hex)
+          --cases N          Differential cases (default: $(SeededFuzz.EXTENDED_CASES))
+          --mutations N      Byte mutations (default: $(SeededFuzz.EXTENDED_MUTATIONS))
+          --case-index N     Replay exactly one generated differential case
+          --mutation-index N Replay exactly one generated byte mutation
+          --mutation-file P  Replay saved bytes instead of generating a case
+          --mutation-lane L  stream_full, file_full, file_ranged, or auto_full
+          --layouts-only     Run only the deterministic layout-family lanes
+          --skip-layouts     Skip layout-family lanes during an exact replay
+          --determinism-every N
+                             Repeat every Nth mutation plus the first route sweep
+          --repro-dir PATH   Write deterministic failure artifacts to PATH
+          --help             Show this help
+
+        Set either count to zero to skip that generated lane. Saved-byte mode
+        requires --mutation-lane and does not run generated lanes.
+        """,
+    )
+    return nothing
+end
+
+_parseargs(args) = SeededFuzz.parse_options(args)
+
+function _printmutationcounts(summary::SeededFuzz.MutationSummary)
+    entries = sort!(collect(summary.counts); by=entry -> String(first(entry)))
+    println("mutation classifications:")
+    for (category, count) in entries
+        println("  $category: $count")
+    end
+    println("mutation routes covered: $(length(summary.routecounts))")
+    println("mutation determinism checks: $(summary.determinismchecks)")
+    operations = sort!(collect(summary.operationcounts); by=entry -> String(first(entry)))
+    println("mutation operations:")
+    for (operation, count) in operations
+        println("  $operation: $count")
+    end
+    return nothing
+end
+
+function main(args=ARGS)
+    options = try
+        _parseargs(args)
+    catch err
+        err isa ArgumentError || rethrow()
+        showerror(stderr, err)
+        println(stderr)
+        _usage(stderr)
+        return 2
+    end
+    if options.help
+        _usage()
+        return 0
+    end
+
+    println("$(SeededFuzz._environmenttext())")
+    if options.mutation_file !== nothing
+        path = abspath(options.mutation_file)
+        isfile(path) || throw(ArgumentError("mutation file does not exist: $path"))
+        result = SeededFuzz.replay_mutation(_readmutation(path), options.mutation_lane)
+        println("saved mutation: $path")
+        println("mutation lane: $(options.mutation_lane)")
+        println("mutation determinism replay: enabled")
+        println("classification: $(result.category)")
+        result.details === nothing || println(result.details)
+        return result.category === :unexpected ? 1 : 0
+    end
+
+    cases = options.layouts_only ? 0 : options.cases
+    mutations = options.layouts_only ? 0 : options.mutations
+    displayedcases = options.case_index === nothing ? cases : 1
+    displayedmutations = options.mutation_index === nothing ? mutations : 1
+
+    println("seed: 0x$(string(options.seed; base=16))")
+    println("differential cases: $displayedcases")
+    options.case_index === nothing || begin
+        println("differential replay index: $(options.case_index)")
+        println(
+            "differential fingerprint: 0x$(string(SeededFuzz.case_fingerprint(options.seed, options.case_index); base=16))",
+        )
+    end
+    println("byte mutations: $displayedmutations")
+    options.mutation_index === nothing ||
+        println("mutation replay index: $(options.mutation_index)")
+    options.verify_determinism && println("mutation determinism replay: enabled")
+    options.determinism_every > 0 && println(
+        "mutation determinism sample: every $(options.determinism_every), plus route sweep",
+    )
+    println("layout-family lanes: $(options.include_layouts ? "enabled" : "disabled")")
+    options.reproduction_dir === nothing ||
+        println("failure artifacts: $(abspath(options.reproduction_dir))")
+
+    summary = SeededFuzz.run_suite(;
+        seed=options.seed,
+        cases,
+        mutations,
+        case_index=options.case_index,
+        mutation_index=options.mutation_index,
+        include_layouts=options.include_layouts,
+        reproduction_dir=options.reproduction_dir,
+        verify_determinism=options.verify_determinism,
+        determinism_every=options.determinism_every,
+        progress_io=stdout,
+    )
+    differential = summary.differential
+    println(
+        "differential summary: cases=$(differential.cases) " *
+        "variants=$(differential.variants) rewrites=$(differential.rewrites) " *
+        "scan_checks=$(differential.scanchecks) layout_checks=$(differential.layoutchecks)",
+    )
+    println(
+        "differential coverage: " *
+        join(sort!(String.(collect(differential.coverage))), ", "),
+    )
+
+    _printmutationcounts(summary.mutations)
+    println("fuzz run complete")
+    return 0
+end
+
+if abspath(PROGRAM_FILE) == @__FILE__
+    exit(main())
+end
diff --git a/test/incremental_writer_tests.jl b/test/incremental_writer_tests.jl
new file mode 100644
index 00000000..23610071
--- /dev/null
+++ b/test/incremental_writer_tests.jl
@@ -0,0 +1,957 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The incremental writer (Arrow.Writer) and stream append (Arrow.append):
+# byte parity with the eager writer, fixed-schema conformance, dictionary
+# rules per format, close semantics, and appends to 2.x-written streams.
+
+module IncrementalWriterTests
+
+using Test
+using Dates
+using Tables
+using Arrow
+using PooledArrays
+import ArrowTypes
+import CategoricalArrays
+import DataAPI
+
+const AC = Arrow.ArrowCore
+
+# A labelled value stored as Union{Nothing,String}: its Null child holds `nothing`.
+struct MaybeLabel
+    value::Union{Nothing,String}
+end
+const MAYBE_LABEL = Symbol("JuliaLang.ArrowTests.WriterMaybe")
+ArrowTypes.ArrowType(::Type{MaybeLabel}) = Union{Nothing,String}
+ArrowTypes.toarrow(x::MaybeLabel) = x.value
+ArrowTypes.arrowname(::Type{MaybeLabel}) = MAYBE_LABEL
+ArrowTypes.JuliaType(::Val{MAYBE_LABEL}, S, metadata) = MaybeLabel
+ArrowTypes.fromarrow(::Type{MaybeLabel}, ::Nothing) = MaybeLabel(nothing)
+ArrowTypes.fromarrow(::Type{MaybeLabel}, x::AbstractString) = MaybeLabel(String(x))
+
+# A labelled value stored as Union{Int64,String}.
+struct EitherLabel
+    value::Union{Int64,String}
+end
+const EITHER_LABEL = Symbol("JuliaLang.ArrowTests.WriterEither")
+ArrowTypes.ArrowType(::Type{EitherLabel}) = Union{Int64,String}
+ArrowTypes.toarrow(x::EitherLabel) = x.value
+ArrowTypes.arrowname(::Type{EitherLabel}) = EITHER_LABEL
+ArrowTypes.JuliaType(::Val{EITHER_LABEL}, S, metadata) = EitherLabel
+ArrowTypes.fromarrow(::Type{EitherLabel}, x::Int64) = EitherLabel(x)
+ArrowTypes.fromarrow(::Type{EitherLabel}, x::AbstractString) = EitherLabel(String(x))
+
+# A labelled value stored as Nothing: a Null field labelled for it holds it.
+struct UnitLabel end
+const UNIT_LABEL = Symbol("JuliaLang.ArrowTests.WriterUnit")
+ArrowTypes.ArrowType(::Type{UnitLabel}) = Nothing
+ArrowTypes.toarrow(::UnitLabel) = nothing
+ArrowTypes.arrowname(::Type{UnitLabel}) = UNIT_LABEL
+ArrowTypes.JuliaType(::Val{UNIT_LABEL}, S, metadata) = UnitLabel
+ArrowTypes.fromarrow(::Type{UnitLabel}, ::Union{Nothing,Missing}) = UnitLabel()
+
+# The output of `tables` written through one Arrow.Writer, and each table's
+# error (or nothing).
+function writetables(tables; kwargs...)
+    io = IOBuffer()
+    errs = Any[]
+    Arrow.Writer(io; kwargs...) do w
+        for t in tables
+            push!(errs, try
+                Arrow.write(w, t)
+                nothing
+            catch err
+                err
+            end)
+        end
+    end
+    return take!(io), errs
+end
+refused(err, name) = err isa ArgumentError && occursin("column $name", err.msg)
+# Field `a` of each row of a struct column (a NamedTuple or an ordered Pair vector).
+fielda(r) = r === missing ? missing : r isa NamedTuple ? r.a : last(only(r))
+
+# A producer may refill its buffers once the consumer asks for another partition.
+struct ReusedPartitions{Known,F}
+    values::Vector{Int}
+    count::Int
+    before_next::F
+end
+Tables.partitions(p::ReusedPartitions) = p
+Base.IteratorSize(::Type{<:ReusedPartitions{true}}) = Base.HasLength()
+Base.IteratorSize(::Type{<:ReusedPartitions{false}}) = Base.SizeUnknown()
+Base.length(p::ReusedPartitions) = p.count
+function Base.iterate(p::ReusedPartitions, i=1)
+    p.before_next(i)
+    i > p.count && return nothing
+    fill!(p.values, i)
+    return (; a=p.values), i + 1
+end
+
+# The IPC messages of a stream, or of a file's message section.
+function framedmessages(bytes)
+    if bytes[1:6] == b"ARROW1"
+        footerlen = only(reinterpret(Int32, bytes[(end - 9):(end - 6)]))
+        bytes = bytes[9:(end - 10 - footerlen)]
+    end
+    return Arrow.framemessages(AC.heapregion(bytes))
+end
+
+# (id, isDelta, length) of each dictionary batch, in order.
+dictbatches(bytes) = [
+    (m.msg.header.id, m.msg.header.isDelta, m.msg.header.data.length) for
+    m in framedmessages(bytes) if m.msg.header isa Arrow.Meta.DictionaryBatch
+]
+
+# `k` Writer tables of 20 rows, each adding 20 string categories as a delta.
+function growdictionary(k)
+    io = IOBuffer()
+    Arrow.Writer(io; file=false, dictdeltas=true, dictencode=true) do w
+        for t = 1:k
+            Arrow.write(w, (s=["c$(t)_$i" for i = 1:20],))
+        end
+    end
+    return take!(io)
+end
+growthallocations(k) = @allocated growdictionary(k)
+appendallocations(path, table) = @allocated Arrow.append(path, table)
+# On one task, so buffer reuse does not depend on how threads are scheduled.
+function batchedallocations(t, n)
+    io = IOBuffer(; sizehint=4_000_000)
+    return @allocated Arrow.write(io, t; batchsize=n, ntasks=1)
+end
+
+# A two-row stream of dense union `u` (children Int64 `i` and String `s`,
+# nullable as `nullable` says), or of a nullable struct `t` around it.
+function unionstream(path, nullable; nested=false)
+    (i, id), (s, sd) = AC.fromjulia("i", Int64[1]), AC.fromjulia("s", ["a"])
+    t = AC.UnionType(AC.DenseMode, Int8[0, 1])
+    children = [
+        AC.Field("i", i.type; nullable=nullable[1]),
+        AC.Field("s", s.type; nullable=nullable[2]),
+    ]
+    f = AC.Field("u", t; nullable=true, children)
+    buffers = [AC._databuffer(Int8[0, 1]), AC._databuffer(Int32[0, 0])]
+    d = AC.ArrayData(t, 2, buffers; children=[id, sd], nullcount=0)
+    if nested
+        f = AC.Field("t", AC.StructType(); nullable=true, children=[f])
+        d = AC.ArrayData(AC.StructType(), 2, [AC.BufferSlice()]; children=[d], nullcount=0)
+    end
+    sch = AC.Schema([f])
+    write(path, Arrow.writestream(sch, [AC.RecordBatch(sch, [d], 2)]))
+    return path
+end
+
+# :dictionary or :record for each batch message, in order.
+batchkinds(bytes) = [
+    m.msg.header isa Arrow.Meta.DictionaryBatch ? :dictionary : :record for
+    m in framedmessages(bytes) if !(m.msg.header isa Arrow.Meta.Schema)
+]
+
+@testset "incremental writer and append" begin
+    t1 = (; a=Int64[1, 2], b=["x", "y"])
+    t2 = (; a=Int64[3, 4], b=["z", "w"])
+
+    @testset "partitions publish before their buffers are reused" begin
+        for known in (false, true),
+            file in (false, true),
+            compress in (nothing, :lz4, :zstd)
+
+            io = IOBuffer()
+            part = ReusedPartitions{known,typeof(identity)}(zeros(Int, 32_768), 3, identity)
+            Arrow.write(io, part; file, compress, ntasks=4)
+            @test collect(Arrow.Table(take!(io)).a) == repeat(1:3; inner=32_768)
+        end
+
+        # The producer can depend on the previous batch already being available.
+        io = IOBuffer()
+        before_next = function (i)
+            i == 1 && return
+            pos = position(io)
+            seekstart(io)
+            bytes = read(io)
+            seek(io, pos)
+            @test collect(Arrow.Table(bytes).a) == repeat(1:(i - 1); inner=2)
+        end
+        part = ReusedPartitions{false,typeof(before_next)}([0, 0], 3, before_next)
+        Arrow.write(io, part)
+        @test collect(Arrow.Table(take!(io)).a) == [1, 1, 2, 2, 3, 3]
+
+        # Unknown-length inputs declare nullable fields without reading ahead,
+        # even when this particular iteration happens to yield just one table.
+        for known in (false, true)
+            part = ReusedPartitions{known,typeof(identity)}([0, 0], 1, identity)
+            table = Arrow.Table(take!(Arrow.tobuffer(part)))
+            @test eltype(table.a) === (known ? Int : Union{Missing,Int})
+        end
+
+        for compress in (nothing, :lz4, :zstd)
+            io = Arrow.tobuffer((; a=[0, 0]))
+            part = ReusedPartitions{false,typeof(identity)}([0, 0], 3, identity)
+            Arrow.append(io, part; compress)
+            @test collect(Arrow.Table(take!(io)).a) == [0, 0, 1, 1, 2, 2, 3, 3]
+        end
+    end
+
+    @testset "multi-write output is byte-identical to the eager writer" begin
+        for file in (true, false), compress in (nothing, :zstd)
+            io = IOBuffer()
+            w = Arrow.Writer(io; file=file, compress=compress)
+            Arrow.write(w, t1)
+            Arrow.write(w, t2)
+            close(w)
+            incremental = take!(io)
+            eager = Arrow._writebytes(
+                Tables.partitioner([t1, t2]);
+                file=file,
+                compress=compress,
+            )
+            @test incremental == eager
+            t = Arrow.Table(incremental)
+            @test t.a == [1, 2, 3, 4]
+            @test t.b == ["x", "y", "z", "w"]
+        end
+    end
+
+    @testset "path sink, function form, and open" begin
+        path = joinpath(mktempdir(), "w.arrow")
+        Arrow.Writer(path; compress=:lz4) do w
+            Arrow.write(w, t1)
+            Arrow.write(w, t2)
+        end
+        @test Arrow.Table(path).a == [1, 2, 3, 4]
+        w = open(Arrow.Writer, joinpath(mktempdir(), "w2.arrow"); file=false)
+        @test w isa Arrow.Writer
+        Arrow.write(w, t1)
+        close(w)
+        @test isopen(w) == false
+    end
+
+    @testset "Stream sees one partition per write" begin
+        io = IOBuffer()
+        w = Arrow.Writer(io; file=false)
+        Arrow.write(w, t1)
+        Arrow.write(w, t2)
+        close(w)
+        parts = collect(Arrow.Stream(take!(io)))
+        @test length(parts) == 2
+        @test parts[2].a == [3, 4]
+    end
+
+    @testset "a zero-batch Stream keeps its schema when rewritten" begin
+        io = IOBuffer()
+        Arrow.Writer(io; file=false) do w
+            Arrow.write(w, (; a=Int64[], b=Union{Missing,String}[]))
+        end
+        bytes = take!(io)
+        # Drop the one empty record batch: schema message, then end-of-stream.
+        msgs = Arrow.framemessages(Arrow.ArrowCore.heapregion(bytes))
+        schemaend = msgs[1].body.offset + msgs[1].body.len
+        nobatches = vcat(bytes[1:schemaend], bytes[(end - 7):end])
+        @test isempty(collect(Arrow.Stream(nobatches)))
+
+        for file in (true, false)
+            out = IOBuffer()
+            Arrow.write(
+                out,
+                Arrow.Stream(nobatches);
+                file=file,
+                colmetadata=Dict(:a => ["k" => "v"]),
+            )
+            t = Arrow.Table(take!(out))
+            @test Tables.columnnames(t) == [:a, :b]
+            @test eltype(t.b) == Union{Missing,Arrow.DataStrings.DataString}
+            @test DataAPI.colmetadata(t, :a, "k") == "v"
+        end
+
+        out = IOBuffer()
+        Arrow.Writer(out; file=false) do w
+            Arrow.write(w, Arrow.Stream(nobatches))
+            Arrow.write(w, t1)
+            Arrow.write(w, Arrow.Stream(nobatches))
+        end
+        @test Arrow.Table(take!(out)).a == [1, 2]
+
+        path = joinpath(mktempdir(), "s.arrow")
+        Arrow.write(path, t1; file=false)
+        Arrow.append(path, Arrow.Stream(nobatches))
+        @test Arrow.Table(path).a == [1, 2]
+
+        @test_throws ArgumentError Arrow.write(IOBuffer(), Tables.partitioner(NamedTuple[]))
+
+        # The Writer interns the schema's names under the facade's bounds.
+        longsch = Arrow.ArrowCore.Schema([
+            Arrow.ArrowCore.Field("x"^5000, Arrow.ArrowCore.IntType(64, true)),
+        ])
+        longbytes = Arrow.writestream(longsch, Arrow.ArrowCore.RecordBatch[])
+        @test_throws Arrow.ValidationError Arrow.Writer(IOBuffer(); file=false) do w
+            Arrow.write(w, Arrow.Stream(longbytes))
+        end
+    end
+
+    @testset "writer metadata and colmetadata" begin
+        io = IOBuffer()
+        w = Arrow.Writer(io; metadata=("k" => "v",), colmetadata=Dict(:a => ("c" => "d",)))
+        Arrow.write(w, t1)
+        close(w)
+        t = Arrow.Table(take!(io))
+        @test Arrow.getmetadata(t) == Dict("k" => "v")
+        @test collect(Arrow.DataAPI.colmetadatakeys(t, :a)) == ["c"]
+    end
+
+    @testset "the first write fixes the schema" begin
+        io = IOBuffer()
+        w = Arrow.Writer(io)
+        Arrow.write(w, t1)
+        err = @test_throws ArgumentError Arrow.write(w, (; a=[1], c=["q"]))
+        @test occursin("do not match", err.value.msg)
+        # Lossy type drift is refused, naming the column and both types.
+        err = @test_throws ArgumentError Arrow.write(w, (; a=[1.5], b=["q"]))
+        @test occursin("column a", err.value.msg)
+        @test occursin("double", err.value.msg) && occursin("int64", err.value.msg)
+        # Every field is nullable, so later missing values conform; the
+        # writer stays usable after a refused write.
+        Arrow.write(w, (; a=[missing, 1], b=["q", missing]))
+        Arrow.write(w, t2)
+        close(w)
+        t = Arrow.Table(take!(io))
+        @test isequal(t.a, [1, 2, missing, 1, 3, 4])
+        @test isequal(t.b, ["x", "y", "q", missing, "z", "w"])
+        # nullable=false declares the first table's nullability instead.
+        w = Arrow.Writer(IOBuffer(); nullable=false)
+        Arrow.write(w, t1)
+        err = @test_throws ArgumentError Arrow.write(w, (; a=[missing, 1], b=["q", "r"]))
+        @test occursin("not nullable", err.value.msg)
+        close(w)
+    end
+
+    @testset "later tables widen losslessly" begin
+        for file in (true, false)
+            io = IOBuffer()
+            Arrow.Writer(io; file) do w
+                Arrow.write(w, (; i=Int64[1], f=[1.5], g=[0.5], s=["a"], u=[true]))
+                Arrow.write(
+                    w,
+                    (; i=Int32[2], f=Float32[2.5], g=Int16[3], s=[missing], u=[false]),
+                )
+                Arrow.write(
+                    w,
+                    (; i=[missing], f=[missing], g=[missing], s=[missing], u=[missing]),
+                )
+            end
+            t = Arrow.Table(take!(io))
+            @test isequal(collect(t.i), [1, 2, missing])
+            @test isequal(collect(t.f), [1.5, 2.5, missing])
+            @test isequal(collect(t.g), [0.5, 3.0, missing])
+            @test isequal(collect(t.s), ["a", missing, missing])
+            @test isequal(collect(t.u), [true, false, missing])
+            @test eltype(t.i) == Union{Missing,Int64}
+        end
+        # Narrowing (Int64 into Int32) is refused.
+        w = Arrow.Writer(IOBuffer())
+        Arrow.write(w, (; i=Int32[1]))
+        err = @test_throws ArgumentError Arrow.write(w, (; i=Int64[2]))
+        @test occursin("column i", err.value.msg)
+        close(w)
+    end
+
+    @testset "a zero-row typed first write pins the schema" begin
+        io = IOBuffer()
+        w = Arrow.Writer(io; file=false)
+        Arrow.write(w, (; a=Union{Missing,Int64}[], b=String[]))
+        Arrow.write(w, (; a=[missing, 2], b=["x", "y"]))
+        close(w)
+        t = Arrow.Table(take!(io))
+        @test eltype(t.a) == Union{Missing,Int64}
+        @test isequal(t.a, [missing, 2])
+    end
+
+    @testset "later tables take the first table's Julia value types" begin
+        # Later tables are built like later partitions of one eager write, so
+        # writer values the retained public domain does not use still conform.
+        cols = (;
+            dt=[DateTime(2026), DateTime(2027)],
+            s=[SubString("ab", 1, 1), SubString("ab", 2, 2)],
+            nt=[(a=1, b="x"), (a=2, b="y")],
+            tup=[(1, 2), (3, 4)],
+            d=[Dict("k" => 1), Dict("k" => 2)],
+        )
+        for file in (true, false)
+            io = IOBuffer()
+            Arrow.Writer(io; file=file) do w
+                Arrow.write(w, cols)
+                return Arrow.write(w, cols)
+            end
+            @test take!(io) ==
+                  Arrow._writebytes(Tables.partitioner([cols, cols]); file=file)
+        end
+        path = joinpath(mktempdir(), "values.arrow")
+        Arrow.write(path, cols; file=false)
+        Arrow.append(path, cols)
+        t = Arrow.Table(path)
+        @test t.dt == repeat(cols.dt, 2)
+        @test t.s == ["a", "b", "a", "b"]
+        # A non-conforming later table names the difference.
+        io = IOBuffer()
+        w = Arrow.Writer(io)
+        Arrow.write(w, (; nt=[(a=1, b="x")]))
+        err = @test_throws ArgumentError Arrow.write(w, (; nt=[(b="x", a=1)]))
+        @test occursin("does not conform", err.value.msg)
+        close(w)
+    end
+
+    @testset "append DateTime values to an Arrow 2.x labelled timestamp" begin
+        # Arrow 2.x labelled every DateTime column JuliaLang.DateTime; fresh
+        # DateTime values lower exactly into the retained descriptor.
+        ms = AC.TimestampType(AC.MILLISECOND, nothing)
+        meta = [
+            "ARROW:extension:name" => "JuliaLang.DateTime",
+            "ARROW:extension:metadata" => "",
+        ]
+        f = AC.Field("dt", ms; nullable=true, metadata=meta)
+        d = AC.ArrayData(ms, 1, [AC.BufferSlice(), AC._databuffer(Int64[0])]; nullcount=0)
+        sch = AC.Schema([f])
+        path = joinpath(mktempdir(), "dt.arrow")
+        write(path, Arrow.writestream(sch, [AC.RecordBatch(sch, [d])]))
+        Arrow.append(path, (; dt=[DateTime(2026, 1, 2, 3)]))
+        @test Arrow.Table(path).dt == [DateTime(1970), DateTime(2026, 1, 2, 3)]
+    end
+
+    @testset "dictionaries grow across tables in both formats" begin
+        for file in (true, false),
+            dictdeltas in (false, true),
+            mk in (Arrow.DictEncode, PooledArray)
+
+            io = IOBuffer()
+            Arrow.Writer(io; file, dictdeltas) do w
+                Arrow.write(w, (; d=mk(["a", "b", "a"])))
+                Arrow.write(w, (; d=mk(["c", "c", "b"])))   # adds "c"
+                Arrow.write(w, (; d=mk(["b", "a"])))        # nothing new
+            end
+            bytes = take!(io)
+            @test Arrow.Table(bytes).d == ["a", "b", "a", "c", "c", "b", "b", "a"]
+            batches = [(isdelta, n) for (_, isdelta, n) in dictbatches(bytes)]
+            if dictdeltas
+                # A base dictionary, then a delta holding only the new category.
+                @test batches == [(false, 2), (true, 1)]
+            elseif file
+                # One complete dictionary, after the record batches using it.
+                @test batches == [(false, 3)]
+                @test batchkinds(bytes) == [:record, :record, :record, :dictionary]
+            else
+                # A stream writes the grown dictionary again, whole.
+                @test batches == [(false, 2), (false, 3)]
+            end
+            # A growing pool is indexed with Int32, as pyarrow writes.
+            f = only(
+                Arrow.readfile(
+                    take!(Arrow.write(IOBuffer(), Arrow.Table(bytes); file=true)),
+                ).schema.fields,
+            )
+            @test (f.type::AC.DictionaryType).indextype == AC.IntType(32, true)
+        end
+        # dictreplacement=true replaces each table's pool instead (stream only).
+        io = IOBuffer()
+        w = Arrow.Writer(io; file=false, dictreplacement=true)
+        Arrow.write(w, (; d=Arrow.DictEncode(["a", "b", "a"])))
+        Arrow.write(w, (; d=Arrow.DictEncode(["c", "c", "b"])))
+        close(w)
+        bytes = take!(io)
+        @test Arrow.Table(bytes).d == ["a", "b", "a", "c", "c", "b"]
+        @test [(isdelta, n) for (_, isdelta, n) in dictbatches(bytes)] == [(false, 2), (false, 2)]
+        # The file format has no replacement to declare.
+        @test_throws ArgumentError Arrow.Writer(IOBuffer(); file=true, dictreplacement=true)
+    end
+
+    @testset "dictionaries with large offsets or views grow" begin
+        # The later table lists its new category first, so its own pool is
+        # not the written one extended.
+        for values in (["c0", "c1"], Vector{UInt8}.(["c0", "c1"])), file in (false, true)
+            for dictdeltas in (false, true)
+                tables = [
+                    (d=Arrow.DictEncode(values[1:1]),),
+                    (d=Arrow.DictEncode(values[[2, 1]]),),
+                ]
+                bytes, errs = writetables(tables; largelists=true, file, dictdeltas)
+                @test all(isnothing, errs)
+                @test Arrow.Table(bytes).d == values[[1, 2, 1]]
+            end
+        end
+        # An append grows a stream another writer's options laid out.
+        for kwargs in ((largelists=true,), (stringview=true,))
+            path = joinpath(mktempdir(), "d.arrow")
+            Arrow.Writer(
+                w -> Arrow.write(w, (d=Arrow.DictEncode(["a"]),)),
+                path;
+                file=false,
+                kwargs...,
+            )
+            Arrow.append(path, (d=Arrow.DictEncode(["b", "a"]),))
+            @test Arrow.Table(path).d == ["a", "b", "a"]
+        end
+    end
+
+    @testset "a growing dictionary costs each table its new categories" begin
+        # Work per table is proportional to the categories it adds, not to the
+        # pool written so far: 2,000 tables cost twice what 1,000 do.
+        growdictionary(10)
+        @test growthallocations(2_000) < 2.5 * growthallocations(1_000)
+        @test length(dictbatches(growdictionary(2_000))) == 2_000
+        t = Arrow.Table(growdictionary(100))
+        @test t.s == ["c$(t)_$i" for t = 1:100 for i = 1:20]
+    end
+
+    @testset "a dictionary column's later batches map their codes without per-row allocation" begin
+        t = (; d=Arrow.DictEncode([string("c", i % 32) for i = 1:1_000_000]))
+        batchedallocations(t, 500_000)
+        batchedallocations(t, 1_000_000)
+        # The second batch's 500,000 codes map into the first batch's pool. The
+        # least of three: allocations on other threads only add to a reading.
+        extra = minimum(
+            batchedallocations(t, 500_000) - batchedallocations(t, 1_000_000) for _ = 1:3
+        )
+        @test extra < 8 * 500_000
+        @test Arrow.Table(take!(Arrow.write(IOBuffer(), t; batchsize=500_000))).d ==
+              t.d.data
+    end
+
+    @testset "one-shot dictionaries use the narrowest index type" begin
+        indextype(t) = (
+            only(
+                Arrow.readfile(take!(Arrow.write(IOBuffer(), t; file=true))).schema.fields,
+            ).type::AC.DictionaryType
+        ).indextype
+        @test indextype((; d=Arrow.DictEncode(["a", "b"]))) == AC.IntType(8, true)
+        @test indextype((; d=PooledArray(string.(1:200)))) == AC.IntType(16, true)
+        @test indextype((; d=PooledArray(string.(1:40_000)))) == AC.IntType(32, true)
+        # An ordered CategoricalArray writes an ordered dictionary.
+        for ordered in (true, false)
+            c = CategoricalArrays.categorical(
+                ["lo", "hi", "lo"];
+                ordered,
+                levels=["lo", "hi"],
+            )
+            bytes = take!(Arrow.write(IOBuffer(), (; c=c); file=true))
+            t = only(Arrow.readfile(bytes).schema.fields).type::AC.DictionaryType
+            @test t.ordered == ordered
+            @test Arrow.Table(bytes).c == ["lo", "hi", "lo"]
+        end
+    end
+
+    @testset "a function-form writer whose function throws keeps the path" begin
+        dir = mktempdir()
+        path = joinpath(dir, "keep.arrow")
+        Arrow.write(path, t1)
+        before = read(path)
+        # The first table is refused (columns of different lengths).
+        @test_throws ArgumentError Arrow.Writer(
+            w -> Arrow.write(w, (a=[1], b=[1, 2])),
+            path,
+        )
+        @test read(path) == before
+        @test_throws ErrorException open(w -> error("no table"), Arrow.Writer, path)
+        @test read(path) == before
+        # After a table too: a later partition is refused, or the function fails.
+        refusedpart(w) = Arrow.write(w, Tables.partitioner([(a=[10],), (a=["x"],)]))
+        @test_throws ArgumentError Arrow.Writer(refusedpart, path)
+        @test read(path) == before
+        failslater(w) = (Arrow.write(w, t1); error("after a table"))
+        @test_throws ErrorException open(failslater, Arrow.Writer, path)
+        @test read(path) == before
+        @test_throws ErrorException Arrow.Writer(failslater, joinpath(dir, "new.arrow"))
+        @test readdir(dir) == ["keep.arrow"]
+        # An IO gets nothing before a table, and its tables ended after one.
+        io = IOBuffer()
+        @test_throws ErrorException Arrow.Writer(w -> error("no table"), io)
+        @test isempty(take!(io))
+        @test_throws ErrorException Arrow.Writer(failslater, io; file=false)
+        @test Arrow.Table(take!(io)).b == t1.b
+        # A writer closed without a table writes an output with no columns.
+        close(Arrow.Writer(path))
+        @test isempty(Tables.columnnames(Arrow.Table(read(path))))
+    end
+
+    @testset "close is idempotent; a closed writer refuses writes" begin
+        io = IOBuffer()
+        w = Arrow.Writer(io)
+        Arrow.write(w, t1)
+        close(w)
+        close(w)
+        err = @test_throws ArgumentError Arrow.write(w, t2)
+        @test occursin("closed", err.value.msg)
+        # Closing a writer that never wrote does not throw (finally-friendly)
+        # and writes a valid output with no columns.
+        io2 = IOBuffer()
+        close(Arrow.Writer(io2))
+        none = Arrow.Table(take!(io2))
+        @test isempty(Tables.columnnames(none)) && Tables.rowcount(none) == 0
+    end
+
+    @testset "close finalizes what was published" begin
+        # A refused write publishes nothing; close still emits a valid
+        # file containing every accepted batch.
+        io = IOBuffer()
+        w = Arrow.Writer(io; file=true)
+        Arrow.write(w, t1)
+        @test_throws Exception Arrow.write(w, (; a=[1.5], b=["q"]))
+        close(w)
+        t = Arrow.Table(take!(io))
+        @test t.a == [1, 2]
+    end
+
+    @testset "compressed batches on several tasks publish before each write returns" begin
+        big = (; a=collect(1:50_000), b=[string(k) for k = 1:50_000])
+        # The second partition is refused; the first's batch still publishes.
+        bad = Tables.partitioner([(; a=[1, 2], b=["p", "q"]), (; a=[1.5], b=["x"])])
+        for compress in (:lz4, :zstd), file in (true, false)
+            sizes = map((1, 4)) do ntasks
+                io = IOBuffer()
+                w = Arrow.Writer(io; file, compress, ntasks, batchsize=7000)
+                Arrow.write(w, big)
+                afterbig = io.size
+                @test_throws ArgumentError Arrow.write(w, bad)
+                afterbad = io.size
+                close(w)
+                bytes = take!(io)
+                t = Arrow.Table(bytes)
+                @test t.a == [big.a; 1; 2] && t.b == [big.b; "p"; "q"]
+                (afterbig, afterbad, bytes)
+            end
+            @test sizes[1] == sizes[2]
+        end
+    end
+
+    @testset "append to a stream path and io" begin
+        path = joinpath(mktempdir(), "s.arrow")
+        Arrow.write(path, t1; file=false)
+        @test Arrow.append(path, t2) == path
+        t = Arrow.Table(path)
+        @test t.a == [1, 2, 3, 4]
+        @test t.b == ["x", "y", "z", "w"]
+        Arrow.append(path, (; a=Int64[5], b=["v"]))
+        @test Arrow.Table(path).a == [1, 2, 3, 4, 5]
+        # The one-table write fixed `a` non-nullable; the refusal says so.
+        err = @test_throws ArgumentError Arrow.append(path, (; a=[missing], b=["v"]))
+        @test occursin("not nullable", err.value.msg)
+        @test occursin("Arrow.Writer", err.value.msg)
+
+        io = IOBuffer()
+        Arrow.write(io, t1; file=false)
+        Arrow.append(io, t2)
+        @test Arrow.Table(take!(io)).a == [1, 2, 3, 4]
+
+        # Appending to nothing starts a stream; the one-argument form curries.
+        fresh = joinpath(mktempdir(), "new.arrows")
+        @test (t1 |> Arrow.append(fresh)) == fresh
+        @test Arrow.append(fresh, t2) == fresh
+        @test Arrow.Table(fresh).a == [1, 2, 3, 4]
+        @test read(fresh, 6) != b"ARROW1"
+        io = IOBuffer()
+        Arrow.append(io, t1)
+        Arrow.append(io, t2)
+        @test Arrow.Table(take!(io)).b == ["x", "y", "z", "w"]
+    end
+
+    @testset "append unmaps the file before it returns" begin
+        path = joinpath(mktempdir(), "s.arrow")
+        Arrow.write(path, t1; file=false)
+        # Windows refuses to delete or replace a mapped file, so a mapping left
+        # for the GC to release would fail these until a collection ran.
+        enabled = GC.enable(false)
+        try
+            Arrow.append(path, t2)
+            Sys.islinux() && @test !any(contains(path), eachline("/proc/self/maps"))
+            Arrow.write(path, t1; file=false)
+            Arrow.append(path, t2)
+            rm(path)
+        finally
+            GC.enable(enabled)
+        end
+        @test !isfile(path)
+    end
+
+    @testset "append reads the stream's metadata and dictionaries, not its batches" begin
+        path = tempname()
+        parts = Tables.partitioner([
+            (x=fill(Float64(p), 500_000), d=Arrow.DictEncode(fill("a", 500_000))) for
+            p = 1:4
+        ])
+        Arrow.write(path, parts; file=false)
+        Arrow.append(path, (x=[5.0], d=["b"]))
+        @test appendallocations(path, (x=[6.0], d=["a"])) < filesize(path) ÷ 16
+        t = Arrow.Table(path)
+        @test t.x[(end - 1):end] == [5.0, 6.0]
+        @test t.d[(end - 2):end] == ["a", "b", "a"]
+        rm(path)
+    end
+
+    @testset "append to a stream without an end-of-stream marker" begin
+        # The reader accepts a stream that ends right after its last message;
+        # appending must keep that message intact.
+        io = IOBuffer()
+        Arrow.write(io, t1; file=false)
+        noeos = take!(io)[1:(end - 8)]
+        @test Arrow.Table(noeos).a == [1, 2]
+        path = joinpath(mktempdir(), "noeos.arrow")
+        write(path, noeos)
+        Arrow.append(path, t2)
+        @test Arrow.Table(path).a == [1, 2, 3, 4]
+        Arrow.append(path, t2)
+        @test Arrow.Table(path).b == ["x", "y", "z", "w", "z", "w"]
+
+        io = IOBuffer()
+        write(io, noeos)
+        Arrow.append(io, t2)
+        @test Arrow.Table(take!(io)).b == ["x", "y", "z", "w"]
+    end
+
+    @testset "append with dictionary columns" begin
+        # New categories extend the stream's dictionary, written again whole
+        # (or as a delta batch with dictdeltas=true); existing ones reuse it.
+        for dictdeltas in (false, true)
+            path = joinpath(mktempdir(), "d.arrow")
+            Arrow.write(path, (; d=Arrow.DictEncode(["a", "b", "a"])); file=false)
+            Arrow.append(path, (; d=Arrow.DictEncode(["a", "b", "b"])); dictdeltas)
+            @test Arrow.Table(path).d == ["a", "b", "a", "a", "b", "b"]
+            Arrow.append(path, (; d=Arrow.DictEncode(["z", "z", "q"])); dictdeltas)
+            @test Arrow.Table(path).d == ["a", "b", "a", "a", "b", "b", "z", "z", "q"]
+            @test [(isdelta, n) for (_, isdelta, n) in dictbatches(read(path))] == (dictdeltas ? [(false, 2), (true, 2)] : [(false, 2), (false, 4)])
+        end
+
+        # A Writer stream that opted into replacement replaces on append.
+        rpath = joinpath(mktempdir(), "r.arrow")
+        Arrow.Writer(rpath; file=false, dictreplacement=true) do w
+            Arrow.write(w, (; d=Arrow.DictEncode(["a", "b", "a"])))
+        end
+        Arrow.append(rpath, (; d=Arrow.DictEncode(["b", "a"])))
+        Arrow.append(rpath, (; d=Arrow.DictEncode(["z", "z", "q"])))
+        @test Arrow.Table(rpath).d == ["a", "b", "a", "b", "a", "z", "z", "q"]
+    end
+
+    @testset "append refusals" begin
+        path = joinpath(mktempdir(), "f.arrow")
+        Arrow.write(path, t1; file=true)
+        err = @test_throws ArgumentError Arrow.append(path, t2)
+        @test occursin("file format", err.value.msg)
+
+        spath = joinpath(mktempdir(), "s.arrow")
+        Arrow.write(spath, t1; file=false)
+        err = @test_throws ArgumentError Arrow.append(spath, (; wrong=[1]))
+        @test occursin("do not match", err.value.msg)
+        # A corrupt schema message refuses instead of gaining valid-looking bytes.
+        bytes = read(spath)
+        bytes[9] ⊻= 0x40
+        write(spath, bytes)
+        @test_throws Exception Arrow.append(spath, t2)
+    end
+
+    @testset "missing values go where a union keeps its nulls" begin
+        dir = mktempdir()
+        # No child keeps a null, so missing values are refused, not written as values.
+        path = unionstream(joinpath(dir, "u.arrow"), (false, false))
+        err = @test_throws ArgumentError Arrow.append(path, (u=[missing, missing],))
+        @test occursin("no child of the schema's union holds a null", err.value.msg)
+        @test isequal(collect(Arrow.Table(path).u), [1, "a"])
+        # Only the second child keeps nulls, under a struct with a null row.
+        path = unionstream(joinpath(dir, "t.arrow"), (false, true); nested=true)
+        T = NamedTuple{(:u,),Tuple{Union{Missing,Int64}}}
+        Arrow.append(path, (t=Union{Missing,T}[(u=missing,), missing, (u=5,)],))
+        rows = Arrow.Table(path).t
+        @test isequal(
+            [ismissing(r) ? missing : r.u for r in rows],
+            [1, "a", missing, missing, 5],
+        )
+    end
+
+    @testset "a labelled Null child holds a value, not a missing value" begin
+        # An unlabelled union keeps later missing values in a nullable child;
+        # its `JuliaLang.Nothing` child holds `nothing`.
+        U = Union{Missing,Nothing,Int}
+        tables = [(x=Union{Nothing,Int}[nothing, 1],), (x=U[missing, 2],), (x=[missing],)]
+        bytes, errs = writetables(tables)
+        @test all(isnothing, errs)
+        @test isequal(collect(Arrow.Table(bytes).x), U[nothing, 1, missing, 2, missing])
+        # Without a nullable child, they are refused.
+        bytes, errs = writetables(tables; nullable=false)
+        @test errs[1] === nothing && all(e -> refused(e, :x), errs[2:3])
+        @test isequal(collect(Arrow.Table(bytes).x), [nothing, 1])
+        path = joinpath(mktempdir(), "u.arrows")
+        Arrow.write(path, tables[1]; file=false)
+        @test refused((@test_throws ArgumentError Arrow.append(path, tables[2])).value, :x)
+        @test isequal(collect(Arrow.Table(path).x), [nothing, 1])
+        # Every child of a labelled union holds a value: a later missing value
+        # needs the Null child a first table with missing values declares.
+        for values in
+            ([MaybeLabel(nothing), MaybeLabel("a")], [EitherLabel(1), EitherLabel("a")])
+            T = Union{Missing,eltype(values)}
+            bytes, errs = writetables([(x=values,), (x=T[values[2], missing],)])
+            @test refused(errs[2], :x)
+            @test isequal(collect(Arrow.Table(bytes).x), values)
+            bytes, errs = writetables([(x=T[values...],), (x=T[values[2], missing],)])
+            @test isequal(collect(Arrow.Table(bytes).x), T[values; values[2]; missing])
+        end
+        # A column of `nothing` writes Null labelled `JuliaLang.Nothing`.
+        bytes, errs = writetables([(x=[nothing, nothing],), (x=[missing],)])
+        @test refused(errs[2], :x)
+        # A labelled union under a null struct row holds a stand-in there.
+        S = Union{Missing,NamedTuple{(:a,),Tuple{EitherLabel}}}
+        bytes, errs = writetables([
+            (x=S[(a=EitherLabel(1),)],),
+            (x=S[missing, (a=EitherLabel("x"),)],),
+        ])
+        @test all(isnothing, errs)
+        @test isequal(
+            fielda.(Arrow.Table(bytes).x),
+            [EitherLabel(1), missing, EitherLabel("x")],
+        )
+    end
+
+    @testset "`nothing` is written as a value, never as a missing value" begin
+        # A union's `JuliaLang.Nothing` child keeps a later table's `nothing`s,
+        # also in a table of nothing else.
+        U = Union{Missing,Nothing,Int}
+        for (tables, values) in (
+            (
+                [(x=Union{Nothing,Int}[nothing, 1],), (x=[nothing, nothing],)],
+                U[nothing, 1, nothing, nothing],
+            ),
+            (
+                [(x=U[missing, nothing, 1],), (x=[nothing],)],
+                U[missing, nothing, 1, nothing],
+            ),
+            (
+                [(x=[Union{Nothing,Int}[nothing, 1]],), (x=[[nothing]],)],
+                [U[nothing, 1], U[nothing]],
+            ),
+        )
+            bytes, errs = writetables(tables)
+            @test all(isnothing, errs)
+            @test isequal(collect(Arrow.Table(bytes).x), values)
+        end
+        # A field without such a child has no place for `nothing`.
+        for (t1, t2) in (
+            ((x=[1],), (x=Union{Nothing,Int}[nothing, 2],)),
+            ((x=[1],), (x=[nothing],)),
+            ((x=[missing],), (x=[nothing],)),
+            ((x=[missing],), (x=[UnitLabel()],)),
+            ((x=[missing],), (x=Any[nothing, UnitLabel()],)),
+            ((x=["a"],), (x=Union{Nothing,Symbol}[nothing, :b],)),
+            ((x=[(u=1,)],), (x=[(u=nothing,), (u=2,)],)),
+            ((x=[[1]],), (x=[Union{Nothing,Int}[nothing, 2]],)),
+        )
+            bytes, errs = writetables([t1, t2])
+            @test errs[1] === nothing && refused(errs[2], :x)
+            @test isequal(collect(Arrow.Table(bytes).x), t1.x)
+        end
+        # Under its own label, a value stored as Nothing reads back.
+        @test collect(Arrow.Table(Arrow.tobuffer((x=[UnitLabel()],))).x) == [UnitLabel()]
+        path = joinpath(mktempdir(), "x.arrows")
+        Arrow.write(path, (x=Union{Missing,Int}[1, missing],); file=false)
+        err =
+            @test_throws ArgumentError Arrow.append(path, (x=Union{Nothing,Int}[nothing],))
+        @test refused(err.value, :x)
+        Arrow.Writer(
+            w -> Arrow.write(w, (x=Union{Nothing,Int}[nothing, 1],)),
+            path;
+            file=false,
+        )
+        Arrow.append(path, (x=[nothing],))
+        @test isequal(collect(Arrow.Table(path).x), [nothing, 1, nothing])
+    end
+
+    @testset "a union child with only missing values in a table holds nulls" begin
+        U = Union{Missing,Int,String}
+        tables = [(u=Union{Int,String}[1, "a"],), (u=U["b", missing],), (u=U[missing],)]
+        bytes, errs = writetables(tables)
+        @test all(isnothing, errs)
+        @test isequal(collect(Arrow.Table(bytes).u), U[1, "a", "b", missing, missing])
+        path = joinpath(mktempdir(), "u.arrows")
+        Arrow.Writer(w -> Arrow.write(w, tables[1]), path; file=false)
+        Arrow.append(path, tables[2])
+        @test isequal(collect(Arrow.Table(path).u), U[1, "a", "b", missing])
+        # A struct with a union field, then a table with a null row.
+        S = Union{Missing,NamedTuple{(:a,),Tuple{Union{Int,String}}}}
+        bytes, errs = writetables([(s=S[(a=1,)],), (s=S[missing, (a="x",)],)])
+        @test all(isnothing, errs)
+        @test isequal(fielda.(Arrow.Table(bytes).s), [1, missing, "x"])
+    end
+
+    @testset "refusals name the column's type and advise only what would help" begin
+        # A Writer's columns are already nullable: no advice to start one.
+        _, errs = writetables([(t=[Date(2020, 1, 1)],), (t=[DateTime(2020)],)])
+        msg = errs[2].msg
+        @test occursin("DateTime values", msg)
+        @test occursin("date32 (reads as", msg)
+        @test !occursin("Arrow.Writer(path", msg)
+        _, errs = writetables([(a=[1],), (a=[missing],)]; nullable=false)
+        @test occursin("created with nullable=false", errs[2].msg)
+        @test !occursin("one-table", errs[2].msg)
+        # A column of `nothing` is not missing values, and declaring the field
+        # nullable would not help it.
+        for nullable in (true, false)
+            _, errs = writetables([(a=[1],), (a=[nothing],)]; nullable)
+            @test occursin("null labelled JuliaLang.Nothing", errs[2].msg)
+            @test !occursin("created with nullable=false", errs[2].msg)
+        end
+        # An append to a one-table stream: a nullable Writer would have taken
+        # the missing values, but not another type or a labelled union's.
+        path = joinpath(mktempdir(), "s.arrow")
+        Arrow.write(path, (a=[1], u=[MaybeLabel("x")]); file=false)
+        hint = "start the stream with Arrow.Writer(path; file=false)"
+        err = @test_throws ArgumentError Arrow.append(
+            path,
+            (a=[missing], u=[MaybeLabel("y")]),
+        )
+        @test occursin(hint, err.value.msg)
+        err = @test_throws ArgumentError Arrow.append(path, (a=["x"], u=[MaybeLabel("y")]))
+        @test !occursin(hint, err.value.msg)
+        U = Union{Missing,MaybeLabel}
+        err = @test_throws ArgumentError Arrow.append(path, (a=[2], u=U[missing]))
+        @test occursin("no child of the schema's union holds a null", err.value.msg)
+        @test !occursin(hint, err.value.msg)
+    end
+
+    @testset "append to an Arrow 2.x stream" begin
+        fixture = read(joinpath(@__DIR__, "fixtures2x", "mixed-two-partitions.arrowbytes"))
+        path = joinpath(mktempdir(), "mixed.arrow")
+        write(path, fixture)
+        before = Arrow.Table(read(path))
+        tail = (;
+            ints=Int64[6, 7],
+            floats=[6.5, missing],
+            bools=[false, true],
+            strs=["tail", missing],
+            lists=[[7, 8], missing],
+            structs=[
+                Pair{String,Any}["a" => 6, "b" => "u"],
+                Pair{String,Any}["a" => 7, "b" => "t"],
+            ],
+            dict=Arrow.DictEncode(["lo", "mid"]),
+        )
+        # The 2.x pool carries a null slot (2.x encoded missing as a pool
+        # entry); the new category extends it with a delta dictionary batch.
+        Arrow.append(path, tail)
+        t = Arrow.Table(path)
+        # The 2.x fixture holds the five-row table twice (two partitions).
+        @test t.ints == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 6, 7]
+        @test t.strs[11] == "tail"
+        @test isequal(t.dict, [before.dict..., "lo", "mid"])
+        @test t.structs[end] == (a=7, b="t")
+    end
+end
+
+end # module IncrementalWriterTests
diff --git a/test/integrationtest.jl b/test/integrationtest.jl
deleted file mode 100644
index 7bca4f64..00000000
--- a/test/integrationtest.jl
+++ /dev/null
@@ -1,49 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-using Arrow, Tables, Test
-
-include(joinpath(dirname(pathof(Arrow)), "../test/arrowjson.jl"))
-# using .ArrowJSON
-
-function runcommand(jsonname, arrowname, mode, verbose)
-    if jsonname == ""
-        error("must provide json file name")
-    end
-    if arrowname == ""
-        error("must provide arrow file name")
-    end
-
-    if mode == "ARROW_TO_JSON"
-        tbl = Arrow.Table(arrowname)
-        df = ArrowJSON.DataFile(tbl)
-        open(jsonname, "w") do io
-            JSON3.write(io, df)
-        end
-    elseif mode == "JSON_TO_ARROW"
-        df = ArrowJSON.parsefile(jsonname)
-        open(arrowname, "w") do io
-            Arrow.write(io, df)
-        end
-    elseif mode == "VALIDATE"
-        df = ArrowJSON.parsefile(jsonname)
-        tbl = Arrow.Table(arrowname)
-        @test isequal(df, tbl)
-    else
-        error("unknown integration test mode: $mode")
-    end
-    return
-end
diff --git a/test/invalidations.jl b/test/invalidations.jl
new file mode 100644
index 00000000..3298094f
--- /dev/null
+++ b/test/invalidations.jl
@@ -0,0 +1,68 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+@testset "loading common data packages keeps the precompiled code" begin
+    # Packages that add methods to generic functions invalidate precompiled code
+    # that was inferred with abstract types, and the next read or write compiles
+    # again. Run in a fresh process, where the code is the package image's.
+    # CategoricalArrays and TimeZones (which loads InlineStrings) add such methods;
+    # so do DataFrames and its dependencies, whose kinds of methods the script
+    # adds itself: `eltype` of a vector type (DataFrames' `RepeatedVector`), a
+    # dictionary's `pairs`, `merge!`, and key iteration (DataStructures), and a
+    # string's code units (LaTeXStrings).
+    script = raw"""
+        using Arrow
+        entries = ccall(:jl_debug_method_invalidation, Any, (Cint,), 1)
+        using CategoricalArrays, TimeZones
+        struct RepeatedRows{T} <: AbstractVector{T} end
+        Base.eltype(::Type{RepeatedRows{T}}) where {T} = T
+        Base.size(::RepeatedRows) = (0,)
+        struct SortedPairs{K,V} <: AbstractDict{K,V} end
+        Base.pairs(d::SortedPairs) = d
+        Base.merge!(d::SortedPairs, others...) = d
+        Base.iterate(::Base.KeySet{<:Any,<:SortedPairs}, state) = nothing
+        Base.keys(d::SortedPairs, prefix) = d
+        struct Markup <: AbstractString end
+        Base.codeunits(::Markup) = UInt8[]
+        Base.eachindex(::Markup) = 1:0
+        ccall(:jl_debug_method_invalidation, Any, (Cint,), 0)
+        instance(x) =
+            x isa Core.MethodInstance ? x :
+            x isa Core.CodeInstance ? (x.def isa Core.MethodInstance ? x.def : x.def.def) :
+            nothing
+        invalidated = Set{Core.MethodInstance}()
+        for x in entries
+            mi = instance(x)
+            mi isa Core.MethodInstance &&
+                mi.def isa Method &&
+                Base.moduleroot(mi.def.module) in (Arrow, Arrow.ArrowTypes) &&
+                push!(invalidated, mi)
+        end
+        foreach(mi -> println(stderr, mi), Iterators.take(invalidated, 20))
+        print(length(invalidated))
+        """
+    cmd = `$(Base.julia_cmd()) --startup-file=no --project=$(Base.active_project()) -e $script`
+    invalidated = parse(Int, read(cmd, String))
+    # Over a thousand were invalidated when the reader's and writer's kernels were
+    # also inferred for abstract types; the bound leaves room for small changes in
+    # those packages. A prerelease Julia adds its own Base code to what they
+    # invalidate, so there the count is only reported.
+    if isempty(VERSION.prerelease)
+        @test invalidated < 200
+    else
+        @info "Arrow method instances invalidated on Julia $VERSION: $invalidated"
+    end
+end
diff --git a/test/ipc_dictionary_tests.jl b/test/ipc_dictionary_tests.jl
new file mode 100644
index 00000000..f23804f3
--- /dev/null
+++ b/test/ipc_dictionary_tests.jl
@@ -0,0 +1,844 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module IPCDictionaryTests
+
+using Test, Arrow, Tables, DataDecimals, DataStrings, InlineStrings, UUIDs, PooledArrays
+const AC = Arrow.AC
+const Meta = Arrow.Meta
+const FB = Arrow.FB
+primitive type PrimitiveCode 16 end
+Arrow.ArrowTypes.ArrowType(::Type{PrimitiveCode}) = Int16
+Arrow.ArrowTypes.toarrow(value::PrimitiveCode) = reinterpret(Int16, value)
+
+struct ByteString <: AbstractString
+    data::String
+end
+Base.ncodeunits(s::ByteString) = ncodeunits(s.data)
+Base.codeunit(::ByteString) = UInt8
+Base.codeunit(s::ByteString, i::Int) = codeunit(s.data, i)
+Base.isvalid(s::ByteString, i::Int) = isvalid(s.data, i)
+Base.firstindex(s::ByteString) = firstindex(s.data)
+Base.lastindex(s::ByteString) = lastindex(s.data)
+Base.getindex(s::ByteString, i::Int) = getindex(s.data, i)
+Base.iterate(s::ByteString) = iterate(s.data)
+Base.iterate(s::ByteString, i::Int) = iterate(s.data, i)
+Base.thisind(s::ByteString, i::Int) = thisind(s.data, i)
+Base.nextind(s::ByteString, i::Int) = nextind(s.data, i)
+Base.prevind(s::ByteString, i::Int) = prevind(s.data, i)
+Base.hash(::ByteString, ::UInt) = error("custom logical hash must not run")
+Base.isequal(::ByteString, ::ByteString) = error("custom logical isequal must not run")
+Base.codeunits(::ByteString) = error("custom codeunits method must not run")
+Arrow.ArrowTypes.ArrowType(::Type{ByteString}) = String
+Arrow.ArrowTypes.toarrow(s::ByteString) = s.data
+Arrow.ArrowTypes.ArrowType(::Type{SubString{ByteString}}) = String
+Arrow.ArrowTypes.toarrow(s::SubString{ByteString}) =
+    String([codeunit(s, i) for i = 1:ncodeunits(s)])
+
+struct WideString <: AbstractString
+    data::Vector{UInt16}
+end
+Base.ncodeunits(s::WideString) = length(s.data)
+Base.codeunit(s::WideString, i::Int) = s.data[i]
+Base.hash(::WideString, ::UInt) = error("custom logical hash must not run")
+
+# Reuse the property suite's module in the full run: loading it twice
+# overwrites its global ArrowTypes extension registrations.
+const Fuzz = if isdefined(parentmodule(@__MODULE__), :PropertyTests)
+    getfield(getfield(parentmodule(@__MODULE__), :PropertyTests), :SeededFuzz)
+else
+    include("support/SeededFuzz.jl")
+end
+
+# The normal suite consumes independently produced PyArrow 25.0.1 bytes.
+# Regenerate with: python test/support/generate_dictionary_fixtures.py
+struct BytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::BytesSource) = length(s.data)
+Arrow.readrange(s::BytesSource, off, len) = s.data[(off + 1):(off + len)]
+
+const FIXTURES = joinpath(@__DIR__, "fixtures-dictionaries")
+
+function dictmessage(id, vf, pool, delta, codec, states)
+    cursor = Arrow.EncodeCursor(codec)
+    Arrow.encodefield!(cursor, vf, pool)
+    Arrow._compressbody!(cursor, states, 1)
+    builder = FB.Builder(1024)
+    rb = Arrow._batchheader!(builder, cursor, pool.len)
+    Meta.dictionaryBatchStart(builder)
+    Meta.dictionaryBatchAddId(builder, id)
+    Meta.dictionaryBatchAddData(builder, rb)
+    Meta.dictionaryBatchAddIsDelta(builder, delta)
+    header = Meta.dictionaryBatchEnd(builder)
+    Meta.messageStart(builder)
+    Meta.messageAddVersion(builder, Meta.MetadataVersion.V5)
+    Meta.messageAddHeaderType(builder, Meta.DictionaryBatch)
+    Meta.messageAddHeader(builder, header)
+    Meta.messageAddBodyLength(builder, cursor.bodylen)
+    return Arrow._messageheader(builder, Meta.messageEnd(builder), cursor.bodylen), cursor
+end
+
+# Test-only producer can deliberately emit malformed state transitions. It
+# uses the ordinary physical encoder but controls dictionary message flags.
+function fixture(vf, events; file=false, features=Int64[], compress=:none)
+    t = AC.DictionaryType(AC.IntType(32, true), vf.type, false)
+    field = AC.Field("a", t; children=vf.children)
+    schema = AC.Schema([field])
+    io = IOBuffer()
+    state = Arrow.beginwrite!(io, schema; file, features, compress)
+    nested = IdDict{AC.Field,AC.ArrayData}()
+    function emit!(callback, blocks)
+        header, body = callback()
+        Arrow._publishmessages!(state, [(header, body, file ? blocks : nothing)])
+    end
+    try
+        for (delta, pool, indices) in events
+            # Nested dictionary dependencies precede their parent. Each new
+            # snapshot is a full replacement under the same nested id.
+            for (nf, np) in Arrow.dictionarypools((vf,), (pool,))
+                get(nested, nf, nothing) === np && continue
+                emit!(state.dictblocks) do
+                    dictmessage(
+                        state.ids[nf],
+                        AC.dictvaluefield(nf, nf.type),
+                        np,
+                        false,
+                        state.codec,
+                        state.states,
+                    )
+                end
+                nested[nf] = np
+            end
+            emit!(state.dictblocks) do
+                dictmessage(state.ids[field], vf, pool, delta, state.codec, state.states)
+            end
+            indices === nothing && continue
+            column = AC.ArrayData(
+                t,
+                length(indices),
+                [AC.BufferSlice(), AC._databuffer(Int32.(indices))];
+                dictionary=pool,
+                nullcount=0,
+            )
+            batch = AC.RecordBatch(schema, [column], length(indices))
+            emit!(state.recordblocks) do
+                Arrow._recordmessage(batch, schema.fields, state.codec, state.states)
+            end
+        end
+        Arrow.finishwrite!(state)
+    finally
+        Arrow.abortwrite!(state)
+    end
+    return take!(io)
+end
+
+function firstpool(reader)
+    record, _ = Arrow._nextrecord!(reader)
+    return WeakRef(only(values(record.dictionaries)))
+end
+
+function discardrecord!(reader)
+    Arrow._nextrecord!(reader)
+    return nothing
+end
+
+function writepool!(state, value)
+    _, column = AC.fromjulia_dict("a", [value], Int32[0])
+    Arrow.writebatch!(state, AC.RecordBatch(state.schema, [column], 1))
+    return WeakRef(column.dictionary)
+end
+
+@testset "stream dictionary history can be collected" begin
+    vf, pool = AC.fromjulia("pool", Int64[1])
+    _, replacement = AC.fromjulia("pool", Int64[2])
+    for delta in (false, true)
+        bytes = fixture(vf, [(false, pool, [0]), (delta, replacement, [delta ? 1 : 0])])
+        reader = Arrow._StreamReader(
+            Arrow._IOMessages(IOBuffer(bytes), UInt8[], 0),
+            Arrow.Limits(),
+        )
+        previous = firstpool(reader)
+        discardrecord!(reader)
+        GC.gc(true)
+        @test previous.value === nothing
+    end
+    field, _ = AC.fromjulia_dict("a", Int64[], Int32[])
+    state =
+        Arrow.beginwrite!(IOBuffer(), AC.Schema([field]); file=false, dictreplacement=true)
+    try
+        previous = writepool!(state, 1)
+        writepool!(state, 2)
+        GC.gc(true)
+        @test previous.value === nothing
+        Arrow.finishwrite!(state)
+    finally
+        Arrow.abortwrite!(state)
+    end
+end
+
+@testset "PyArrow dictionary updates" begin
+    for version in ("V4", "V5")
+        bytes = read(joinpath(FIXTURES, "replacement-$version.arrowbytes"))
+        @test Arrow.Table(bytes).a == ["alpha", "beta", "gamma", "delta"]
+        parts = collect(Arrow.Stream(bytes))
+        @test parts[1].a == ["alpha", "beta"]
+        @test parts[2].a == ["gamma", "delta"]
+    end
+    for kind in ("stream", "file")
+        bytes = read(joinpath(FIXTURES, "delta-V4-$kind.arrowbytes"))
+        @test Arrow.Table(bytes).a == ["beta", "gamma"]
+        if kind == "file"
+            @test Arrow.Table(
+                Arrow.SourceFile(BytesSource(bytes); tailbytes=32);
+                scan=Tables.Scan(),
+            ).a == ["beta", "gamma"]
+        end
+    end
+    pools = (
+        "strings" => ["alpha", "beta", "gamma", missing, "delta"],
+        "bool" => [true, false, missing, true, false],
+        "int" => [1, 2, 3, missing, 4],
+        "list" => Any[[1, 2], Int[], [3], missing, [4, 5]],
+        "struct" => Any[["x" => 1], ["x" => 2], ["x" => 3], missing, ["x" => 4]],
+    )
+    # Table reads give struct rows as named tuples.
+    publicrow(x) =
+        x isa AbstractVector{<:Pair} ? (; (Symbol(k) => v for (k, v) in x)...) : x
+    for (name, pool) in pools, file in (false, true), codec in ("None", "lz4", "zstd")
+        kind = file ? "file" : "stream"
+        path = joinpath(FIXTURES, "$name-$kind-$codec.arrowbytes")
+        bytes = read(path)
+        expected = Any[
+            pool[1],
+            pool[2],
+            missing,
+            pool[3],
+            pool[1],
+            missing,
+            pool[4],
+            pool[5],
+            pool[2],
+        ]
+        public = map(publicrow, expected)
+        for source in (bytes, path, IOBuffer(bytes))
+            @test isequal(collect(Arrow.Table(source).a), public)
+        end
+        if file
+            for handle in
+                (Arrow.readfile(bytes), Arrow.SourceFile(BytesSource(bytes); tailbytes=32))
+                @test isequal(collect(Arrow.Table(handle; scan=Tables.Scan()).a), public)
+                @test isequal(
+                    collect(Arrow.Table(handle; scan=Tables.Scan(offset=3, limit=4)).a),
+                    public[4:7],
+                )
+                @test isequal(
+                    collect(
+                        Arrow.Table(
+                            handle;
+                            scan=Tables.Scan(filter=Tables.isnull(Tables.col(:a))),
+                        ).a,
+                    ),
+                    filter(ismissing, public),
+                )
+            end
+        else
+            parts = collect(Arrow.Stream(bytes))
+            @test isequal(vcat([collect(b.a) for b in parts]...), public)
+            core = Arrow.readstream(bytes)
+            snapshots = [b.columns[1].dictionary for b in core.batches]
+            @test length.(snapshots) == [2, 3, 5]
+            @test snapshots[1] !== snapshots[2] !== snapshots[3]
+            @test isequal(parts[1].a, public[1:3])
+        end
+    end
+end
+
+@testset "Dictionary state transitions" begin
+    vf, base = AC.fromjulia("pool", ["alpha", "beta"])
+    _, delta = AC.fromjulia("pool", ["gamma"])
+    _, empty = AC.fromjulia("pool", String[])
+    _, replacement = AC.fromjulia("pool", ["zeta"])
+    events = [
+        (false, base, [0, 1]),
+        (true, delta, [2, 0]),
+        (true, empty, [1]),
+        (false, replacement, [0]),
+        (true, delta, [1, 0]),
+    ]
+    for features in (Int64[], Int64[1]), compress in (:none, :lz4, :zstd)
+        bytes = fixture(vf, events; features, compress)
+        @test Arrow.Table(bytes).a ==
+              ["alpha", "beta", "gamma", "alpha", "beta", "zeta", "gamma", "zeta"]
+        core = Arrow.readstream(bytes)
+        pools = [b.columns[1].dictionary for b in core.batches]
+        @test pools[2] === pools[3] # empty delta reuses its immutable base
+        @test pools[1] !== pools[2]
+        @test pools[4] !== pools[5]
+        @test AC.materialize(vf, pools[1]) == ["alpha", "beta"]
+    end
+    for file in (false, true)
+        # A delta cannot create its own base, even when empty.
+        for pool in (delta, empty)
+            bytes = fixture(vf, [(true, pool, nothing)]; file)
+            @test_throws AC.ValidationError Arrow.Table(bytes)
+            if file
+                @test_throws AC.ValidationError Arrow.Table(
+                    Arrow.SourceFile(BytesSource(bytes); tailbytes=32);
+                    scan=Tables.Scan(),
+                )
+            end
+        end
+        bytes = fixture(vf, [(false, empty, nothing), (true, delta, [0])]; file)
+        @test Arrow.Table(bytes).a == ["gamma"]
+        # Index validation sees the new pool length, including every delta.
+        bytes = fixture(vf, [(false, base, nothing), (true, delta, [3])]; file)
+        @test_throws AC.ValidationError Arrow.Table(bytes)
+        if file
+            bytes = fixture(vf, [(false, base, [0]), (false, replacement, [0])]; file)
+            @test_throws AC.ValidationError Arrow.Table(bytes)
+            @test_throws AC.ValidationError Arrow.Table(
+                Arrow.SourceFile(BytesSource(bytes); tailbytes=32);
+                scan=Tables.Scan(),
+            )
+        end
+    end
+    @test Arrow._filemetadataversion(Int16(4), Int16(3)) == 3
+    # Arrow.jl before 2.6 wrote a V4 footer over V5 messages.
+    @test Arrow._filemetadataversion(Int16(3), Int16(4)) == 4
+    @test_throws AC.ValidationError Arrow._filemetadataversion(Int16(2), Int16(4))
+    @test_throws AC.ValidationError Arrow._filemetadataversion(Int16(4), Int16(4), Int16(3))
+    # Deltas queued before a record batch still append in wire order.
+    bytes = fixture(
+        vf,
+        [(false, base, nothing), (true, delta, nothing), (true, replacement, [3, 2, 1, 0])],
+    )
+    @test Arrow.Table(bytes).a == ["zeta", "gamma", "beta", "alpha"]
+end
+
+@testset "Physical dictionary delta layouts" begin
+    for case in (
+        Fuzz._logical_layout_case(),
+        Fuzz._physical_layout_case(),
+        Fuzz._union_layout_case(),
+    )
+        for (vf, pool) in zip(case.schema.fields, case.batches[1].columns)
+            vf.type isa AC.DictionaryType && continue
+            @testset "$(vf.name)" begin
+                expected = AC.materialize(vf, pool)
+                n = pool.len
+                bytes = fixture(
+                    vf,
+                    [(false, pool, collect(0:(n - 1))), (true, pool, collect(n:(2n - 1)))],
+                )
+                if haskey(ENV, "ARROW_DICTIONARY_ORACLE_DIR")
+                    outdir = ENV["ARROW_DICTIONARY_ORACLE_DIR"]
+                    mkpath(outdir)
+                    write(joinpath(outdir, "$(case.label)-$(vf.name).arrows"), bytes)
+                end
+                decoded = Arrow.readstream(bytes)
+                f = decoded.schema.fields[1]
+                first, last = [b.columns[1] for b in decoded.batches]
+                @test isequal(AC.materialize(f, first), expected)
+                @test isequal(AC.materialize(f, last), expected)
+                @test last.dictionary.len == 2n
+                @test first.dictionary !== last.dictionary
+                @test AC.validate_semantic(f, last) === last
+            end
+        end
+    end
+end
+
+@testset "Nested and overlapping dictionary storage" begin
+    sf, firstpool = AC.fromjulia("strings", ["first", "second"])
+    _, secondpool = AC.fromjulia("strings", ["third", "fourth"])
+    nt = AC.DictionaryType(AC.IntType(8, true), sf.type, false)
+    nf = AC.Field("item", nt)
+    function nested(pool)
+        child = AC.ArrayData(
+            nt,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int8[1, 0])];
+            dictionary=pool,
+            nullcount=0,
+        )
+        vf = AC.Field("lists", AC.ListType(false); children=[nf])
+        data = AC.ArrayData(
+            vf.type,
+            1,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 2])];
+            children=[child],
+            nullcount=0,
+        )
+        return vf, data
+    end
+    vf, first = nested(firstpool)
+    _, second = nested(secondpool)
+    bytes = fixture(vf, [(false, first, [0]), (true, second, [0, 1])])
+    @test Arrow.Table(bytes).a ==
+          [["second", "first"], ["second", "first"], ["fourth", "third"]]
+    core = Arrow.readstream(bytes)
+    @test core.batches[1].columns[1].dictionary.children[1].dictionary.len == 2
+    @test core.batches[2].columns[1].dictionary.children[1].dictionary.len == 4
+
+    for large in (false, true)
+        cf, child = AC.fromjulia("item", Int64[10, 20, 30, 40])
+        t = AC.ListViewType(large)
+        f = AC.Field("views", t; children=[cf])
+        Offset = large ? Int64 : Int32
+        pool = AC.ArrayData(
+            t,
+            3,
+            [
+                AC.BufferSlice(),
+                AC._databuffer(Offset[2, 0, 1]),
+                AC._databuffer(Offset[2, 3, 2]),
+            ];
+            children=[child],
+            nullcount=0,
+        )
+        bytes = fixture(f, [(false, pool, [0, 1, 2]), (true, pool, [3, 4, 5])])
+        @test Arrow.Table(bytes).a == repeat([[30, 40], [10, 20, 30], [20, 30]], 2)
+    end
+    # Narrow unsigned nested indices must not use the signed maximum.
+    uinttype = AC.DictionaryType(AC.IntType(8, false), AC.IntType(32, true), false)
+    uintfield = AC.Field("items", uinttype)
+    uf = AC.Field("outer", AC.ListType(false); children=[uintfield])
+    function uintpool(start)
+        _, pool = AC.fromjulia("pool", Int32.(start:(start + 99)))
+        child = AC.ArrayData(
+            uinttype,
+            1,
+            [AC.BufferSlice(), AC._databuffer(UInt8[99])];
+            dictionary=pool,
+            nullcount=0,
+        )
+        return AC.ArrayData(
+            uf.type,
+            1,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 1])];
+            children=[child],
+            nullcount=0,
+        )
+    end
+    u1, u2 = uintpool(0), uintpool(100)
+    @test Arrow.Table(fixture(uf, [(false, u1, [0]), (true, u2, [0, 1])])).a ==
+          [[99], [99], [199]]
+
+    # Same value and Julia type in two Union routes must remain distinguishable.
+    c1, d1 = AC.fromjulia("left", Int64[1])
+    c2, d2 = AC.fromjulia("right", Int64[1])
+    t = AC.UnionType(AC.DenseMode, Int8[3, 7])
+    f = AC.Field("union", t; children=[c1, c2])
+    pool = AC.ArrayData(
+        t,
+        2,
+        [AC._databuffer(Int8[7, 3]), AC._databuffer(Int32[0, 0])];
+        children=[d1, d2],
+        nullcount=0,
+    )
+    core = Arrow.readstream(fixture(f, [(false, pool, [0, 1]), (true, pool, [2, 3])]))
+    combined = core.batches[2].columns[1].dictionary
+    @test AC.slicebytes(AC.rolebuffer(combined, AC.TYPE_IDS)) == UInt8[7, 3, 7, 3]
+end
+
+@testset "Dictionary pool equality retains nested Union routes" begin
+    leftfield, left = AC.fromjulia("left", Int64[1])
+    rightfield, right = AC.fromjulia("right", Int64[1])
+    uniontype = AC.UnionType(AC.DenseMode, Int8[3, 7])
+    unionfield = AC.Field("values", uniontype; children=[leftfield, rightfield])
+    unionpool(tag) = AC.ArrayData(
+        uniontype,
+        1,
+        [AC._databuffer(Int8[tag]), AC._databuffer(Int32[0])];
+        children=[left, right],
+        nullcount=0,
+    )
+    a, b = unionpool(3), unionpool(7)
+    cases = [(unionfield, a, b)]
+    for type in (
+        AC.StructType(),
+        AC.ListType(false),
+        AC.ListType(true),
+        AC.FixedSizeListType(1),
+        AC.ListViewType(false),
+        AC.ListViewType(true),
+    )
+        field = AC.Field("container", type; children=[unionfield])
+        buffers = if type isa AC.StructType || type isa AC.FixedSizeListType
+            [AC.BufferSlice()]
+        elseif type isa AC.ListViewType
+            Offset = type.large ? Int64 : Int32
+            [AC.BufferSlice(), AC._databuffer(Offset[0]), AC._databuffer(Offset[1])]
+        else
+            Offset = type.large ? Int64 : Int32
+            [AC.BufferSlice(), AC._databuffer(Offset[0, 1])]
+        end
+        wrap(pool) = AC.ArrayData(type, 1, buffers; children=[pool], nullcount=0)
+        push!(cases, (field, wrap(a), wrap(b)))
+    end
+    runfield, runends = AC.fromjulia("run_ends", Int32[2])
+    reetype = AC.RunEndEncodedType()
+    reefield = AC.Field("runs", reetype; children=[runfield, unionfield])
+    ree(pool) =
+        AC.ArrayData(reetype, 2, AC.BufferSlice[]; children=[runends, pool], nullcount=0)
+    push!(cases, (reefield, ree(a), ree(b)))
+    keyfield, keys = AC.fromjulia("key", Int64[1])
+    entriesfield = AC.Field(
+        "entries",
+        AC.StructType();
+        nullable=false,
+        children=[keyfield, unionfield],
+    )
+    mapfield = AC.Field("map", AC.MapType(false); children=[entriesfield])
+    map(pool) = AC.ArrayData(
+        mapfield.type,
+        1,
+        [AC.BufferSlice(), AC._databuffer(Int32[0, 1])];
+        children=[
+            AC.ArrayData(
+                entriesfield.type,
+                1,
+                [AC.BufferSlice()];
+                children=[keys, pool],
+                nullcount=0,
+            ),
+        ],
+        nullcount=0,
+    )
+    push!(cases, (mapfield, map(a), map(b)))
+    dicttype = AC.DictionaryType(AC.IntType(8, true), uniontype, false)
+    dictfield = AC.Field("item", dicttype; children=unionfield.children)
+    listfield = AC.Field("list", AC.ListType(false); children=[dictfield])
+    nested(pool) = AC.ArrayData(
+        listfield.type,
+        1,
+        [AC.BufferSlice(), AC._databuffer(Int32[0, 1])];
+        children=[
+            AC.ArrayData(
+                dicttype,
+                1,
+                [AC.BufferSlice(), AC._databuffer(Int8[0])];
+                dictionary=pool,
+                nullcount=0,
+            ),
+        ],
+        nullcount=0,
+    )
+    push!(cases, (listfield, nested(a), nested(b)))
+    for (vf, first, changed) in cases
+        @test isequal(AC.materialize(vf, first), AC.materialize(vf, changed))
+        @test Arrow._poolsequal(vf, first, copy(first))
+        @test !Arrow._poolsequal(vf, first, changed)
+        type = AC.DictionaryType(AC.IntType(32, true), vf.type, false)
+        field = AC.Field("a", type; children=vf.children)
+        schema = AC.Schema([field])
+        batch(pool) = AC.RecordBatch(
+            schema,
+            [
+                AC.ArrayData(
+                    type,
+                    1,
+                    [AC.BufferSlice(), AC._databuffer(Int32[0])];
+                    dictionary=pool,
+                    nullcount=0,
+                ),
+            ],
+            1,
+        )
+        for file in (false, true)
+            io = IOBuffer()
+            state = Arrow.beginwrite!(io, schema; file)
+            try
+                Arrow.writebatch!(state, batch(first))
+                Arrow.writebatch!(state, batch(copy(first)))
+                before = position(io)
+                @test_throws AC.ValidationError Arrow.writebatch!(state, batch(changed))
+                @test position(io) == before
+                Arrow.finishwrite!(state)
+                @test Tables.rowcount(Arrow.Table(take!(io))) == 2
+            finally
+                Arrow.abortwrite!(state)
+            end
+        end
+    end
+end
+
+@testset "String dictionary categories use their physical code units" begin
+    texts = ["", "cat-17", "éø漢", "\0a\0", repeat("long-", 24), repeat("x", 255)]
+    representations = function (text; inline=true)
+        padded = "_" * text * "_"
+        first = 2
+        last = prevind(padded, lastindex(padded))
+        values = (
+            text,
+            SubString(padded, first, last),
+            DataString(text),
+            LazyString(text),
+            ByteString(text),
+            SubString(ByteString(padded), first, last),
+        )
+        return inline ? (values..., InlineStrings.String255(text)) : values
+    end
+    mixed = AbstractString[
+        value for text in texts for value in representations(text; inline=false)
+    ]
+    expected = [text for text in texts for _ in representations(text; inline=false)]
+    layouts = (
+        (a=Arrow.DictEncode(mixed),),
+        (a=Arrow.DictEncode(InlineStrings.String255.(expected)),),
+        Tables.partitioner((
+            (a=Arrow.DictEncode(mixed[1:13]),),
+            (a=Arrow.DictEncode(mixed[14:end]),),
+        )),
+    )
+    for layout in layouts, file in (false, true), compress in (:none, :lz4, :zstd)
+        io = IOBuffer()
+        Arrow.write(io, layout; file, compress)
+        bytes = take!(io)
+        @test String.(Arrow.Table(bytes).a) == expected
+        core = file ? Arrow.readfile(bytes) : Arrow.readstream(bytes)
+        batch = file ? core[length(core)] : last(core.batches)
+        @test batch.columns[1].dictionary.len == length(texts)
+    end
+end
+
+@testset "Dictionary categories preserve primitive bits" begin
+    D = Decimal{20,2,Int128}
+    decimals = D[D("1.25"), D("2.50"), D("1.25")]
+    for values in (Int128[1, 2, 1], UInt128[1, 2, 1], decimals, [[x] for x in decimals]),
+        file in (false, true),
+        batchsize in (1, 64)
+
+        bytes = take!(Arrow.tobuffer((x=Arrow.DictEncode(values),); file, batchsize))
+        @test Arrow.Table(bytes).x == values
+    end
+    codes = reinterpret(PrimitiveCode, Int16[1, 2, 1])
+    bytes = take!(Arrow.tobuffer((x=Arrow.DictEncode(codes),)))
+    @test Arrow.Table(bytes).x == Int16[1, 2, 1]
+end
+
+@testset "dictencode writes a Dict column over several tables" begin
+    # After the first table the schema is declared nullable; a dictionary of
+    # maps keeps its entries and keys non-null.
+    parts = [(m=[Dict("a" => 1), Dict("b" => 2)],), (m=[Dict("c" => 3)],)]
+    expected = [Dict("a" => 1), Dict("b" => 2), Dict("c" => 3)]
+    for file in (false, true)
+        io = Arrow.write(IOBuffer(), Tables.partitioner(parts); dictencode=true, file)
+        t = Arrow.Table(take!(io))
+        @test getfield(t, :schema).fields[1].type isa AC.DictionaryType
+        @test [Dict(x) for x in t.m] == expected
+        io = IOBuffer()
+        Arrow.Writer(io; dictencode=true, file) do w
+            foreach(p -> Arrow.write(w, p), parts)
+        end
+        @test [Dict(x) for x in Arrow.Table(take!(io)).m] == expected
+    end
+end
+
+@testset "UUID columns are not dictionary-encoded" begin
+    uuids = UUID.(UInt128[1, 2, 1])
+    # pyarrow cannot read a dictionary of arrow.uuid values, so pooled UUIDs and
+    # `dictencode` write the values themselves.
+    for (col, kwargs) in (
+        (PooledArray(uuids), (;)),
+        (PooledArray(Union{Missing,UUID}[uuids; missing]), (;)),
+        (uuids, (dictencode=true,)),
+        (uuids, (dictencode=:u,)),
+        (PooledArray(uuids), (dictencode=:u,)),
+        (Any[uuids...], (dictencode=true,)),
+        (Any[uuids; missing], (dictencode=:u,)),
+    )
+        t = Arrow.Table(Arrow.tobuffer((u=col,); kwargs...))
+        # A dictionary of UUIDs reads back as UUIDs too, so check the schema.
+        @test !(getfield(t, :schema).fields[1].type isa AC.DictionaryType)
+        @test isequal(collect(t.u), collect(col))
+    end
+    err = @test_throws ArgumentError Arrow.write(IOBuffer(), (u=Arrow.DictEncode(uuids),))
+    @test occursin("column u holds UUIDs", err.value.msg)
+end
+
+@testset "Dictionary pool updates preserve NaN payloads" begin
+    for (F, U, bits) in (
+        (Float16, UInt16, 0x7e01),
+        (Float32, UInt32, 0x7fc00001),
+        (Float64, UInt64, 0x7ff8000000000001),
+    )
+        valuefield, initial = AC.fromjulia("values", F[reinterpret(F, bits)])
+        _, changed = AC.fromjulia("values", F[reinterpret(F, bits + U(1))])
+        type = AC.DictionaryType(AC.IntType(8, true), valuefield.type, false)
+        field = AC.Field("a", type; nullable=false)
+        schema = AC.Schema([field])
+        batch(pool) = AC.RecordBatch(
+            schema,
+            [
+                AC.ArrayData(
+                    type,
+                    1,
+                    [AC.BufferSlice(), AC._databuffer(Int8[0])];
+                    dictionary=pool,
+                    nullcount=0,
+                ),
+            ],
+            1,
+        )
+        @test !Arrow._poolsequal(valuefield, initial, changed)
+        bytes = Arrow.writestream(schema, [batch(initial), batch(changed)])
+        @test reinterpret(U, collect(F, Arrow.Table(bytes).a)) == U[bits, bits + U(1)]
+        for file in (false, true)
+            io = IOBuffer()
+            state = Arrow.beginwrite!(io, schema; file)
+            try
+                Arrow.writebatch!(state, batch(initial))
+                Arrow.writebatch!(state, batch(copy(initial)))
+                before = position(io)
+                @test_throws AC.ValidationError Arrow.writebatch!(state, batch(changed))
+                @test position(io) == before
+                Arrow.finishwrite!(state)
+                @test reinterpret(U, collect(F, Arrow.Table(take!(io)).a)) == U[bits, bits]
+            finally
+                Arrow.abortwrite!(state)
+            end
+        end
+    end
+end
+
+@testset "Null pools and growing Union pools" begin
+    nullfield = AC.Field("null", AC.NullType())
+    nullpool = AC.ArrayData(nullfield.type, 1, AC.BufferSlice[]; nullcount=1)
+    @test Arrow._poolsequal(nullfield, nullpool, copy(nullpool))
+    leftfield, left = AC.fromjulia("left", [[Int64(1)]])
+    rightfield, right = AC.fromjulia("right", [[Int64(1)]])
+    uniontype = AC.UnionType(AC.DenseMode, Int8[3, 7])
+    valuefield = AC.Field("pool", uniontype; children=[leftfield, rightfield])
+    pool(tags) = AC.ArrayData(
+        uniontype,
+        length(tags),
+        [AC._databuffer(tags), AC._databuffer(zeros(Int32, length(tags)))];
+        children=[left, right],
+        nullcount=0,
+    )
+    type = AC.DictionaryType(AC.IntType(32, true), uniontype, false)
+    field = AC.Field("a", type; children=valuefield.children)
+    schema = AC.Schema([field])
+    batch(values) = AC.RecordBatch(
+        schema,
+        [
+            AC.ArrayData(
+                type,
+                1,
+                [AC.BufferSlice(), AC._databuffer(Int32[0])];
+                dictionary=values,
+                nullcount=0,
+            ),
+        ],
+        1,
+    )
+    initial, grown = pool(Int8[3]), pool(Int8[3, 7])
+    bytes = Arrow.writefile(schema, [batch(initial), batch(grown)])
+    result = Arrow.readfile(bytes)[2].columns[1].dictionary
+    @test Arrow._poolsequal(valuefield, grown, result)
+    @test AC.slicebytes(AC.rolebuffer(result, AC.TYPE_IDS)) == UInt8[3, 7]
+    @test_throws AC.ValidationError Arrow.writefile(
+        schema,
+        [batch(initial), batch(pool(Int8[7, 3]))],
+    )
+end
+
+@testset "Dictionary delta limits and malformed payloads" begin
+    vf, pool = AC.fromjulia("pool", Int64[1, 2])
+    bytes = fixture(vf, [(false, pool, [0]), (true, pool, [3])])
+    @test_throws AC.ValidationError Arrow.Table(
+        bytes;
+        limits=Arrow.Limits(max_array_length=3),
+    )
+    dicts = Dict{Int64,AC.ArrayData}(0 => pool)
+    validated = AC._ValidatedDictionaries()
+    @test_throws Arrow.AllocationLimitError Arrow._updatedictionary!(
+        dicts,
+        validated,
+        Int64(0),
+        true,
+        vf,
+        pool,
+        Arrow.Limits(),
+        Arrow.AllocationBudget(0),
+    )
+    @test dicts[0] === pool
+    @test_throws AC.ValidationError Arrow._updatedictionary!(
+        dicts,
+        validated,
+        Int64(0),
+        true,
+        vf,
+        pool,
+        Arrow.Limits(max_buffer_bytes=24),
+        Arrow.AllocationBudget(1_000_000),
+    )
+    @test dicts[0] === pool
+    # Validation must precede reading offsets during concatenation.
+    sf, strings = AC.fromjulia("pool", ["ok"])
+    malformed = AC.ArrayData(
+        sf.type,
+        1,
+        [AC.BufferSlice(), AC._databuffer(Int32[0, 10]), AC._databuffer(UInt8[0x61])];
+        nullcount=0,
+    )
+    dicts = Dict{Int64,AC.ArrayData}(0 => strings)
+    @test_throws AC.ValidationError Arrow._updatedictionary!(
+        dicts,
+        validated,
+        Int64(0),
+        true,
+        sf,
+        malformed,
+        Arrow.Limits(),
+        Arrow.AllocationBudget(1_000_000),
+    )
+    @test dicts[0] === strings
+end
+
+@testset "Append after trailing dictionary updates" begin
+    vf, base = AC.fromjulia("pool", ["alpha", "beta"])
+    for delta in (false, true), compress in (:none, :lz4, :zstd)
+        poolvalues = delta ? ["gamma"] : ["gamma", "delta"]
+        _, update = AC.fromjulia("pool", poolvalues)
+        finalvalues = delta ? vcat(["alpha", "beta"], poolvalues) : poolvalues
+        bytes = fixture(vf, [(false, base, [0, 1]), (delta, update, nothing)]; compress)
+        @test Arrow.Table(bytes).a == ["alpha", "beta"]
+        mktempdir() do dir
+            for path in (false, true)
+                sink = path ? joinpath(dir, "trailing.arrows") : IOBuffer()
+                write(sink, bytes)
+                @test Arrow.append(sink, (; a=Arrow.DictEncode(finalvalues))) == sink
+                appended = path ? read(sink) : take!(sink)
+                @test Arrow.Table(appended).a == vcat(["alpha", "beta"], finalvalues)
+                parts = collect(Arrow.Stream(appended))
+                @test parts[1].a == ["alpha", "beta"]
+                @test parts[2].a == finalvalues
+
+                # Categories missing from the latest pool extend it (a delta).
+                sink = path ? joinpath(dir, "extended.arrows") : IOBuffer()
+                write(sink, bytes)
+                Arrow.append(sink, (; a=Arrow.DictEncode(["alpha", "beta"])))
+                appended = path ? read(sink) : take!(sink)
+                @test Arrow.Table(appended).a == ["alpha", "beta", "alpha", "beta"]
+            end
+        end
+    end
+end
+
+end
diff --git a/test/ipc_read_battery.jl b/test/ipc_read_battery.jl
new file mode 100644
index 00000000..2a1335c4
--- /dev/null
+++ b/test/ipc_read_battery.jl
@@ -0,0 +1,725 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ---------------------------------------------------------------------------
+# Acceptance: 2.x writes, Core reads
+# ---------------------------------------------------------------------------
+
+function ipc_read_battery()
+    hostgate = try
+        _framemessages(heapregion(UInt8[]), Limits(), UInt32(0x01020304))
+        false
+    catch e
+        e isa ValidationError && occursin("little-endian host", e.msg)
+    end
+    @assert hostgate
+    println("unsupported hosts fail before generated metadata getters ✓")
+
+    emptybuffers = readstream(_misaligned_empty_buffers_stream())
+    @assert emptybuffers.batches[1].nrows == 0
+    @assert isempty(
+        materialize(emptybuffers.schema.fields[1], emptybuffers.batches[1].columns[1]),
+    )
+    println("empty struct vectors need no nominal element alignment ✓")
+
+    @assert _rejects(() -> readstream(_misaligned_empty_children_stream()))
+    println("vector length words are aligned before generated getters ✓")
+
+    emptyvalue = readstream(_metadata_value_stream(true))
+    @assert collect(emptyvalue.schema.metadata) == ["owner" => ""]
+    @assert _rejects(() -> readstream(_metadata_value_stream(false)))
+    println("metadata values are present, including explicit empty strings ✓")
+
+    expected = MIXED_EXPECTED
+    bytes = _mixed_two_partitions_bytes()
+
+    stream = readstream(bytes)
+    @assert length(stream.batches) == 2
+
+    dictpos = findfirst(f -> f.type isa DictionaryType, stream.schema.fields)
+    dictpos === nothing && error("acceptance stream has no dictionary field")
+    dictfield = stream.schema.fields[dictpos]
+    dictpool = stream.batches[1].columns[dictpos].dictionary
+    @assert dictpool === stream.batches[2].columns[dictpos].dictionary
+    validated = AC._ValidatedDictionaries()
+    validate_semantic(AC.dictvaluefield(dictfield, dictfield.type), dictpool)
+    validated[dictpool] = nothing
+    for b in stream.batches
+        validaterecordcolumns(stream.schema.fields, b.columns, validated)
+    end
+    @assert length(validated) == 1
+
+    wanted = (
+        ints=Any[1, 2, 3, 4, 5],
+        floats=Any[1.5, missing, 3.5, missing, 5.5],
+        bools=Any[true, false, true, missing, false],
+        strs=Any["hey", "", missing, "αβ∀", "last"],
+        lists=Any[[1, 2], Int64[], [3], missing, [4, 5, 6]],
+        # Core struct scalars are ordered pairs; the 2.x-written fixture
+        # above was fed NamedTuples.
+        structs=Any[
+            ["a" => 1, "b" => "x"],
+            ["a" => 2, "b" => "y"],
+            ["a" => 3, "b" => "z"],
+            ["a" => 4, "b" => "w"],
+            ["a" => 5, "b" => "v"],
+        ],
+        dict=Any["lo", "hi", "lo", missing, "hi"],
+    )
+    for b in stream.batches
+        for (i, f) in enumerate(stream.schema.fields)
+            got = materialize(f, b.columns[i])
+            want = wanted[Symbol(f.name)]
+            @assert isequal(collect(Any, got), want) "column $(f.name): got $got, want $want"
+        end
+    end
+    println("all columns round-tripped through ArrowCore ✓")
+
+    # Compressed acceptance: the same table, written by 2.x with each codec
+    # (dictionary batches are compressed too), read back through Core. The
+    # per-buffer Int64 prefix is bounded before allocation, the decompressed
+    # size must match the declaration, and every decompressed buffer lives in
+    # its own exact-sized owned region.
+    for (codecname, kw) in (("lz4", :lz4), ("zstd", :zstd))
+        cbytes = _fixture2x("mixed-two-partitions-$(codecname)") do
+            cio = IOBuffer()
+            cwritetable = merge(expected, (dict=Arrow.DictEncode(expected.dict),))
+            Arrow.write(
+                cio,
+                Tables.partitioner([cwritetable, cwritetable]);
+                file=false,
+                compress=kw,
+            )
+            take!(cio)
+        end
+        cstream = readstream(cbytes)
+        @assert length(cstream.batches) == 2
+        for b in cstream.batches
+            for (i, f) in enumerate(cstream.schema.fields)
+                got = materialize(f, b.columns[i])
+                want = wanted[Symbol(f.name)]
+                @assert isequal(collect(Any, got), want) "compressed $(codecname) column $(f.name): got $got"
+            end
+        end
+        println("$(codecname)-compressed stream (incl. dictionary batches) decodes ✓")
+
+        # Adversarial prefix manipulation, located via the framer itself:
+        # find the first record batch's first nonempty buffer and rewrite its
+        # Int64 uncompressed-length prefix in the raw bytes.
+        prefixpos = let
+            region = heapregion(copy(cbytes))
+            msgs = framemessages(region, Limits())
+            pos = Int64(-1)
+            for fm in msgs
+                fm.header_type == UInt8(3) || continue   # RecordBatch
+                rb = fm.msg.header::Meta.RecordBatch
+                for mb in rb.buffers
+                    if mb.length > 0
+                        pos = fm.body.offset + Int64(mb.offset)
+                        break
+                    end
+                end
+                pos >= 0 && break
+            end
+            @assert pos >= 0 "no nonempty compressed buffer found"
+            pos
+        end
+        # (a) a hostile declared length allocates only what the column reads:
+        # decoding stops at the column's bytes, which are the original values
+        lying = copy(cbytes)
+        lying[(prefixpos + 1):(prefixpos + 8)] .= reinterpret(UInt8, [Int64(2)^61])
+        lyingstream = readstream(lying)
+        for (i, f) in enumerate(lyingstream.schema.fields)
+            got = materialize(f, lyingstream.batches[1].columns[i])
+            @assert isequal(collect(Any, got), wanted[Symbol(f.name)])
+        end
+        @assert (@allocated readstream(lying)) < 1 << 24
+        println(
+            "$(codecname): hostile decompressed-length prefix decodes only the column's bytes ✓",
+        )
+        # (b) a prefix that understates the payload is a mismatch error, not
+        # silent truncation
+        short = copy(cbytes)
+        short[(prefixpos + 1):(prefixpos + 8)] .= reinterpret(UInt8, [Int64(1)])
+        @assert _rejects(() -> readstream(short))
+        println("$(codecname): declared/actual decompressed-size mismatch rejected ✓")
+    end
+
+    # Direct codec-boundary regressions. The destination is exactly the
+    # declared size, so a compressed bomb cannot force a larger allocation.
+    for (codecname, codec, compressor) in (
+        ("lz4", CODEC_LZ4_FRAME, Arrow.LZ4FrameCompressor),
+        ("zstd", CODEC_ZSTD, Arrow.CZSTD.ZstdCompressor),
+    )
+        emptyframe = transcode(compressor, UInt8[])
+        @assert isempty(_decode_fixture(codec, emptyframe, 0))
+        oneframe = transcode(compressor, UInt8[0x41])
+        @assert _rejects(() -> _decode_fixture(codec, oneframe, 0))
+        @assert _rejects(() -> _decode_fixture(codec, UInt8[], 0))
+        @assert _decode_fixture(codec, UInt8[0x41, 0x42], -1) == UInt8[0x41, 0x42]
+
+        bomb = transcode(compressor, zeros(UInt8, 1024 * 1024))
+        @assert _rejects(() -> _decode_fixture(codec, bomb, 1; budget=1))
+        if codec == CODEC_LZ4_FRAME
+            for n = 1:3
+                @assert _rejects(() -> _decode_fixture(codec, emptyframe[1:(end - n)], 0))
+            end
+            second = transcode(compressor, UInt8[0x42])
+            @assert _rejects(() -> _decode_fixture(codec, vcat(oneframe, second), 2))
+        else
+            @assert _rejects(() -> _decode_fixture(codec, oneframe[1:(end - 1)], 1))
+        end
+        println("$(codecname): empty, truncated, and bounded-output frames are checked ✓")
+    end
+
+    # A corrupt LZ4 frame must not erase the native pointer before reader
+    # cleanup. CodecLz4's streaming wrapper does erase it on this error, so
+    # the adapter owns the raw context and frees it directly.
+    # Fund exactly the empty output vector. A zero budget now fails at the
+    # allocation gate before the decoder owns a native context, which would
+    # not exercise the cleanup seam below.
+    badstate = DecodeState(AllocationBudget(AC._materializedvectorbytes(UInt8, Int64(0))))
+    badbytes = _compressed_wire(UInt8[0x01, 0x02, 0x03], 0)
+    badwire = BufferSlice(heapregion(badbytes), 0, length(badbytes))
+    badcursor = DecodeCursor(
+        nothing,
+        nothing,
+        BufferSlice(),
+        Limits();
+        codec=CODEC_LZ4_FRAME,
+        state=badstate,
+    )
+    try
+        @assert _rejects(() -> _decompressbuffer!(badcursor, badwire))
+        @assert badstate.lz4 != C_NULL
+    finally
+        close(badstate)
+    end
+    @assert badstate.lz4 == C_NULL
+    println("corrupt LZ4 frames retain their context until explicit cleanup ✓")
+
+    # The schema feature is standard in V5. Arrow.jl 2.x omits it from its
+    # compressed output, which this adapter accepts for compatibility. A
+    # standards-conforming stream that declares it must also be accepted.
+    simplebytes = _fixture2x("int64-three-zstd") do
+        simpleio = IOBuffer()
+        Arrow.write(simpleio, (x=Int64[1, 2, 3],); file=false, compress=:zstd)
+        take!(simpleio)
+    end
+    simpleframes = _frameinfo(simplebytes)
+    standardschema = _int64_schema_stream(Int64[2])
+    resize!(standardschema, length(standardschema) - 8)
+    standardbytes = vcat(
+        standardschema,
+        simplebytes[only(f.frame for f in simpleframes if f.kind == UInt8(3))],
+        simplebytes[only(f.frame for f in simpleframes if f.kind == UInt8(0))],
+    )
+    standardstream = readstream(standardbytes)
+    @assert materialize(
+        standardstream.schema.fields[1],
+        standardstream.batches[1].columns[1],
+    ) == Any[1, 2, 3]
+
+    v4compressed = copy(simplebytes)
+    for (i, frame) in pairs(simpleframes)
+        frame.kind == UInt8(0) && continue
+        _mutatemessage!(v4compressed, i) do meta, msg
+            _write_i16!(meta, _vfield(msg, 0, 2; required=true), Int16(3))
+        end
+    end
+    @assert _rejects(() -> readstream(v4compressed))
+    println("COMPRESSED_BODY is accepted in V5 and BodyCompression is rejected in V4 ✓")
+
+    # The allocation limit is reader-wide. It does not reset for each eager
+    # batch retained by IPCStream.
+    large = (x=zeros(Int64, 10_000),)
+    onebytes = _fixture2x("large-zeros-zstd") do
+        oneio = IOBuffer()
+        Arrow.write(oneio, large; file=false, compress=:zstd)
+        take!(oneio)
+    end
+    twobytes = _fixture2x("large-zeros-zstd-two-partitions") do
+        twoio = IOBuffer()
+        Arrow.write(twoio, Tables.partitioner([large, large]); file=false, compress=:zstd)
+        take!(twoio)
+    end
+
+    # Derive the exact boundary from this reader instead of baking in an
+    # allocation threshold that becomes stale when accounting deepens.
+    probe_limit = Int64(1_000_000_000)
+    probe_limits = Limits(max_total_allocated_bytes=probe_limit)
+    onebudget = AllocationBudget(probe_limit)
+    @assert length(Arrow._readstream(onebytes, probe_limits, onebudget).batches) == 1
+    onecharge = probe_limit - _remaining(onebudget)
+    twobudget = AllocationBudget(probe_limit)
+    @assert length(Arrow._readstream(twobytes, probe_limits, twobudget).batches) == 2
+    @assert probe_limit - _remaining(twobudget) > onecharge
+
+    aggregate_limit = Limits(max_total_allocated_bytes=onecharge)
+    @assert length(readstream(onebytes; limits=aggregate_limit).batches) == 1
+    @assert _rejects(() -> readstream(twobytes; limits=aggregate_limit))
+    println("metadata and decompressed bytes share one reader-wide budget ✓")
+
+    for kw in (:lz4, :zstd)
+        emptycompressed = _fixture2x("int64-empty-$(kw)") do
+            emptyio = IOBuffer()
+            Arrow.write(emptyio, (x=Int64[],); file=false, compress=kw)
+            take!(emptyio)
+        end
+        emptystream = readstream(emptycompressed)
+        @assert isempty(
+            materialize(emptystream.schema.fields[1], emptystream.batches[1].columns[1]),
+        )
+    end
+    println("zero-byte compressed buffers may omit the prefix ✓")
+
+    # The 2.x writer permits a coefficient outside its declared decimal
+    # precision. Precision is advisory at the semantic boundary (the gold
+    # corpus itself carries five digits in a decimal(3,2)); the opt-in
+    # validate_full tier enforces the declaration.
+    baddecbytes = _fixture2x("decimal-over-precision") do
+        baddecimalio = IOBuffer()
+        D = Arrow.Decimal{Int32(1),Int32(0),Int128}
+        Arrow.write(baddecimalio, (d=D[D(Int128(10))],); file=false)
+        take!(baddecimalio)
+    end
+    baddec = readstream(baddecbytes)
+    @assert _rejects(
+        () -> AC.validate_full(baddec.schema.fields[1], baddec.batches[1].columns[1]),
+    )
+    println("decimal coefficients outside declared precision are validate_full's ✓")
+
+    pulled = readstream(bytes)
+    @assert nextbatch!(pulled) isa RecordBatch
+    @assert nextbatch!(pulled) isa RecordBatch
+    @assert nextbatch!(pulled) === nothing
+    println("RecordBatchSource pull protocol works ✓")
+
+    # Framing limits actually bite: a 16-byte body cap rejects this stream
+    # BEFORE any decode work happens.
+    caught = try
+        readstream(bytes; limits=Limits(max_body_bytes=16))
+        false
+    catch e
+        e isa ValidationError
+    end
+    @assert caught
+    println("stage-1 resource limits reject oversized bodies ✓")
+    @assert _rejects(() -> readstream(bytes; limits=Limits(max_buffer_bytes=1)))
+    @assert _rejects(() -> readstream(bytes; limits=Limits(max_total_allocated_bytes=1)))
+    nmessages = length(framemessages(heapregion(bytes)))
+    @assert length(readstream(bytes; limits=Limits(max_messages=nmessages)).batches) == 2
+    println("buffer, allocation, and exact message-count limits work ✓")
+
+    # Legal FlatBuffer aliasing must not amplify a small metadata message
+    # into an unbounded Core schema or repeated large String copies.
+    aliased = _aliased_field_stream(14)
+    @assert _rejects(() -> readstream(aliased; limits=Limits(max_metadata_objects=100)))
+    sharedname = _shared_name_stream(10, 50_000)
+    @assert _rejects(
+        () -> readstream(
+            sharedname;
+            limits=Limits(max_total_allocated_bytes=200_000, max_metadata_objects=1_000),
+        ),
+    )
+    println("logical metadata expansion and repeated strings are budgeted ✓")
+
+    # Truncation semantics, both halves of the append rule:
+    # (a) losing only the 8-byte EOS block = boundary truncation, ACCEPTED
+    #     (the stream ends after its last complete message);
+    # (b) losing bytes of a message body = corruption, a clean framing error
+    #     — never a silent empty/short stream and never
+    #     an aliased read.
+    boundary = readstream(bytes[1:(end - 8)])
+    @assert length(boundary.batches) == 2
+    println("boundary truncation (missing EOS) tolerated by design ✓")
+    caught = try
+        readstream(bytes[1:(end - 100)])
+        false
+    catch e
+        e isa ValidationError
+    end
+    @assert caught
+    println("mid-body truncation is a framing error, not a silent short read ✓")
+
+    # A partial next prefix is corruption. An explicit EOS consumes the exact
+    # stream, so any bytes after it are also rejected.
+    for n = 1:7
+        @assert _rejects(() -> readstream(bytes[1:(end - n)]))
+    end
+    @assert _rejects(() -> readstream(vcat(bytes, UInt8[0x01])))
+    println("partial EOS and trailing junk are rejected ✓")
+
+    # Mutate metadata in place to pin verifier and decoder boundaries.
+    frames = _frameinfo(bytes)
+    recordidx = findfirst(x -> x.kind == 3, frames)
+    dictidx = findfirst(x -> x.kind == 2, frames)
+
+    corrupt = copy(bytes)
+    _mutatemessage!(corrupt, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        vecp = _vref(schema, 1; required=true)
+        _write_u32!(meta, vecp, UInt32(1_000_001))
+    end
+    @assert _rejects(
+        () -> readstream(corrupt; limits=Limits(max_metadata_objects=1_000_000)),
+    )
+
+    oldversion = copy(bytes)
+    _mutatemessage!(oldversion, 1) do meta, msg
+        _write_i16!(meta, _vfield(msg, 0, 2; required=true), Int16(2)) # V3
+    end
+    @assert _rejects(() -> readstream(oldversion))
+
+    mixedversion = copy(bytes)
+    _mutatemessage!(mixedversion, recordidx) do meta, msg
+        _write_i16!(meta, _vfield(msg, 0, 2; required=true), Int16(3)) # V4
+    end
+    @assert _rejects(() -> readstream(mixedversion))
+    println("FlatBuffer bounds and metadata versions are verified ✓")
+
+    # Arrow 0.17 V4 used Message custom metadata for its experimental
+    # compression marker. The body below is a real length-prefixed LZ4 frame;
+    # it must fail closed instead of exposing that prefix as an Int64 value.
+    @assert _rejects(() -> readstream(_experimental_v4_stream(Int64(42))))
+    println("legacy V4 compression is rejected before body decoding ✓")
+
+    bigendian = copy(bytes)
+    _mutatemessage!(bigendian, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        p = _vfield(schema, 0, 2)
+        if p === nothing
+            # The default Little value is omitted. The generated object has
+            # two padding bytes after its fields reference; publish that slot.
+            off = schema.olen - 2
+            off >= 4 || error("schema table has no endian slot storage")
+            _writele!(meta, schema.vpos + 4, UInt64(off), 2)
+            p = schema.pos + off
+        end
+        _write_i16!(meta, p, Int16(1))
+    end
+    @assert _rejects(() -> readstream(bigendian))
+
+    badschema = copy(bytes)
+    _mutatemessage!(badschema, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        fieldsvec = _vvector(schema, 1, 4; required=true)
+        start, _ = fieldsvec
+        firstfield = _vtable(meta, start + Int64(_vu32(meta, start)))
+        inttype = _vtable(meta, _vref(firstfield, 3; required=true))
+        _write_i32!(meta, _vfield(inttype, 0, 4; required=true), Int32(24))
+    end
+    @assert _rejects(() -> readstream(badschema))
+
+    badutf8 = copy(bytes)
+    _mutatemessage!(badutf8, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        start, n = _vvector(schema, 1, 4; required=true)
+        n > 0 || error("schema fixture has no fields")
+        firstfield = _vtable(meta, start + Int64(_vu32(meta, start)))
+        name = _vref(firstfield, 0; required=true)
+        _vu32(meta, name) > 0 || error("schema fixture has an empty field name")
+        meta[name + 5] = 0xff
+    end
+    @assert _rejects(() -> readstream(badutf8))
+    println("endianness and schema descriptors are checked before batches ✓")
+
+    # Zero is the FlatBuffers scalar default and may be omitted. Both widths
+    # are valid Arrow descriptors, including schema-only streams.
+    fsb = readstream(_zero_width_schema_stream(false))
+    @assert fsb.schema.fields[1].type == FixedSizeBinaryType(0)
+    fsl = readstream(_zero_width_schema_stream(true))
+    @assert fsl.schema.fields[1].type == FixedSizeListType(0)
+    println("omitted zero-width fixed-size defaults are accepted ✓")
+
+    badbody = copy(bytes)
+    _mutatemessage!(badbody, recordidx) do meta, msg
+        _write_i64!(meta, _vfield(msg, 3, 8; required=true), Int64(17))
+    end
+    @assert _rejects(() -> readstream(badbody))
+
+    badrowcount = copy(bytes)
+    _mutatemessage!(badrowcount, recordidx) do meta, msg
+        rb = _headertable(meta, msg)
+        _write_i64!(meta, _vfield(rb, 0, 8; required=true), Int64(999))
+    end
+    @assert _rejects(() -> readstream(badrowcount))
+
+    negativebuffer = copy(bytes)
+    _mutatemessage!(negativebuffer, recordidx) do meta, msg
+        rb = _headertable(meta, msg)
+        start, _ = _vvector(rb, 2, 16; required=true)
+        _write_i64!(meta, start, Int64(-16))
+    end
+    @assert _rejects(() -> readstream(negativebuffer))
+
+    overlap = _fixture2x("two-int64-columns") do
+        overlapio = IOBuffer()
+        Arrow.write(overlapio, (x=Int64[1], y=Int64[2]); file=false)
+        take!(overlapio)
+    end
+    overlaprecord = findfirst(x -> x.kind == 3, _frameinfo(overlap))
+    _mutatemessage!(overlap, overlaprecord) do meta, msg
+        rb = _headertable(meta, msg)
+        start, n = _vvector(rb, 2, 16; required=true)
+        n >= 4 || error("overlap fixture has fewer than four buffers")
+        _write_i64!(meta, start + 3 * 16, Int64(0))
+    end
+    @assert _rejects(() -> readstream(overlap))
+    println("body alignment, non-overlap, row counts, and body authority are pinned ✓")
+
+    # A dictionary batch must consume its entire node/buffer declaration.
+    wrongdict = copy(bytes)
+    _mutatemessage!(wrongdict, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        start, n = _vvector(schema, 1, 4; required=true)
+        for i = 0:(n - 1)
+            ep = start + 4i
+            field = _vtable(meta, ep + Int64(_vu32(meta, ep)))
+            _vref(field, 4) === nothing && continue
+            tagp = _vfield(field, 2, 1; required=true)
+            meta[tagp + 1] = UInt8(6) # Utf8 value type -> Bool
+            break
+        end
+    end
+    @assert _rejects(() -> readstream(wrongdict))
+
+    # A repeated full dictionary is replacement, even without a schema
+    # feature declaration (as emitted by PyArrow).
+    dictidx === nothing && error("acceptance stream has no dictionary batch")
+    spans = _frameinfo(bytes)
+    duplicate = vcat(
+        bytes[1:last(spans[dictidx].frame)],
+        bytes[spans[dictidx].frame],
+        bytes[(last(spans[dictidx].frame) + 1):end],
+    )
+    @assert length(readstream(duplicate).batches) == length(stream.batches)
+
+    replaced = readstream(_dictionary_replacement_stream())
+    @assert length(replaced.batches) == 2
+    df = replaced.schema.fields[1]
+    @assert materialize(df, replaced.batches[1].columns[1]) == ["aa", "bb", "aa"]
+    @assert materialize(df, replaced.batches[2].columns[1]) == ["xx", "yy", "xx"]
+    @assert replaced.batches[1].columns[1].dictionary !==
+            replaced.batches[2].columns[1].dictionary
+    println(
+        "dictionary replacement accepts absent feature flags and snapshots stay immutable ✓",
+    )
+
+    nestedvals = [[Int64(1), 2], [3]]
+    sharedbytes = _fixture2x("shared-nested-dict") do
+        sharedio = IOBuffer()
+        Arrow.write(
+            sharedio,
+            (a=Arrow.DictEncode(nestedvals, 7), b=Arrow.DictEncode(nestedvals, 7));
+            file=false,
+        )
+        take!(sharedio)
+    end
+    sharedstream = readstream(sharedbytes)
+    for i = 1:2
+        @assert materialize(
+            sharedstream.schema.fields[i],
+            sharedstream.batches[1].columns[i],
+        ) == nestedvals
+    end
+    sharedcols = sharedstream.batches[1].columns
+    @assert sharedcols[1].dictionary === sharedcols[2].dictionary
+    sharedpool = sharedcols[1].dictionary
+    sharedtype = sharedstream.schema.fields[1].type::DictionaryType
+    validate_semantic(
+        AC.dictvaluefield(sharedstream.schema.fields[1], sharedtype),
+        sharedpool,
+    )
+    sharedvalidated = AC._ValidatedDictionaries(sharedpool => nothing)
+    validaterecordcolumns(sharedstream.schema.fields, sharedcols, sharedvalidated)
+    @assert length(sharedvalidated) == 1
+    println("shared dictionary ids reuse one full pool certificate ✓")
+
+    poolbytes = _fixture2x("pooled-view-dict") do
+        pool = PooledArray(Union{Missing,String}[missing, "x"])
+        poolio = IOBuffer()
+        Arrow.write(poolio, (d=Arrow.DictEncode(view(pool, 2:2)),); file=false)
+        take!(poolio)
+    end
+    _mutatemessage!(poolbytes, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        start, n = _vvector(schema, 1, 4; required=true)
+        for i = 0:(n - 1)
+            ep = start + 4i
+            field = _vtable(meta, ep + Int64(_vu32(meta, ep)))
+            _vref(field, 4) === nothing && continue
+            nullable = _vfield(field, 1, 1; required=true)
+            meta[nullable + 1] = 0x00
+            return
+        end
+        error("dictionary fixture has no dictionary field")
+    end
+    poolstream = readstream(poolbytes)
+    @assert materialize(poolstream.schema.fields[1], poolstream.batches[1].columns[1]) ==
+            ["x"]
+    println("dictionary pool nullability is independent from index fields ✓")
+
+    nullvalues = Union{Missing,String}[missing, missing]
+    nullbytes = _fixture2x("all-null-dict") do
+        nullio = IOBuffer()
+        Arrow.write(nullio, (d=Arrow.DictEncode(nullvalues),); file=false)
+        take!(nullio)
+    end
+    nullframes = _frameinfo(nullbytes)
+    nschema = findfirst(x -> x.kind == 1, nullframes)
+    ndict = findfirst(x -> x.kind == 2, nullframes)
+    nrecord = findfirst(x -> x.kind == 3, nullframes)
+    neos = findfirst(x -> x.kind == 0, nullframes)
+    all(x -> x !== nothing, (nschema, ndict, nrecord, neos)) ||
+        error("all-null dictionary fixture has unexpected framing")
+    reordered = vcat(
+        nullbytes[nullframes[nschema].frame],
+        nullbytes[nullframes[nrecord].frame],
+        nullbytes[nullframes[ndict].frame],
+        nullbytes[nullframes[neos].frame],
+    )
+    nullstream = readstream(reordered)
+    @assert isequal(
+        materialize(nullstream.schema.fields[1], nullstream.batches[1].columns[1]),
+        nullvalues,
+    )
+    # A streaming consumer receives an all-null batch before the producer
+    # sends its dictionary, without reading into subsequent batches.
+    repeated = vcat(
+        nullbytes[nullframes[nschema].frame],
+        nullbytes[nullframes[nrecord].frame],
+        nullbytes[nullframes[nrecord].frame],
+        nullbytes[nullframes[ndict].frame],
+        nullbytes[nullframes[neos].frame],
+    )
+    nullio = IOBuffer(repeated)
+    incremental = Arrow.Stream(nullio)
+    part, state = iterate(incremental)
+    @assert isequal(part.d, nullvalues)
+    @assert position(nullio) ==
+            length(nullframes[nschema].frame) + length(nullframes[nrecord].frame)
+    part, state = iterate(incremental, state)
+    @assert isequal(part.d, nullvalues)
+    @assert position(nullio) ==
+            length(nullframes[nschema].frame) + 2 * length(nullframes[nrecord].frame)
+    @assert iterate(incremental, state) === nothing
+    # EOF still checks that every promised dictionary eventually arrived.
+    missingpool = vcat(
+        nullbytes[nullframes[nschema].frame],
+        nullbytes[nullframes[nrecord].frame],
+        nullbytes[nullframes[neos].frame],
+    )
+    @assert _rejects(() -> collect(Arrow.Stream(IOBuffer(missingpool))))
+    println("all-null dictionary references may precede their dictionary ✓")
+
+    # The 2.x writer omits Map.keysSorted when false. The generated getter
+    # returns `nothing`; the adapter must apply the FlatBuffers default.
+    mapbytes = _fixture2x("map-default-keyssorted") do
+        mapio = IOBuffer()
+        Arrow.write(mapio, (m=[Dict("a" => Int64(1))],); file=false)
+        take!(mapio)
+    end
+    mapstream = readstream(mapbytes)
+    mf = mapstream.schema.fields[1]
+    @assert mf.type == MapType(false)
+    @assert materialize(mf, mapstream.batches[1].columns[1]) == [["a" => 1]]
+    println("valid 2.x Map streams decode with default keysSorted=false ✓")
+
+    emptybytes = _fixture2x("int64-three") do
+        emptyio = IOBuffer()
+        Arrow.write(emptyio, (x=Int64[1, 2, 3],); file=false)
+        take!(emptyio)
+    end
+    emptyframes = _frameinfo(emptybytes)
+    emptyrecord = findfirst(x -> x.kind == 3, emptyframes)
+    emptyrecord === nothing && error("empty-schema fixture has no record batch")
+    _mutatemessage!(emptybytes, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        fieldsref = _vref(schema, 1; required=true)
+        _write_u32!(meta, fieldsref, UInt32(0))
+    end
+    _mutatemessage!(emptybytes, emptyrecord) do meta, msg
+        rb = _headertable(meta, msg)
+        nodesref = _vref(rb, 1; required=true)
+        buffersref = _vref(rb, 2; required=true)
+        _write_u32!(meta, nodesref, UInt32(0))
+        _write_u32!(meta, buffersref, UInt32(0))
+    end
+    emptystream = readstream(emptybytes)
+    @assert isempty(emptystream.schema.fields)
+    @assert emptystream.batches[1].nrows == 3
+    missingfields = copy(emptybytes)
+    _mutatemessage!(missingfields, 1) do meta, msg
+        schema = _headertable(meta, msg)
+        _write_i16!(meta, schema.vpos + 6, Int16(0)) # omit fields vtable slot
+    end
+    @assert _rejects(() -> readstream(missingfields))
+    toolong = copy(emptybytes)
+    _mutatemessage!(toolong, emptyrecord) do meta, msg
+        rb = _headertable(meta, msg)
+        _write_i64!(meta, _vfield(rb, 0, 8; required=true), typemax(Int64))
+    end
+    @assert _rejects(() -> readstream(toolong; limits=Limits(max_array_length=1)))
+    println("zero-column batches retain their explicit row count ✓")
+
+    emptyrecordbytes = _fixture2x("int64-empty") do
+        emptyrecordio = IOBuffer()
+        Arrow.write(emptyrecordio, (x=Int64[],); file=false)
+        take!(emptyrecordio)
+    end
+    emptyrecordstream = readstream(emptyrecordbytes)
+    @assert emptyrecordstream.batches[1].nrows == 0
+    @assert isempty(
+        materialize(
+            emptyrecordstream.schema.fields[1],
+            emptyrecordstream.batches[1].columns[1],
+        ),
+    )
+
+    emptydictbytes = _fixture2x("empty-dict") do
+        emptydictio = IOBuffer()
+        Arrow.write(emptydictio, (d=Arrow.DictEncode(String[]),); file=false)
+        take!(emptydictio)
+    end
+    emptydictstream = readstream(emptydictbytes)
+    @assert emptydictstream.batches[1].nrows == 0
+    @assert isempty(
+        materialize(
+            emptydictstream.schema.fields[1],
+            emptydictstream.batches[1].columns[1],
+        ),
+    )
+    println("omitted zero-length record and dictionary lengths use defaults ✓")
+
+    metabytes2x = _fixture2x("schema-field-metadata") do
+        metaio = IOBuffer()
+        Arrow.write(
+            metaio,
+            (x=Int64[1],);
+            file=false,
+            metadata=Dict("owner" => "jacob"),
+            colmetadata=Dict(:x => Dict("unit" => "count")),
+        )
+        take!(metaio)
+    end
+    metastream = readstream(metabytes2x)
+    @assert Dict(metastream.schema.metadata) == Dict("owner" => "jacob")
+    @assert Dict(metastream.schema.fields[1].metadata) == Dict("unit" => "count")
+    println("schema and field metadata are preserved ✓")
+    println()
+    println("IPC framing, verification, decoding, and adversarial checks passed.")
+end
diff --git a/test/ipc_view_output_tests.jl b/test/ipc_view_output_tests.jl
new file mode 100644
index 00000000..2add3606
--- /dev/null
+++ b/test/ipc_view_output_tests.jl
@@ -0,0 +1,394 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module IPCViewOutputTests
+
+using Test
+using Random
+using Arrow
+using DataStrings
+using DataStrings: StringVector, StringPayload, BytesVector, DataBytes
+
+const AC = Arrow.AC
+const UNUSED = "UNUSED_SYNTHETIC_BUFFER_TEXT"
+const LONG = "selected long string \0 with λ"
+
+function fixture()
+    raw = Vector{UInt8}(codeunits(UNUSED * LONG * UNUSED))
+    extra = Vector{UInt8}(codeunits(UNUSED * "another selected string" * UNUSED))
+    p = DataStrings.view_payload(
+        raw,
+        ncodeunits(UNUSED) + 1,
+        ncodeunits(LONG),
+        0,
+        ncodeunits(UNUSED),
+    )
+    q = DataStrings.view_payload(extra, ncodeunits(UNUSED) + 1, 23, 2, ncodeunits(UNUSED))
+    inline = DataStrings.inline_payload(codeunits("λ\0ok"), 1, 5)
+    payloads = [p, DataStrings.PAYLOAD_MISSING, inline, q, p]
+    buffers = [raw, Vector{UInt8}(codeunits(UNUSED)), extra]
+    return StringVector{Union{Missing,DataString}}(payloads, buffers)
+end
+
+function packedfixture()
+    first, second = "first selected long string", "second selected long string"
+    raw = collect(codeunits(first * second * UNUSED))
+    p = DataStrings.view_payload(raw, 1, ncodeunits(first), 0, 0)
+    q = DataStrings.view_payload(
+        raw,
+        ncodeunits(first) + 1,
+        ncodeunits(second),
+        0,
+        ncodeunits(first),
+    )
+    inline = DataStrings.inline_payload(codeunits("ok"), 1, 2)
+    return StringVector{Union{Missing,DataString}}(
+        [p, q, p, DataStrings.PAYLOAD_MISSING, inline],
+        [raw],
+    )
+end
+
+function checkoutput(bytes, expected, ndata; file, compress)
+    @test isequal(Arrow.Table(bytes).s, expected)
+    decoded = file ? Arrow.readfile(bytes) : Arrow.readstream(bytes)
+    f = decoded.schema.fields[1]
+    @test f.type == AC.ViewType(true)
+    # A table with no rows writes no record batch.
+    isempty(expected) &&
+        return @test (file ? length(decoded) : length(decoded.batches)) == 0
+    d = (file ? decoded[1] : decoded.batches[1]).columns[1]
+    @test AC.validate_full(f, d) === d
+    @test sum(b.len for b in d.buffers[3:end]; init=0) == ndata
+    @test all(b -> findfirst(codeunits(UNUSED), AC.slicebytes(b)) === nothing, d.buffers)
+    if compress === nothing
+        @test findfirst(codeunits(UNUSED), bytes) === nothing
+    end
+    return d
+end
+
+@testset "IPC view output contains referenced content" begin
+    @testset "shared buffers, selections, nulls, and both writers" begin
+        col = fixture()
+        beforepayloads, beforebuffers = copy(col.payloads), deepcopy(col.buffers)
+        for file in (true, false), compress in (nothing, :lz4, :zstd)
+            for selection in ([1, 2, 3, 4, 5], [4, 2, 1], [3], [2], Int[])
+                selected = StringVector{Union{Missing,DataString}}(
+                    col.payloads[selection],
+                    col.buffers,
+                )
+                expected = DataStrings.materialize(selected)
+                ndata =
+                    (1 in selection || 5 in selection ? ncodeunits(LONG) : 0) +
+                    (4 in selection ? 23 : 0)
+                io = IOBuffer()
+                Arrow.write(
+                    io,
+                    (s=selected,);
+                    file=file,
+                    compress=compress,
+                    stringview=true,
+                )
+                eager = take!(io)
+                checkoutput(eager, expected, ndata; file=file, compress=compress)
+                w = Arrow.Writer(io; file=file, compress=compress, stringview=true)
+                Arrow.write(w, (s=selected,))
+                close(w)
+                @test take!(io) == eager
+            end
+        end
+        @test col.payloads == beforepayloads
+        @test col.buffers == beforebuffers
+        # Ordinary Julia slices and filters currently materialize selected
+        # strings. They must obey the same content boundary.
+        for selected in (view(col, 3:5), col[[false, false, true, true, true]])
+            io = IOBuffer()
+            Arrow.write(io, (s=selected,); file=false, stringview=true)
+            bytes = take!(io)
+            @test isequal(Arrow.Table(bytes).s, DataStrings.materialize(col)[3:5])
+            @test findfirst(codeunits(UNUSED), bytes) === nothing
+        end
+    end
+
+    @testset "overlapping and repeated ranges retain sharing" begin
+        raw = Vector{UInt8}(codeunits(UNUSED * "abcdefghijklmnopqrstuvwxyz" * UNUSED))
+        off = ncodeunits(UNUSED)
+        payloads = [
+            DataStrings.view_payload(raw, off + i + 1, n, 0, off + i) for
+            (i, n) in [(8, 18), (0, 20), (4, 13), (0, 20)]
+        ]
+        col = StringVector{DataString}(payloads, [raw])
+        io = IOBuffer()
+        Arrow.write(io, (s=col,); file=false, stringview=true)
+        d = checkoutput(
+            take!(io),
+            [
+                "ijklmnopqrstuvwxyz",
+                "abcdefghijklmnopqrst",
+                "efghijklmnopq",
+                "abcdefghijklmnopqrst",
+            ],
+            26;
+            file=false,
+            compress=nothing,
+        )
+        views = AC.slicebytes(d.buffers[2])
+        @test reinterpret(Int32, views)[8] == reinterpret(Int32, views)[16]
+    end
+
+    @testset "low-level views clear unused entry bytes and trailing storage" begin
+        # Null entries may contain arbitrary bytes. Short view padding is
+        # tolerated by this reader. Neither may survive IPC serialization.
+        raw = Vector{UInt8}(codeunits(UNUSED))
+        entries = fill(UInt8('Z'), 48)
+        entries[1:4] = reinterpret(UInt8, Int32[2])
+        entries[5:6] = codeunits("ok")
+        entries[17:32] = codeunits("NULL_UNUSED_TEXT")
+        for utf8 in (true, false), file in (true, false), compress in (:none, :lz4, :zstd)
+            # A one-byte prefix also exercises unaligned borrowed entries.
+            borrowed = vcat(UInt8[0xaa], entries)
+            utf8 || (borrowed[6] = 0xff)
+            t = AC.ViewType(utf8)
+            f = AC.Field("s", t; nullable=true)
+            d = AC.ArrayData(
+                t,
+                2,
+                [
+                    AC._databuffer(UInt8[0xfd, 0xff]),
+                    AC.subslice(AC._databuffer(borrowed), 1, length(entries)),
+                    AC._databuffer(raw),
+                ];
+                nullcount=1,
+            )
+            sch = AC.Schema([f])
+            batch = AC.RecordBatch(sch, [d])
+            bytes =
+                file ? Arrow.writefile(sch, [batch]; compress=compress) :
+                Arrow.writestream(sch, [batch]; compress=compress)
+            decoded = file ? Arrow.readfile(bytes) : Arrow.readstream(bytes)
+            out = (file ? decoded[1] : decoded.batches[1]).columns[1]
+            @test length(out.buffers) == 2
+            @test AC.slicebytes(out.buffers[1]) == UInt8[1]
+            canonical = zeros(UInt8, 32)
+            canonical[1] = 2
+            canonical[5:6] = codeunits("ok")
+            utf8 || (canonical[5] = 0xff)
+            @test AC.slicebytes(out.buffers[2]) == canonical
+            @test isequal(
+                Arrow.Table(bytes).s,
+                utf8 ? ["ok", missing] : [UInt8[0xff, 0x6b], missing],
+            )
+        end
+        @test entries[17:32] == codeunits("NULL_UNUSED_TEXT")
+    end
+
+    @testset "range unions agree with an independent byte selection" begin
+        rng = MersenneTwister(0x719ab)
+        for trial = 1:30
+            buffers = [rand(rng, UInt8('a'):UInt8('z'), 256) for _ = 1:3]
+            used = [falses(length(b)) for b in buffers]
+            payloads = StringPayload[]
+            expected = Union{Missing,String}[]
+            for _ = 1:50
+                if rand(rng, Bool)
+                    bufidx = rand(rng, 1:3)
+                    off = rand(rng, 0:200)
+                    len = rand(rng, 13:56)
+                    push!(
+                        payloads,
+                        DataStrings.view_payload(
+                            buffers[bufidx],
+                            off + 1,
+                            len,
+                            bufidx - 1,
+                            off,
+                        ),
+                    )
+                    used[bufidx][(off + 1):(off + len)] .= true
+                    push!(expected, String(buffers[bufidx][(off + 1):(off + len)]))
+                else
+                    push!(payloads, DataStrings.PAYLOAD_MISSING)
+                    push!(expected, missing)
+                end
+            end
+            col = StringVector{Union{Missing,DataString}}(payloads, buffers)
+            io = IOBuffer()
+            Arrow.write(io, (s=col,); file=false, stringview=true)
+            bytes = take!(io)
+            @test isequal(Arrow.Table(bytes).s, expected)
+            d = Arrow.readstream(bytes).batches[1].columns[1]
+            # Boolean indexing is independent of the encoder's sorted-range
+            # union and offset-remapping algorithm.
+            @test [AC.slicebytes(b) for b in d.buffers[3:end]] == [buffers[i][used[i]] for i = 1:3 if any(used[i])]
+        end
+    end
+
+    @testset "covered prefixes and gaps preserve the byte boundary" begin
+        # Include interleaved buffers, contained/extended overlaps, a late
+        # gap, a gap filled by a later row, and a wholly unused buffer.
+        cases = [
+            [(0, 0, 20), (1, 0, 18), (0, 8, 24), (1, 10, 22), (0, 0, 13), (0, 32, 32)],
+            [(0, 0, 20), (1, 0, 18), (0, 32, 32)],
+            [(0, 0, 20), (1, 0, 18), (0, 32, 32), (0, 20, 20)],
+            [(1, 0, 18), (1, 10, 22)],
+        ]
+        for ranges in cases, utf8 in (true, false)
+            buffers = [
+                vcat(repeat(collect(codeunits("abcdefgh")), 8), codeunits(UNUSED)),
+                vcat(repeat(collect(codeunits("ijklmnop")), 8), codeunits(UNUSED)),
+            ]
+            utf8 || (buffers[1][1] = 0xff)
+            used = [falses(length(b)) for b in buffers]
+            payloads = StringPayload[]
+            expected = Any[]
+            for (bufidx, off, len) in ranges
+                raw = buffers[bufidx + 1]
+                push!(payloads, DataStrings.view_payload(raw, off + 1, len, bufidx, off))
+                used[bufidx + 1][(off + 1):(off + len)] .= true
+                value = raw[(off + 1):(off + len)]
+                push!(expected, utf8 ? String(value) : value)
+            end
+            # A null entry contains a valid-looking reference to unused
+            # bytes. It must neither extend coverage nor survive as bytes.
+            push!(
+                payloads,
+                DataStrings.view_payload(buffers[1], 65, ncodeunits(UNUSED), 0, 64),
+            )
+            push!(expected, missing)
+            push!(payloads, DataStrings.inline_payload(codeunits("ok"), 1, 2))
+            push!(expected, utf8 ? "ok" : collect(codeunits("ok")))
+            n = length(payloads)
+            entries = collect(reinterpret(UInt8, payloads))
+            entries[(16 * (n - 1) + 7):(16 * n)] .= 0x5a
+            append!(entries, codeunits("TRAILING_UNUSED_ENTRIES"))
+            # Exercise an unaligned entry buffer and a nonzero slice base
+            # for data. BufferSlice bounds, not owner allocation size, apply.
+            borrowed = vcat(UInt8[0xaa], entries)
+            data = [
+                AC.subslice(AC._databuffer(vcat(UInt8[0xaa], b)), 1, length(b)) for
+                b in buffers
+            ]
+            validity = fill(0xff, cld(n, 8) + 1)
+            validity[(n - 2) ÷ 8 + 1] &= ~(UInt8(1) << ((n - 2) % 8))
+            t = AC.ViewType(utf8)
+            f = AC.Field("s", t; nullable=true)
+            d = AC.ArrayData(
+                t,
+                n,
+                [
+                    AC._databuffer(validity),
+                    AC.subslice(AC._databuffer(borrowed), 1, length(entries)),
+                    data...,
+                ];
+                nullcount=1,
+            )
+            sch = AC.Schema([f])
+            batch = AC.RecordBatch(sch, [d])
+            original = [AC.slicebytes(b) for b in d.buffers]
+            for file in (true, false), compress in (:none, :lz4, :zstd)
+                bytes =
+                    file ? Arrow.writefile(sch, [batch]; compress=compress) :
+                    Arrow.writestream(sch, [batch]; compress=compress)
+                decoded = file ? Arrow.readfile(bytes) : Arrow.readstream(bytes)
+                out = (file ? decoded[1] : decoded.batches[1]).columns[1]
+                @test AC.validate_full(f, out) === out
+                @test isequal(Arrow.Table(bytes).s, expected)
+                @test [AC.slicebytes(b) for b in out.buffers[3:end]] == [buffers[i][used[i]] for i = 1:2 if any(used[i])]
+                outentries = AC.slicebytes(out.buffers[2])
+                @test length(outentries) == 16 * n
+                @test all(iszero, outentries[(16 * (n - 2) + 1):(16 * (n - 1))])
+                @test all(iszero, outentries[(16 * (n - 1) + 7):(16 * n)])
+                @test all(
+                    b -> findfirst(codeunits(UNUSED), AC.slicebytes(b)) === nothing,
+                    out.buffers,
+                )
+                @test isequal([AC.isvalid_at(out, i) for i = 1:n], [i != n - 1 for i = 1:n])
+            end
+            @test [AC.slicebytes(b) for b in d.buffers] == original
+        end
+    end
+
+    @testset "covered dictionary pools retain unreferenced values" begin
+        col = packedfixture()
+        f, pool = Arrow._constructcolumn(:s, col; stringview=true)
+        t = AC.DictionaryType(AC.IntType(8, true), f.type, true)
+        df = AC.Field("s", t; nullable=false)
+        indices = Int8[0, 0, 4]
+        d = AC.ArrayData(
+            t,
+            3,
+            [AC.BufferSlice(), AC._databuffer(indices)];
+            dictionary=pool,
+            nullcount=0,
+        )
+        sch = AC.Schema([df])
+        expectedpool = [
+            "first selected long string",
+            "second selected long string",
+            "first selected long string",
+            missing,
+            "ok",
+        ]
+        for file in (true, false), compress in (:none, :lz4, :zstd)
+            bytes =
+                file ? Arrow.writefile(sch, [AC.RecordBatch(sch, [d])]; compress=compress) :
+                Arrow.writestream(sch, [AC.RecordBatch(sch, [d])]; compress=compress)
+            decoded = file ? Arrow.readfile(bytes) : Arrow.readstream(bytes)
+            out = (file ? decoded[1] : decoded.batches[1]).columns[1]
+            @test Arrow.Table(bytes).s ==
+                  ["first selected long string", "first selected long string", "ok"]
+            @test decoded.schema.fields[1].type == t
+            @test AC.slicebytes(out.buffers[2]) == reinterpret(UInt8, indices)
+            @test out.dictionary.len == 5
+            @test isequal(AC.materialize(f, out.dictionary), expectedpool)
+            @test length(out.dictionary.buffers) == 3
+            @test AC.slicebytes(out.dictionary.buffers[3]) ==
+                  codeunits(expectedpool[1] * expectedpool[2])
+        end
+    end
+
+    @testset "dictionary pools preserve values and indices" begin
+        col = fixture()
+        f, pool = Arrow._constructcolumn(:s, col; stringview=true)
+        t = AC.DictionaryType(AC.IntType(8, true), f.type, true)
+        df = AC.Field("s", t; nullable=false)
+        indices = Int8[3, 0, 3]
+        d = AC.ArrayData(
+            t,
+            3,
+            [AC.BufferSlice(), AC._databuffer(indices)];
+            dictionary=pool,
+            nullcount=0,
+        )
+        sch = AC.Schema([df])
+        for file in (true, false), compress in (:none, :zstd)
+            bytes =
+                file ? Arrow.writefile(sch, [AC.RecordBatch(sch, [d])]; compress=compress) :
+                Arrow.writestream(sch, [AC.RecordBatch(sch, [d])]; compress=compress)
+            @test Arrow.Table(bytes).s ==
+                  ["another selected string", LONG, "another selected string"]
+            decoded = file ? Arrow.readfile(bytes) : Arrow.readstream(bytes)
+            out = (file ? decoded[1] : decoded.batches[1]).columns[1]
+            @test decoded.schema.fields[1].type == t
+            @test AC.slicebytes(out.buffers[2]) == reinterpret(UInt8, indices)
+            @test out.dictionary.len == pool.len
+            @test sum(b.len for b in out.dictionary.buffers[3:end]; init=0) ==
+                  ncodeunits(LONG) + 23
+            @test isequal(AC.materialize(f, out.dictionary), DataStrings.materialize(col))
+        end
+    end
+end
+
+end # module IPCViewOutputTests
diff --git a/test/ipc_write_battery.jl b/test/ipc_write_battery.jl
new file mode 100644
index 00000000..29052f3a
--- /dev/null
+++ b/test/ipc_write_battery.jl
@@ -0,0 +1,838 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ---------------------------------------------------------------------------
+# Acceptance: this writer's bytes read back by Core; 2.x-written fixtures
+# read by Core.
+# ---------------------------------------------------------------------------
+
+"""
+Hand-build a one-column batch from raw buffer bytes (the write-side mirror of
+the read fixtures): interval layouts have no 2.x writer to lean on.
+"""
+function _handbatch(t::ArrowType, n::Int, buffers::Vector{Vector{UInt8}}; nullcount::Int=0)
+    f = Field("x", t, true, nothing, Field[])
+    slices = BufferSlice[
+        isempty(bytes) ? BufferSlice() : BufferSlice(heapregion(bytes), 0, length(bytes)) for bytes in buffers
+    ]
+    d = ArrayData(t, n, slices; nullcount=nullcount)
+    sch = Schema(Field[f])
+    return sch, AC.RecordBatch(sch, ArrayData[d], n)
+end
+
+_le(xs...) = reduce(vcat, [collect(reinterpret(UInt8, [x])) for x in xs])
+
+function _materialized(stream)
+    return [
+        [materialize(f, b.columns[i]) for (i, f) in enumerate(stream.schema.fields)] for
+        b in stream.batches
+    ]
+end
+
+function _assert_stream_equal(a, b)
+    @assert length(a.batches) == length(b.batches)
+    @assert length(a.schema.fields) == length(b.schema.fields)
+    for (fa, fb) in zip(a.schema.fields, b.schema.fields)
+        @assert fa.name == fb.name
+        @assert AC.typeequal(fa.type, fb.type)
+    end
+    ma, mb = _materialized(a), _materialized(b)
+    for (ba, bb) in zip(ma, mb), (ca, cb) in zip(ba, bb)
+        @assert isequal(collect(Any, ca), collect(Any, cb))
+    end
+    return nothing
+end
+
+function ipc_write_battery()
+    # The same fixture table the read acceptance uses: 2.x writes it, Core
+    # decodes it, and from here on the WRITER is the system under test.
+    expected = MIXED_EXPECTED
+    source = readstream(_mixed_two_partitions_bytes())
+
+    # Stream round-trip: our writer -> our reader.
+    bytes = writestream(source)
+    roundtrip = readstream(bytes)
+    _assert_stream_equal(source, roundtrip)
+    println("writer -> reader stream round-trip ✓")
+
+    # The dictionary batch is emitted once: the second batch reuses the same
+    # pool snapshot, so no replacement message and no feature declaration —
+    # a declared feature is a demand on readers (nanoarrow refuses streams
+    # declaring one it does not support), so eager streams declare only what
+    # their batches actually use.
+    kinds = [f.kind for f in _frameinfo(bytes)]
+    @assert count(==(UInt8(2)), kinds) == 1
+    @assert isempty(framemessages(heapregion(copy(bytes)))[1].features)
+    println("unchanged pools write one dictionary batch (replacement-on-change) ✓")
+
+    # Compressed round-trips, both codecs, both directions.
+    for codec in (:lz4, :zstd)
+        cbytes = writestream(source; compress=codec)
+        cstream = readstream(cbytes)
+        _assert_stream_equal(source, cstream)
+        # The compression feature is declared (standards-conforming; 2.x
+        # omits it and the reader accepts both).
+        cframes = framemessages(heapregion(copy(cbytes)))
+        @assert Int64(2) in cframes[1].features
+        println("$(codec)-compressed writer stream round-trips ✓")
+    end
+
+    # Incompressible buffers fall back to the -1 stored-raw prefix.
+    rawsource = readstream(_fixture2x("incompressible-bytes") do
+        rng_bytes = Vector{UInt8}(reinterpret(UInt8, hash.(1:4096)))
+        rawio = IOBuffer()
+        Arrow.write(rawio, (x=rng_bytes,); file=false)
+        take!(rawio)
+    end)
+    rawbytes = writestream(rawsource; compress=:lz4)
+    rawstream = readstream(rawbytes)
+    _assert_stream_equal(rawsource, rawstream)
+    println("incompressible buffers store raw behind the -1 prefix ✓")
+
+    # Replacement-on-change: a stream whose pool changes identity between
+    # batches (built by the read example's replacement fixture) re-encodes to
+    # a replacement stream — feature declared, two dictionary batches, and
+    # both our reader and the frame shape agree.
+    replaced = readstream(_dictionary_replacement_stream())
+    rbytes = writestream(replaced)
+    rframes = framemessages(heapregion(copy(rbytes)))
+    @assert Int64(1) in rframes[1].features
+    rkinds = [fm.header_type for fm in rframes]
+    @assert count(==(UInt8(2)), rkinds) == 2
+    rstream = readstream(rbytes)
+    _assert_stream_equal(replaced, rstream)
+    @assert rstream.batches[1].columns[1].dictionary !==
+            rstream.batches[2].columns[1].dictionary
+    println("pool-identity change emits a feature-gated replacement batch ✓")
+
+    # Schema-only and zero-row streams.
+    emptysch = Schema(Field[Field("x", IntType(64, true), true, nothing, Field[])])
+    schemaonly = writestream(emptysch, AC.RecordBatch[])
+    schemaonlystream = readstream(schemaonly)
+    @assert isempty(schemaonlystream.batches)
+    @assert isempty(
+        framemessages(
+            heapregion(copy(writestream(emptysch, AC.RecordBatch[]; compress=:zstd))),
+        )[1].features,
+    )
+    zerorow = readstream(writestream(readstream(_fixture2x("int64-empty") do
+        z = IOBuffer()
+        Arrow.write(z, (x=Int64[],); file=false)
+        take!(z)
+    end)))
+    @assert zerorow.batches[1].nrows == 0
+    println("schema-only streams do not overdeclare compression; zero rows round-trip ✓")
+
+    # Core may omit the physical offsets buffer for a canonical empty array.
+    # IPC still carries length + 1 offsets, so the adapter materializes one
+    # zero without changing Core's allocation-free representation.
+    emptyutf8 = Utf8Type(false)
+    emptyfield = Field("empty", emptyutf8)
+    emptydata = ArrayData(emptyutf8, 0, [BufferSlice(), BufferSlice(), BufferSlice()])
+    emptybatch = AC.RecordBatch(Schema([emptyfield]), [emptydata], 0)
+    emptybytes = writestream(emptybatch.schema, [emptybatch])
+    emptyframes = framemessages(heapregion(copy(emptybytes)))
+    emptybuffers =
+        something((emptyframes[2].msg.header::Meta.RecordBatch).buffers, Meta.Buffer[])
+    @assert emptybuffers[2].length == 4
+    # ... and the reader ACCEPTS the omitted-offsets form for zero-length
+    # arrays (Core's canonical empty; nanoarrow and C++ write it), which the
+    # same message with its offsets buffer length zeroed exercises.
+    omittedempty = copy(emptybytes)
+    _mutatemessage!(omittedempty, 2) do meta, msg
+        rb = _headertable(meta, msg)
+        bufferstart, nbufs = _vvector(rb, 2, 16; required=true)
+        @assert nbufs == 3
+        _write_i64!(meta, bufferstart + 16 + 8, Int64(0))
+    end
+    omittedstream = readstream(omittedempty)
+    @assert isempty(
+        materialize(omittedstream.schema.fields[1], omittedstream.batches[1].columns[1]),
+    )
+    println("empty IPC offset arrays: written with one terminal zero, read with none ✓")
+
+    # Schema and field metadata round-trip through the writer.
+    msource = readstream(
+        _fixture2x("schema-field-metadata") do
+            mio = IOBuffer()
+            Arrow.write(
+                mio,
+                (x=Int64[1],);
+                file=false,
+                metadata=Dict("owner" => "jacob"),
+                colmetadata=Dict(:x => Dict("unit" => "count")),
+            )
+            take!(mio)
+        end,
+    )
+    mstream = readstream(writestream(msource))
+    @assert Dict(mstream.schema.metadata) == Dict("owner" => "jacob")
+    @assert Dict(mstream.schema.fields[1].metadata) == Dict("unit" => "count")
+    println("schema and field metadata round-trip through the writer ✓")
+
+    # Writer refusals: offset views, mismatched schemas, unknown codecs.
+    off = ArrayData(IntType(64, true), 1, source.batches[1].columns[1].buffers; offset=1)
+    offbatch = AC.RecordBatch(Schema(Field[source.schema.fields[1]]), ArrayData[off], 1)
+    @assert _rejects(() -> writestream(offbatch.schema, [offbatch]))
+    @assert _rejects(() -> writestream(Schema(Field[]), [source.batches[1]]))
+    caught = try
+        writestream(source; compress=:snappy)
+        false
+    catch e
+        e isa ArgumentError
+    end
+    @assert caught
+    @assert _rejects(() -> _requirelittleendian(UInt32(0x01020304)))
+    println("offset views, schema mismatches, and unknown codecs are refused ✓")
+
+    # Schema-only output still validates the full Schema/Field envelope.
+    invalidname = String(UInt8[0xff])
+    badnameschema = Schema(Field[Field(invalidname, IntType(64, true))])
+    binaryschema = Schema(emptysch.fields; metadata=[invalidname => "value"])
+    bigschema = Schema(emptysch.fields; endianness=AC.BigEndian)
+    badreeschema = Schema(
+        Field[Field(
+            "ree",
+            RunEndEncodedType();
+            children=[
+                Field("wrong", IntType(32, true); nullable=false),
+                Field("also-wrong", IntType(64, true)),
+            ],
+        )],
+    )
+    @assert _rejects(() -> writestream(badnameschema, AC.RecordBatch[]))
+    @assert _rejects(() -> writefile(badnameschema, AC.RecordBatch[]))
+    binaryfile = readfile(writefile(binaryschema, AC.RecordBatch[]))
+    @assert collect(binaryfile.schema.metadata) == [invalidname => "value"]
+    @assert _rejects(() -> writestream(bigschema, AC.RecordBatch[]))
+    @assert _rejects(() -> writestream(badreeschema, AC.RecordBatch[]))
+    @assert _rejects(() -> writefile(badreeschema, AC.RecordBatch[]))
+    println(
+        "schema-only writers preserve binary metadata and validate names, endianness, and REE children ✓",
+    )
+
+    # A Field object is one writer-side dictionary-id key. Reusing that exact
+    # object at two positions must not collapse two distinct pools onto one id.
+    aliasfield, aliasdata1 = AC.fromjulia_dict("d", ["a", "b"], [0, 1])
+    _, aliasdata2 = AC.fromjulia_dict("d", ["x", "y"], [0, 1])
+    aliasschema = Schema(Field[aliasfield, aliasfield])
+    aliasbatch = AC.RecordBatch(aliasschema, ArrayData[aliasdata1, aliasdata2], 2)
+    @assert _rejects(() -> writestream(aliasschema, [aliasbatch]))
+    sharedvaluechild = Field("value", IntType(64, true))
+    aliaseddict = Field(
+        "dict",
+        DictionaryType(IntType(32, true), StructType(), false);
+        children=[sharedvaluechild],
+    )
+    aliasedlist = Field("list", ListType(false); children=[sharedvaluechild])
+    @assert _rejects(() -> assigndictids([aliaseddict, aliasedlist]))
+
+    # One pool shared through two dictionary fields must satisfy both value
+    # schemas. The batch's own schema permits the null; the requested writer
+    # schema deliberately makes the second value child non-nullable.
+    poolfield, pooldata = AC.fromjulia_struct("pool", (a=Union{Missing,Int64}[missing],))
+    dtype = DictionaryType(IntType(32, true), poolfield.type, false)
+    _, indexdata = fromjulia("index", Int32[0])
+    dictdata = ArrayData(dtype, 1, indexdata.buffers; dictionary=pooldata, nullcount=0)
+    nullablechild = poolfield.children[1]
+    strictchild = Field(nullablechild.name, nullablechild.type; nullable=false)
+    batchfields = Field[
+        Field("left", dtype; children=[nullablechild]),
+        Field("right", dtype; children=[nullablechild]),
+    ]
+    strictfields = Field[batchfields[1], Field("right", dtype; children=[strictchild])]
+    sharedbatch = AC.RecordBatch(Schema(batchfields), ArrayData[dictdata, dictdata], 1)
+    # Field.nullable is advisory at the semantic tier (the gold corpus itself
+    # violates it), so the skewed write is accepted; the strict declaration
+    # is enforced by the opt-in validate_full tier.
+    @assert readstream(writestream(Schema(strictfields), [sharedbatch])) isa IPCStream
+    @assert _rejects(() -> AC.validate_full(strictfields[2], dictdata))
+    @assert AC.validate_full(batchfields[2], dictdata) === dictdata
+    println("dictionary field aliases are refused; contract skew is validate_full's ✓")
+
+    # One id names ONE pool within a record batch: a caller id table mapping
+    # two fields to one id with DIFFERENT pools would decode both fields
+    # through whichever pool was emitted last.
+    skewf1, skewd1 = AC.fromjulia_dict("s1", ["a"], [0])
+    skewf2, skewd2 = AC.fromjulia_dict("s2", ["b"], [0])
+    skewids = IdDict{Field,Int64}(skewf1 => Int64(7), skewf2 => Int64(7))
+    skewsch = Schema(Field[skewf1, skewf2])
+    skewbatch = AC.RecordBatch(skewsch, ArrayData[skewd1, skewd2], 1)
+    @assert _rejects(() -> writestream(skewsch, [skewbatch]; dictids=skewids))
+    okd2 =
+        ArrayData(skewf2.type, 1, skewd2.buffers; dictionary=skewd1.dictionary, nullcount=0)
+    okbatch = AC.RecordBatch(skewsch, ArrayData[skewd1, okd2], 1)
+    okbytes = writestream(skewsch, [okbatch]; dictids=skewids)
+    okstream = readstream(okbytes)
+    @assert okstream.fielddictids[okstream.schema.fields[1]] ==
+            okstream.fielddictids[okstream.schema.fields[2]]
+    # The shared pool is one dictionary message, so the file format, which
+    # forbids replacement, carries a shared id too.
+    @assert count(f -> f.kind == UInt8(2), _frameinfo(okbytes)) == 1
+    @assert length(readfile(writefile(skewsch, [okbatch]; dictids=skewids))) == 1
+    # ... and a repeated id must carry ONE nested dictionary-id topology, or
+    # the second field would decode through pools its schema never declared.
+    innerty = DictionaryType(IntType(32, true), Utf8Type(false), false)
+    inner1 = Field("inner", innerty)
+    inner2 = Field("inner", innerty)
+    outerty = DictionaryType(IntType(32, true), StructType(), false)
+    topo1 = Field("o1", outerty; children=[inner1])
+    topo2 = Field("o2", outerty; children=[inner2])
+    topoids = IdDict{Field,Int64}(
+        topo1 => Int64(10),
+        topo2 => Int64(10),
+        inner1 => Int64(20),
+        inner2 => Int64(21),
+    )
+    @assert _rejects(() -> validatedictionaryids(Field[topo1, topo2], topoids))
+    topoids[inner2] = Int64(20)
+    @assert validatedictionaryids(Field[topo1, topo2], topoids) isa Dict
+    # ... and fresh ids fill unoccupied values instead of wrapping past a
+    # given id at the top of the signed-long domain.
+    wrapfs = Field[Field("w$i", innerty) for i = 1:3]
+    wrapids = assigndictids(
+        wrapfs,
+        IdDict{Field,Int64}(wrapfs[1] => typemin(Int64), wrapfs[2] => typemax(Int64)),
+    )
+    @assert length(Set(values(wrapids))) == 3
+    println("shared dictionary ids: one pool per batch, one nested topology, no id wrap ✓")
+
+    # Unions, both modes: 2.x writes them, Core reads and re-encodes them.
+    # The mapped set matches Core's accessor coverage; the self-round-trips
+    # below cover the view layouts and REE that Arrow.jl 2.x does not emit.
+    sparsebytes = UInt8[]
+    for (modename, dense) in (("dense", true), ("sparse", false))
+        usource = readstream(
+            _fixture2x("union-$(modename)") do
+                uio = IOBuffer()
+                Arrow.write(
+                    uio,
+                    (u=Union{Int64,String}[1, "x", 2, "y"],);
+                    file=false,
+                    denseunions=dense,
+                )
+                take!(uio)
+            end,
+        )
+        ut = usource.schema.fields[1].type
+        @assert ut isa UnionType
+        @assert (ut.mode == AC.DenseMode) == dense
+        ubytes = writestream(usource)
+        dense || (sparsebytes = copy(ubytes))
+        _assert_stream_equal(usource, readstream(ubytes))
+        println("$(modename) unions round-trip ✓")
+    end
+
+    # IPC sparse-union children have exactly the parent length. Core allows a
+    # longer backing child for sliced C Data, so this rule stays at the IPC
+    # boundary. Omitted union ids also fail cleanly before Int8 conversion.
+    onechild, longchild = fromjulia("i", Int64[10, 20])
+    sparse = UnionType(AC.SparseMode, Int8[0])
+    sparsefield = Field("u", sparse; children=[onechild])
+    sparsedata = ArrayData(sparse, 1, [AC._databuffer(Int8[0])]; children=[longchild])
+    sparsebatch = AC.RecordBatch(Schema([sparsefield]), [sparsedata], 1)
+    @assert _rejects(() -> writestream(sparsebatch.schema, [sparsebatch]))
+    ub = FB.Builder(64)
+    Meta.unionStart(ub)
+    Meta.unionAddMode(ub, Meta.UnionMode.Sparse)
+    FB.finish!(ub, Meta.unionEnd(ub))
+    umeta = FB.getrootas(Meta.Union, collect(FB.finishedbytes(ub)), 0)
+    too_many_children = Field[Field("c$i", NullType()) for i = 1:129]
+    @assert _rejects(() -> _coremetatype(umeta, too_many_children))
+    _mutatemessage!(sparsebytes, 2) do meta, msg
+        rb = _headertable(meta, msg)
+        _write_i64!(meta, _vfield(rb, 0, 8; required=true), Int64(3))
+        nodestart, nnodes = _vvector(rb, 1, 16; required=true)
+        @assert nnodes >= 2
+        _write_i64!(meta, nodestart, Int64(3))
+    end
+    @assert _rejects(() -> readstream(sparsebytes))
+    customleft, customleftdata = fromjulia("left", Int64[10, 20])
+    customright, customrightdata = fromjulia("right", ["x", "y"])
+    customtype = UnionType(AC.SparseMode, Int8[7, 3])
+    customfield = Field("u", customtype; children=[customleft, customright])
+    customdata = ArrayData(
+        customtype,
+        2,
+        [AC._databuffer(Int8[7, 3])];
+        children=[customleftdata, customrightdata],
+    )
+    custombatch = AC.RecordBatch(Schema([customfield]), [customdata], 2)
+    customstream = readstream(writestream(custombatch.schema, [custombatch]))
+    @assert materialize(
+        customstream.schema.fields[1],
+        customstream.batches[1].columns[1],
+    ) == Any[10, "y"]
+    println("IPC sparse-union length and union-id domains are enforced ✓")
+
+    # Intervals, all three units, hand-built (2.x has no interval writer).
+    # MONTH_DAY_NANO exceeds 2.x entirely: its vendored enum predates the
+    # unit, so 2.x must fail while this adapter round-trips it.
+    ym = _handbatch(
+        IntervalType(AC.YEAR_MONTH),
+        3,
+        [UInt8[0x05], _le(Int32(12), Int32(0), Int32(7))];
+        nullcount=1,
+    )
+    dt = _handbatch(
+        IntervalType(AC.DAY_TIME),
+        3,
+        [UInt8[], _le(Int32(1), Int32(2), Int32(3), Int32(4), Int32(5), Int32(6))],
+    )
+    mdn = _handbatch(
+        IntervalType(AC.MONTH_DAY_NANO),
+        2,
+        [UInt8[], _le(Int32(1), Int32(2), Int64(3), Int32(4), Int32(5), Int64(6))],
+    )
+    intervalwant = (
+        (ym, Any[12, missing, 7]),
+        (dt, Any[(days=1, millis=2), (days=3, millis=4), (days=5, millis=6)]),
+        (mdn, Any[(months=1, days=2, nanos=3), (months=4, days=5, nanos=6)]),
+    )
+    for ((sch, batch), want) in intervalwant
+        ibytes = writestream(sch, [batch])
+        istream = readstream(ibytes)
+        @assert istream.schema.fields[1].type == sch.fields[1].type
+        got = materialize(istream.schema.fields[1], istream.batches[1].columns[1])
+        @assert isequal(collect(Any, got), want)
+    end
+    println("intervals round-trip, including MONTH_DAY_NANO ✓")
+
+    # ---- File format ----------------------------------------------------
+
+    filebytes = writefile(source)
+    file = readfile(copy(filebytes))
+    @assert length(file) == 2
+    # Random access, last batch first — nothing but the footer index drives it.
+    for i in (2, 1)
+        batch = file[i]
+        for (j, f) in enumerate(file.schema.fields)
+            want = materialize(f, source.batches[i].columns[j])
+            @assert isequal(
+                collect(Any, materialize(f, batch.columns[j])),
+                collect(Any, want),
+            )
+        end
+    end
+    println("writer -> readfile random-access round-trip ✓")
+
+    # We read a 2.x-written file (the reverse direction — other
+    # implementations reading OUR bytes — is the oracle suite's job).
+    theirs = readfile(
+        _fixture2x("mixed-two-partitions-file") do
+            fio = IOBuffer()
+            fwritetable = merge(expected, (dict=Arrow.DictEncode(expected.dict),))
+            Arrow.write(fio, Tables.partitioner([fwritetable, fwritetable]); file=true)
+            take!(fio)
+        end,
+    )
+    @assert length(theirs) == 2
+    for i = 1:2, (j, f) in enumerate(theirs.schema.fields)
+        @assert isequal(
+            collect(Any, materialize(f, theirs[i].columns[j])),
+            collect(Any, materialize(f, source.batches[i].columns[j])),
+        )
+    end
+    println("2.x-written files read back ✓")
+
+    # Compressed file round-trip.
+    zfilebytes = writefile(source; compress=:zstd)
+    zfile = readfile(zfilebytes)
+    for (j, f) in enumerate(zfile.schema.fields)
+        @assert isequal(
+            collect(Any, materialize(f, zfile[1].columns[j])),
+            collect(Any, materialize(f, source.batches[1].columns[j])),
+        )
+    end
+    zfooterlen = Int64(reinterpret(Int32, zfilebytes[(end - 9):(end - 6)])[1])
+    zfooterstart = Int64(length(zfilebytes)) - 10 - zfooterlen
+    zfooterbytes = copy(zfilebytes[(zfooterstart + 1):(zfooterstart + zfooterlen)])
+    _, zfooterfeatures, _, _, _ = verify_footer(zfooterbytes, Limits())
+    zstreamsection = copy(zfilebytes[9:zfooterstart])
+    zschemafeatures = framemessages(heapregion(zstreamsection))[1].features
+    @assert zschemafeatures == Int64[2] == zfooterfeatures
+    emptyfilebytes = writefile(emptysch, AC.RecordBatch[]; compress=:zstd)
+    emptyfooterlen = Int64(reinterpret(Int32, emptyfilebytes[(end - 9):(end - 6)])[1])
+    emptyfooterstart = Int64(length(emptyfilebytes)) - 10 - emptyfooterlen
+    emptyfooterbytes =
+        copy(emptyfilebytes[(emptyfooterstart + 1):(emptyfooterstart + emptyfooterlen)])
+    _, emptyfeatures, _, _, _ = verify_footer(emptyfooterbytes, Limits())
+    @assert isempty(emptyfeatures)
+    println("compressed file schemas declare feature 2 exactly when needed ✓")
+
+    # Mmap path: the file region's root is the Mmap array; decode after GC.
+    mmapdir = mktempdir()
+    mmappath = joinpath(mmapdir, "roundtrip.arrow")
+    write(mmappath, filebytes)
+    mfile = readfile(mmapregion(mmappath))
+    GC.gc(true)
+    @assert length(mfile) == 2
+    @assert isequal(
+        collect(Any, materialize(mfile.schema.fields[1], mfile[2].columns[1])),
+        collect(Any, materialize(source.schema.fields[1], source.batches[2].columns[1])),
+    )
+    println("mmap-backed files decode through the reachability-rooted region ✓")
+
+    # File-format refusals: replacement pools, truncated/corrupt footers,
+    # magic damage, block escapes.
+    @assert _rejects(() -> writefile(replaced))
+    nomagic = copy(filebytes)
+    nomagic[end] ⊻= 0xff
+    @assert _rejects(() -> readfile(nomagic))
+    nohead = copy(filebytes)
+    nohead[1] ⊻= 0xff
+    @assert _rejects(() -> readfile(nohead))
+    shortfile = filebytes[1:(end - 7)]
+    @assert _rejects(() -> readfile(shortfile))
+    lyinglen = copy(filebytes)
+    lenpos = length(lyinglen) - 9
+    lyinglen[lenpos:(lenpos + 3)] .= reinterpret(UInt8, Int32[Int32(2^30)])
+    @assert _rejects(() -> readfile(lyinglen))
+
+    # The Footer is authoritative, as in Arrow C++: a leading Schema message
+    # that disagrees with Footer.schema is never read.
+    differentschema = copy(filebytes)
+    embeddedlen = Int64(reinterpret(Int32, differentschema[13:16])[1])
+    embedded = copy(differentschema[17:(16 + embeddedlen)])
+    embeddedmsg = _vtable(embedded, Int64(_vu32(embedded, 0)))
+    embeddedschema = _vtable(embedded, _vref(embeddedmsg, 2; required=true))
+    fieldvec, nembeddedfields = _vvector(embeddedschema, 1, 4; required=true)
+    @assert nembeddedfields > 0
+    embeddedfield =
+        _vtable(embedded, AC.checked_add(fieldvec, Int64(_vu32(embedded, fieldvec))))
+    namepos = _vref(embeddedfield, 0; required=true)
+    differentschema[16 + namepos + 4 + 1] = UInt8('z')
+    @assert readfile(differentschema).schema.fields[1].name ==
+            readfile(filebytes).schema.fields[1].name
+
+    # Files cannot opt into stream dictionary replacement, even when their
+    # block index happens to contain no duplicate dictionary id.
+    replacementfeature = copy(zfilebytes)
+    embeddedlen = Int64(reinterpret(Int32, replacementfeature[13:16])[1])
+    embedded = copy(replacementfeature[17:(16 + embeddedlen)])
+    embeddedmsg = _vtable(embedded, Int64(_vu32(embedded, 0)))
+    embeddedschema = _vtable(embedded, _vref(embeddedmsg, 2; required=true))
+    embeddedfeatures, nembeddedfeatures = _vvector(embeddedschema, 3, 8; required=true)
+    @assert nembeddedfeatures == 1
+    _write_i64!(replacementfeature, Int64(16) + embeddedfeatures, Int64(1))
+    replacementfooterlen =
+        Int64(reinterpret(Int32, replacementfeature[(end - 9):(end - 6)])[1])
+    replacementfooterstart = Int64(length(replacementfeature)) - 10 - replacementfooterlen
+    replacementfooter = copy(
+        replacementfeature[(replacementfooterstart + 1):(replacementfooterstart + replacementfooterlen)],
+    )
+    replacementtable = _vtable(replacementfooter, Int64(_vu32(replacementfooter, 0)))
+    replacementschema =
+        _vtable(replacementfooter, _vref(replacementtable, 1; required=true))
+    replacementfeatures, nreplacementfeatures =
+        _vvector(replacementschema, 3, 8; required=true)
+    @assert nreplacementfeatures == 1
+    _write_i64!(replacementfeature, replacementfooterstart + replacementfeatures, Int64(1))
+    @assert _rejects(() -> readfile(replacementfeature))
+    @assert _rejects(
+        () -> _validateblockindex(
+            NTuple{3,Int64}[(Int64(304), Int64(16), Int64(0))],
+            NTuple{3,Int64}[],
+            Int64(312),
+        ),
+    )
+    @assert _rejects(
+        () -> _validateblockindex(
+            NTuple{3,Int64}[(Int64(8), Int64(16), Int64(8))],
+            NTuple{3,Int64}[(Int64(24), Int64(16), Int64(0))],
+            Int64(64),
+        ),
+    )
+
+    # A zero-body Block ends exactly after its metadata. The Message omits its
+    # default-zero bodyLength slot, and the frame preflight must accept it.
+    zerobodyschema = Schema(Field[])
+    zerobodybatch = AC.RecordBatch(zerobodyschema, ArrayData[], 3)
+    zerobodyfile = readfile(writefile(zerobodyschema, [zerobodybatch]))
+    @assert only(zerobodyfile.recordblocks)[3] == 0
+    @assert zerobodyfile[1].nrows == 3
+
+    # The footer copy and verified graph share one allocation budget. File
+    # message count and lazy bodies use the same limits as stream framing.
+    simplefield, simpledata = fromjulia("x", Int64[1])
+    simplebatch = AC.RecordBatch(Schema([simplefield]), [simpledata], 1)
+    simplebytes = writefile(simplebatch.schema, [simplebatch])
+    simplefooterlen = Int64(reinterpret(Int32, simplebytes[(end - 9):(end - 6)])[1])
+    simplefooterstart = Int64(length(simplebytes)) - 10 - simplefooterlen
+    simplefooter =
+        copy(simplebytes[(simplefooterstart + 1):(simplefooterstart + simplefooterlen)])
+
+    # Keep the message and Block internally consistent while extending the
+    # indexed body into the footer. Open must reject the cross-boundary span.
+    crossing = copy(simplebytes)
+    crossingtable = _vtable(simplefooter, Int64(_vu32(simplefooter, 0)))
+    crossingstart, crossingcount = _vvector(crossingtable, 3, 24)
+    @assert crossingcount == 1
+    crossingoffset = _vi64(simplefooter, crossingstart)
+    crossingmeta = Int64(_vi32(simplefooter, crossingstart + 8))
+    crossingbody = _vi64(simplefooter, crossingstart + 16)
+    crossingmessage = copy(crossing[(crossingoffset + 9):(crossingoffset + crossingmeta)])
+    crossingroot = _vtable(crossingmessage, Int64(_vu32(crossingmessage, 0)))
+    bodypos = _vfield(crossingroot, 3, 8; required=true)
+    newbodylen = crossingbody + 16
+    _write_i64!(crossing, crossingoffset + 8 + bodypos, newbodylen)
+    _write_i64!(crossing, simplefooterstart + crossingstart + 16, newbodylen)
+    @assert _rejects(() -> readfile(crossing))
+
+    # A no-EOS file may end its last data buffer with the eight-byte EOS byte
+    # pattern. Indexed block extents, not that ambiguous pattern alone, decide
+    # whether those bytes are data. Arrow.jl 2.x writes and accepts no-EOS
+    # files, so retain that interoperable form.
+    collisionfield, collisiondata = fromjulia("collision", Int64[Int64(0x00000000ffffffff)])
+    collisionbatch = AC.RecordBatch(Schema([collisionfield]), [collisiondata], 1)
+    collision = writefile(collisionbatch.schema, [collisionbatch])
+    collisionfooterlen = Int64(reinterpret(Int32, collision[(end - 9):(end - 6)])[1])
+    collisionfooterstart = Int64(length(collision)) - 10 - collisionfooterlen
+    noeos = copy(collision)
+    deleteat!(noeos, Int(collisionfooterstart - 7):Int(collisionfooterstart))
+    noeosfile = readfile(noeos)
+    @assert materialize(noeosfile.schema.fields[1], noeosfile[1].columns[1]) ==
+            Int64[Int64(0x00000000ffffffff)]
+
+    # Footer extents are not verified until they agree with the on-wire
+    # Message envelope. Merely shortening the final Block must not make its
+    # marker-shaped data look like an optional EOS marker at file-open time.
+    forgedcollision = copy(noeos)
+    forgedfooterlen = Int64(reinterpret(Int32, forgedcollision[(end - 9):(end - 6)])[1])
+    forgedfooterstart = Int64(length(forgedcollision)) - 10 - forgedfooterlen
+    forgedfooter =
+        copy(forgedcollision[(forgedfooterstart + 1):(forgedfooterstart + forgedfooterlen)])
+    forgedtable = _vtable(forgedfooter, Int64(_vu32(forgedfooter, 0)))
+    forgedblocks, nforgedblocks = _vvector(forgedtable, 3, 24; required=true)
+    @assert nforgedblocks == 1
+    forgedbodylen = _vi64(forgedfooter, forgedblocks + 16)
+    @assert forgedbodylen >= 8
+    _write_i64!(forgedcollision, forgedfooterstart + forgedblocks + 16, forgedbodylen - 8)
+    @assert _rejects(() -> readfile(forgedcollision)[1])
+
+    # Coordinating the same lie in Message.bodyLength is still insufficient:
+    # the RecordBatch buffer table proves that the excluded bytes are data.
+    coordinated = copy(forgedcollision)
+    forgedoffset = _vi64(forgedfooter, forgedblocks)
+    forgedmetalen = Int64(_vi32(forgedfooter, forgedblocks + 8))
+    forgedmessage = copy(coordinated[(forgedoffset + 9):(forgedoffset + forgedmetalen)])
+    forgedmessagetable = _vtable(forgedmessage, Int64(_vu32(forgedmessage, 0)))
+    forgedmessagebody = _vfield(forgedmessagetable, 3, 8; required=true)
+    _write_i64!(coordinated, forgedoffset + 8 + forgedmessagebody, forgedbodylen - 8)
+    @assert _rejects(() -> readfile(coordinated)[1])
+
+    _, _, _, _, footreserve = verify_footer(simplefooter, Limits())
+    tightbudget = max(simplefooterlen, footreserve)
+    @assert _rejects(
+        () -> readfile(
+            copy(simplebytes);
+            limits=Limits(max_total_allocated_bytes=tightbudget),
+        ),
+    )
+    @assert _rejects(() -> readfile(copy(simplebytes); limits=Limits(max_messages=1)))
+    bodylimited = readfile(copy(simplebytes); limits=Limits(max_body_bytes=0))
+    @assert _rejects(() -> bodylimited[1])
+    # A block offset pointing outside the file must fail cleanly.
+    file2 = readfile(copy(filebytes))
+    badblocks = [(Int64(2)^40, Int64(16), Int64(0))]
+    badfile = ArrowFile(
+        file2.region,
+        file2.schema,
+        file2.fields,
+        file2.fielddictids,
+        file2.dictionaries,
+        file2.validated,
+        badblocks,
+        file2.dataend,
+        file2.limits,
+        file2.schemaversion,
+    )
+    @assert _rejects(() -> badfile[1])
+    println("file magic, footer, and block extents are verified ✓")
+
+    # ---- Format 1.3/1.4 layouts: views and run-end encoding ------------
+    # No 2.x-written fixture exists for these layouts, so the acceptance is
+    # self round-trip on both formats plus wire-shape checks:
+    # the variadicBufferCounts vector, the late type tags, and the buffer
+    # accounting that skewed nothing after them.
+    payload1 = collect(codeunits("first-out-of-line-payload"))
+    payload2 = collect(codeunits("second-buffer-payload-here"))
+    views = vcat(
+        _viewentry(3, collect(codeunits("abc"))),
+        _viewlong(25, payload1[1:4], 0, 0),
+        _viewlong(26, payload2[1:4], 1, 0),
+        _viewentry(0, UInt8[]),
+    )
+    vt = ViewType(true)
+    vf = Field("v", vt; nullable=true)
+    vd = ArrayData(
+        vt,
+        4,
+        [
+            AC._databuffer(UInt8[0x0b]),
+            AC._databuffer(views),
+            AC._databuffer(payload1),
+            AC._databuffer(payload2),
+        ];
+        nullcount=1,
+    )
+    lvt = ListViewType(false)
+    lvcf, lvcd = fromjulia("item", Int64[10, 20, 30])
+    lvf = Field("lv", lvt; children=[lvcf])
+    lvd = ArrayData(
+        lvt,
+        3,
+        [BufferSlice(), AC._databuffer(Int32[2, 0, 0]), AC._databuffer(Int32[1, 2, 3])];
+        children=[lvcd],
+        nullcount=0,
+    )
+    rt = RunEndEncodedType()
+    ref, red = fromjulia("run_ends", Int32[2, 3, 4])
+    rvf, rvd = fromjulia("values", Union{Missing,String}["x", missing, "z"])
+    rf = Field("ree", rt; children=[ref, rvf])
+    rd = ArrayData(rt, 4, BufferSlice[]; children=[red, rvd], nullcount=0)
+    nvv = ArrayData(
+        vt,
+        2,
+        [
+            BufferSlice(),
+            AC._databuffer(
+                vcat(
+                    _viewentry(1, collect(codeunits("p"))),
+                    _viewentry(1, collect(codeunits("q"))),
+                ),
+            ),
+        ];
+        nullcount=0,
+    )
+    nvf = Field("values", vt; nullable=false)
+    nirf, nird = fromjulia("run_ends", Int32[1, 2])
+    nif = Field("values", rt; children=[nirf, nvf])
+    nid = ArrayData(rt, 2, BufferSlice[]; children=[nird, nvv], nullcount=0)
+    norf, nord = fromjulia("run_ends", Int32[2, 4])
+    nf = Field("nested", rt; children=[norf, nif])
+    nd = ArrayData(rt, 4, BufferSlice[]; children=[nord, nid], nullcount=0)
+    # 64-bit-offset utf8/binary: the only IPC path exercising the LargeUtf8/
+    # LargeBinary metadata tables — the only coverage of those generated
+    # builders.
+    luf = Field("lu", Utf8Type(true); nullable=false)
+    lud = ArrayData(
+        Utf8Type(true),
+        4,
+        [
+            BufferSlice(),
+            AC._databuffer(Int64[0, 1, 1, 3, 6]),
+            AC._databuffer(collect(codeunits("abcdef"))),
+        ];
+        nullcount=0,
+    )
+    # a plain column AFTER the exotic ones proves no buffer skew
+    tf, td = fromjulia("tail", Int64[1, 2, 3, 4])
+    exsch = Schema(Field[vf, lvf, rf, nf, luf, tf])
+    exlv = ArrayData(
+        lvt,
+        4,
+        [
+            BufferSlice(),
+            AC._databuffer(Int32[2, 0, 0, 1]),
+            AC._databuffer(Int32[1, 2, 3, 0]),
+        ];
+        children=[lvcd],
+        nullcount=0,
+    )
+    exbatch = AC.RecordBatch(exsch, ArrayData[vd, exlv, rd, nd, lud, td], 4)
+    exwant = Dict(
+        "v" => Any["abc", "first-out-of-line-payload", missing, ""],
+        "lv" => Any[[30], [10, 20], [10, 20, 30], Int64[]],
+        "ree" => Any["x", "x", missing, "z"],
+        "nested" => Any["p", "p", "q", "q"],
+        "lu" => Any["a", "", "bc", "def"],
+        "tail" => Any[1, 2, 3, 4],
+    )
+    for compress in (:none, :zstd)
+        exbytes = writestream(exsch, [exbatch]; compress=compress)
+        exstream = readstream(exbytes)
+        for (i, f) in enumerate(exstream.schema.fields)
+            @assert AC.typeequal(f.type, exsch.fields[i].type)
+            got = collect(Any, materialize(f, exstream.batches[1].columns[i]))
+            @assert isequal(got, exwant[f.name]) "$(f.name) ($compress): $got"
+        end
+        exfile = readfile(writefile(exsch, [exbatch]; compress=compress))
+        for (i, f) in enumerate(exfile.schema.fields)
+            got = collect(Any, materialize(f, exfile[1].columns[i]))
+            @assert isequal(got, exwant[f.name]) "file $(f.name) ($compress): $got"
+        end
+    end
+    println("views, list-views, and nested REE round-trip on both formats (plain + zstd) ✓")
+
+    # Wire shape: variadic counts follow field preorder (1 buffer for the
+    # top-level view: the second input buffer is referenced only by a null;
+    # then 0 for the inline view below nested REE). The type tags are the
+    # 1.3/1.4 ids.
+    exframes = framemessages(heapregion(copy(writestream(exsch, [exbatch]))))
+    exrb = exframes[2].msg.header::Meta.RecordBatch
+    @assert variadiccounts(exrb) == Int64[1, 0]
+    exmeta = exframes[1].msg.header::Meta.Schema
+    @assert [typeof(f.type) for f in exmeta.fields] == [
+        Meta.Utf8View,
+        Meta.ListView,
+        Meta.RunEndEncoded,
+        Meta.RunEndEncoded,
+        Meta.LargeUtf8,
+        Meta.Int,
+    ]
+    println("variadic counts and 1.3/1.4 type tags are on the wire ✓")
+
+    # A view column with ZERO variadic buffers (all inline) is legal and
+    # round-trips with an explicit 0 count.
+    inl = ArrayData(
+        vt,
+        2,
+        [
+            BufferSlice(),
+            AC._databuffer(
+                vcat(
+                    _viewentry(2, collect(codeunits("hi"))),
+                    _viewentry(1, collect(codeunits("!"))),
+                ),
+            ),
+        ];
+        nullcount=0,
+    )
+    inlsch = Schema(Field[Field("v", vt)])
+    inlstream = readstream(writestream(inlsch, [AC.RecordBatch(inlsch, ArrayData[inl], 2)]))
+    @assert materialize(inlstream.schema.fields[1], inlstream.batches[1].columns[1]) ==
+            ["hi", "!"]
+    println("all-inline views carry an explicit zero variadic count ✓")
+
+    # Corrupt variadic counts fail closed: overstated (consumes into the
+    # tail column's buffers → skew caught) and understated (leftover buffers).
+    exraw = writestream(exsch, [exbatch])
+    for lie in (Int64(2), Int64(0))
+        lied = copy(exraw)
+        _mutatemessage!(lied, 2) do meta, msg
+            rb = _headertable(meta, msg)
+            start, n = _vvector(rb, 4, 8; required=true)
+            n == 2 || error("fixture declares $n variadic counts")
+            _write_i64!(meta, start, lie)
+        end
+        @assert _rejects(() -> readstream(lied)) "variadic lie $lie accepted"
+    end
+    println("misdeclared variadic counts are rejected as skew ✓")
+
+    println()
+    println("IPC write, file-format, interop, and adversarial checks passed.")
+end
diff --git a/test/java_compress_len_neg_one.arrow b/test/java_compress_len_neg_one.arrow
deleted file mode 100644
index 1d0f864d..00000000
Binary files a/test/java_compress_len_neg_one.arrow and /dev/null differ
diff --git a/test/java_compressed_zero_length.arrow b/test/java_compressed_zero_length.arrow
deleted file mode 100644
index 36345e1e..00000000
Binary files a/test/java_compressed_zero_length.arrow and /dev/null differ
diff --git a/test/limits_tests.jl b/test/limits_tests.jl
new file mode 100644
index 00000000..bdeb0bd1
--- /dev/null
+++ b/test/limits_tests.jl
@@ -0,0 +1,202 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Reader allocation budgets: per-batch streams, compressed input, contention.
+
+using Test, Arrow, Tables
+const ZstdCompressor = Arrow.CZSTD.ZstdCompressor
+
+# Decode one compressed buffer whose column reads `needed` bytes (-1: unknown).
+function decodebuffer(payload, declared, needed; codec=Arrow.CODEC_ZSTD, budget)
+    bytes = vcat(collect(reinterpret(UInt8, [Int64(declared)])), payload)
+    wire = Arrow.BufferSlice(Arrow.heapregion(bytes), 0, length(bytes))
+    state = Arrow.DecodeState(budget)
+    cursor = Arrow.DecodeCursor(
+        nothing,
+        nothing,
+        Arrow.BufferSlice(),
+        Arrow.Limits();
+        codec=codec,
+        state=state,
+    )
+    try
+        return Arrow.AC.slicebytes(Arrow._decompressbuffer!(cursor, wire, Int64(needed)))
+    finally
+        close(state)
+    end
+end
+
+smallbudget() = Arrow.AllocationBudget(64 * 1024; ratio=64, cap=1 << 30)
+
+@testset "reader allocation limits" begin
+    @testset "a size past a Limits field names the field to raise" begin
+        bytes = take!(Arrow.write(IOBuffer(), (a=collect(1:10),); file=true))
+        for (limits, text) in (
+            (
+                Arrow.Limits(max_array_length=5),
+                "record batch length 10 exceeds Arrow.Limits max_array_length (5); " *
+                "raise it with limits=Arrow.Limits(max_array_length=...)",
+            ),
+            (Arrow.Limits(max_buffer_bytes=8), "limits=Arrow.Limits(max_buffer_bytes=...)"),
+            (Arrow.Limits(max_body_bytes=8), "limits=Arrow.Limits(max_body_bytes=...)"),
+            (
+                Arrow.Limits(max_nesting_depth=1),
+                "metadata nesting exceeds Arrow.Limits max_nesting_depth (1); " *
+                "raise it with limits=Arrow.Limits(max_nesting_depth=...)",
+            ),
+            (
+                Arrow.Limits(max_metadata_objects=2),
+                "metadata object count exceeds Arrow.Limits max_metadata_objects (2)",
+            ),
+        )
+            for source in (bytes, IOBuffer(bytes))
+                err = @test_throws Arrow.ValidationError Arrow.Table(source; limits)
+                @test occursin(text, err.value.msg)
+            end
+        end
+        # The low-level file reader, and dictionaries combined across batches.
+        dict =
+            take!(Arrow.write(IOBuffer(), (d=Arrow.DictEncode(string.(1:10)),); file=true))
+        io = IOBuffer()
+        Arrow.Writer(io; dictdeltas=true) do w
+            Arrow.write(w, (d=Arrow.DictEncode(["a", "b", "c", "d"]),))
+            Arrow.write(w, (d=Arrow.DictEncode(["e", "f", "g", "h"]),))
+        end
+        deltas = take!(io)
+        for (read, text) in (
+            (
+                () -> Arrow.readfile(bytes; limits=Arrow.Limits(max_messages=1)),
+                "message count 2 exceeds Arrow.Limits max_messages (1)",
+            ),
+            (
+                () -> Arrow.readfile(dict; limits=Arrow.Limits(max_array_length=5)),
+                "dictionary batch length 10 exceeds Arrow.Limits max_array_length (5)",
+            ),
+            (
+                () -> Arrow.Table(deltas; limits=Arrow.Limits(max_array_length=5)),
+                "combined dictionary length 8 exceeds Arrow.Limits max_array_length (5)",
+            ),
+        )
+            err = @test_throws Arrow.ValidationError read()
+            @test occursin(text, err.value.msg)
+        end
+    end
+
+    @testset "decompressed bytes a column reads fund themselves" begin
+        n = 1 << 20
+        frame = transcode(ZstdCompressor, zeros(UInt8, n))
+        # 1 MiB from a few hundred bytes, under a 64 KiB budget.
+        @test length(decodebuffer(frame, n, n; budget=smallbudget())) == n
+        # The same claim with no column known to read it is not funded...
+        @test_throws Arrow.AllocationLimitError decodebuffer(
+            frame,
+            n,
+            -1;
+            budget=smallbudget(),
+        )
+        # ...and a column that reads 100 bytes decodes only those.
+        @test length(decodebuffer(frame, n, 100; budget=smallbudget())) == 128
+        @test_throws Arrow.ValidationError decodebuffer(
+            frame[1:8],
+            n,
+            100;
+            budget=smallbudget(),
+        )
+    end
+
+    @testset "a claim beyond the codec's expansion fails before allocation" begin
+        # 1 GiB cannot come from a few dozen compressed bytes, even when the
+        # column says it reads that much.
+        n = 1 << 30
+        for (codec, frame) in (
+            (
+                Arrow.CODEC_LZ4_FRAME,
+                transcode(Arrow.LZ4FrameCompressor, zeros(UInt8, 1000)),
+            ),
+            (Arrow.CODEC_ZSTD, transcode(ZstdCompressor, zeros(UInt8, 1000))),
+        )
+            budget = Arrow.AllocationBudget(Int64(1) << 40)
+            err = try
+                decodebuffer(frame, n, n; codec=codec, budget=budget)
+            catch e
+                e
+            end
+            @test err isa Arrow.ValidationError && occursin("can hold", err.msg)
+            @test Arrow._remaining(budget) == Int64(1) << 40
+        end
+    end
+
+    @testset "the bytes a column reads come from its layout" begin
+        AC = Arrow.AC
+        slice(bytes) = Arrow.BufferSlice(Arrow.heapregion(bytes), 0, length(bytes))
+        validity = slice(UInt8[0xff])
+        offsets = slice(collect(reinterpret(UInt8, Int32[0, 3, 7])))
+        needed(t, role, n, previous) =
+            Arrow._neededbytes(role, AC.layoutspec_of(t), Int64(n), previous)
+        @test needed(AC.Utf8Type(false), AC.DATA, 2, [validity, offsets]) == 7
+        @test needed(AC.Utf8Type(false), AC.OFFSETS, 2, [validity]) == 12
+        @test needed(AC.IntType(32, true), AC.DATA, 5, [validity]) == 20
+        @test needed(AC.BoolType(), AC.DATA, 9, [validity]) == 2
+        # Zero-width values have no offsets to read an end from.
+        @test needed(AC.FixedSizeBinaryType(0), AC.DATA, 5, [validity]) == -1
+    end
+
+    @testset "a claim the frame header contradicts fails before allocation" begin
+        src = rand(UInt8, 1000)
+        frame = Vector{UInt8}(undef, 2000)
+        len = GC.@preserve frame src Arrow.ZSTD.ZSTD_compress(
+            frame,
+            length(frame),
+            src,
+            length(src),
+            1,
+        )
+        resize!(frame, len)
+        budget = Arrow.AllocationBudget(1 << 30)
+        err = try
+            decodebuffer(frame, 1 << 29, -1; budget=budget)
+        catch e
+            e
+        end
+        @test err isa Arrow.ValidationError && occursin("records", err.msg)
+        @test Arrow._remaining(budget) == 1 << 30
+        @test decodebuffer(frame, 1000, 1000; budget=smallbudget()) == src
+    end
+
+    @testset "a Stream gives each batch its own allowance" begin
+        parts = Tables.partitioner([(x=rand(400_000),) for _ = 1:4])
+        io = IOBuffer()
+        Arrow.write(io, parts; file=true, compress=:zstd)
+        bytes = take!(io)
+        # A cap that holds one batch but not the whole file.
+        limits = Arrow.Limits(max_total_allocated_bytes=5_000_000)
+        @test_throws Arrow.AllocationLimitError Arrow.Table(copy(bytes); limits=limits)
+        @test sum(length(b.x) for b in Arrow.Stream(copy(bytes); limits=limits)) ==
+              1_600_000
+    end
+
+    @testset "concurrent charges are exact" begin
+        budget = Arrow.AllocationBudget(64 * 1000)
+        tasks = [errormonitor(Threads.@spawn begin
+            for _ = 1:1000
+                Arrow._charge!(budget, Int64(1), "test")
+            end
+        end) for _ = 1:64]
+        foreach(wait, tasks)
+        @test Arrow._remaining(budget) == 0
+        @test_throws Arrow.AllocationLimitError Arrow._charge!(budget, Int64(1), "test")
+    end
+end
diff --git a/test/min_arrowtypes_compat.jl b/test/min_arrowtypes_compat.jl
new file mode 100644
index 00000000..ade8a9fe
--- /dev/null
+++ b/test/min_arrowtypes_compat.jl
@@ -0,0 +1,74 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# The main test matrix develops the monorepo ArrowTypes package. This focused
+# check proves that Arrow also works with the declared ArrowTypes 2.0 minimum.
+
+using Arrow
+using ArrowTypes
+using Test
+
+struct MinArrowTypesID
+    value::Int64
+end
+
+Base.:(==)(a::MinArrowTypesID, b::MinArrowTypesID) = a.value == b.value
+
+const MIN_ARROW_TYPES_NAME = Symbol("JuliaLang.ArrowTests.MinArrowTypesID")
+
+ArrowTypes.ArrowType(::Type{MinArrowTypesID}) = Int64
+ArrowTypes.toarrow(value::MinArrowTypesID) = value.value
+ArrowTypes.arrowname(::Type{MinArrowTypesID}) = MIN_ARROW_TYPES_NAME
+ArrowTypes.JuliaType(::Val{MIN_ARROW_TYPES_NAME}, storage, metadata) = MinArrowTypesID
+ArrowTypes.fromarrow(::Type{MinArrowTypesID}, value::Int64) = MinArrowTypesID(value)
+
+struct MinArrowTypesPoint
+    x::Int32
+    y::Int32
+end
+
+const MIN_ARROW_TYPES_POINT_NAME = Symbol("JuliaLang.ArrowTests.MinArrowTypesPoint")
+const MinArrowTypesPointStorage = @NamedTuple{x::Int32, y::Int32}
+
+ArrowTypes.ArrowType(::Type{MinArrowTypesPoint}) = MinArrowTypesPointStorage
+ArrowTypes.toarrow(value::MinArrowTypesPoint) = (x=value.x, y=value.y)
+ArrowTypes.arrowname(::Type{MinArrowTypesPoint}) = MIN_ARROW_TYPES_POINT_NAME
+ArrowTypes.JuliaType(::Val{MIN_ARROW_TYPES_POINT_NAME}, storage, metadata) =
+    MinArrowTypesPoint
+# ArrowTypes 2.0 predates `fromarrowstruct`. Arrow.jl must retain this
+# positional Struct-lifting fallback for the whole declared 2.x range.
+ArrowTypes.fromarrow(::Type{MinArrowTypesPoint}, x::Int32, y::Int32) =
+    MinArrowTypesPoint(x, y)
+
+function roundtrip(name::Symbol, values; file::Bool)
+    io = IOBuffer()
+    Arrow.write(io, NamedTuple{(name,)}((values,)); file)
+    return getproperty(Arrow.Table(take!(io)), name)
+end
+
+@testset "minimum ArrowTypes compatibility" begin
+    @test Base.pkgversion(ArrowTypes) == v"2.0.0"
+
+    values = MinArrowTypesID.(Int64[typemin(Int64), -1, 0, 1, typemax(Int64)])
+    nullable = Union{Missing,MinArrowTypesID}[values[1], missing, values[end]]
+    points = MinArrowTypesPoint[MinArrowTypesPoint(1, 2), MinArrowTypesPoint(3, 4)]
+    for file in (false, true)
+        @test roundtrip(:id, values; file) == values
+        @test isequal(roundtrip(:id, nullable; file), nullable)
+        @test roundtrip(:point, points; file) == points
+    end
+end
diff --git a/test/nested_writes_tests.jl b/test/nested_writes_tests.jl
new file mode 100644
index 00000000..1d8df202
--- /dev/null
+++ b/test/nested_writes_tests.jl
@@ -0,0 +1,425 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Writing plain nested Julia values (vectors, NamedTuples, NTuples, Dicts,
+# Pair vectors) and the typed nested rows Arrow.Table reads.
+
+module NestedWritesTests
+
+using Test
+using Arrow
+using Dates
+using Tables
+
+const AC = Arrow.AC
+
+# A row whose length grows on every look.
+mutable struct Grows <: AbstractVector{Int}
+    n::Int
+end
+Base.size(g::Grows) = (g.n += 1,)
+Base.getindex(::Grows, i::Int) = i
+
+# A map row type of its own, as Parquet's MapValue is.
+struct PairRow <: AbstractVector{Pair{String,Int}}
+    pairs::Vector{Pair{String,Int}}
+end
+Base.size(r::PairRow) = size(r.pairs)
+Base.getindex(r::PairRow, i::Int) = r.pairs[i]
+
+roundtrip(cols; kw...) = Arrow.Table(take!(Arrow.tobuffer(cols; kw...)))
+field(t, j=1) = getfield(t, :schema).fields[j]
+# A map row as the Dict it describes, for comparing with Dict inputs.
+asdict(x) = x === missing ? missing : Dict(x)
+
+# Two plain structs with the same fields.
+struct SameFieldsA
+    a::Int64
+    b::String
+end
+struct SameFieldsB
+    a::Int64
+    b::String
+end
+
+@testset "a Union whose members cannot build as one column writes a union" begin
+    for (v, expected) in (
+        (
+            Union{SameFieldsA,SameFieldsB}[SameFieldsA(1, "x"), SameFieldsB(2, "y")],
+            [(1, "x"), (2, "y")],
+        ),
+        (Union{Int,Vector{Any}}[1, Any[2]], [1, [2]]),
+    )
+        t = Arrow.Table(Arrow.tobuffer((u=v,)))
+        @test field(t).type isa AC.UnionType
+        @test isequal(
+            map(x -> x isa Integer || x isa AbstractVector ? x : Tuple(x), t.u),
+            expected,
+        )
+    end
+end
+
+@testset "a Nothing field under missing rows" begin
+    s = Union{Missing,NamedTuple{(:a,),Tuple{Nothing}}}[(a=nothing,), missing]
+    f = Union{Missing,NTuple{2,Nothing}}[(nothing, nothing), missing]
+    t = Arrow.Table(Arrow.tobuffer((s=s, f=f)))
+    # A struct row reads as a NamedTuple or an ordered Pair vector.
+    fields(r) = r === missing ? missing : Any[x isa Pair ? last(x) : x for x in r]
+    @test isequal(fields.(t.s), [[nothing], missing])
+    @test isequal(fields.(t.f), [[nothing, nothing], missing])
+end
+
+@testset "a union under missing rows stores no value for them" begin
+    # A hidden slot shares the slot of the visible row before it.
+    S = Union{Missing,NamedTuple{(:a,),Tuple{Union{Int,String}}}}
+    F = Union{Missing,NTuple{2,Union{Int,String}}}
+    s = S[missing, (a="x",), missing, missing, (a=2,), missing]
+    f = F[missing, (1, "a"), missing, missing, ("b", 2), missing]
+    t = Arrow.Table(Arrow.tobuffer((s=s, f=f)))
+    fielda(r) = r === missing ? missing : r isa NamedTuple ? r.a : last(only(r))
+    @test isequal(fielda.(t.s), fielda.(s))
+    @test isequal([r === missing ? missing : Tuple(r) for r in t.f], f)
+    # 100,000 missing rows hold no copies of a 1,000-byte value.
+    big = S[isodd(i) ? (a=i == 1 ? "x"^1000 : i,) : missing for i = 1:200_000]
+    @test length(take!(Arrow.tobuffer((s=big,)))) < 4_000_000
+end
+
+@testset "plain nested writes" begin
+    @testset "lists, with missing rows and values" begin
+        cols = (
+            a=[[1, 2], Int[], [3]],
+            b=Union{Missing,Vector{Union{Missing,Int32}}}[[1, missing], missing, Int32[]],
+            c=[["x", "yy"], String[], ["a longer string than twelve bytes"]],
+            d=[[[1], Int[]], [[2, 3]], Vector{Int}[]],
+            e=[1:2, 3:3, 4:3],
+        )
+        t = roundtrip(cols)
+        for (j, name) in enumerate(keys(cols))
+            @test isequal(collect(t[name]), collect(cols[name]))
+            @test field(t, j).type == AC.ListType(false)
+        end
+        @test field(t, 2).nullable && only(field(t, 2).children).nullable
+        @test !field(t, 1).nullable && !only(field(t, 1).children).nullable
+        @test field(roundtrip((a=cols.a,); largelists=true)).type == AC.ListType(true)
+    end
+
+    @testset "structs, and children hidden under missing rows" begin
+        NT = @NamedTuple{a::Int64, s::String, l::Vector{Int8}, n::@NamedTuple{x::Float64}}
+        rows = Union{Missing,NT}[
+            (a=1, s="one", l=Int8[1, 2], n=(x=1.5,)),
+            missing,
+            (a=3, s="", l=Int8[], n=(x=-0.0,)),
+        ]
+        t = roundtrip((r=rows,))
+        @test isequal(collect(t.r), rows)
+        f = field(t)
+        @test f.type isa AC.StructType && f.nullable
+        # Non-nullable children stay non-nullable: their slots under the
+        # missing row hold placeholders.
+        @test [c.nullable for c in f.children] == [false, false, false, false]
+        fields = [(a=missing, b="x"), (a=2, b=missing)]
+        @test isequal(collect(roundtrip((r=fields,)).r), fields)
+        # As views: a string child under a missing row holds an empty view.
+        v = roundtrip((r=rows,); stringview=true)
+        @test isequal(collect(v.r), rows)
+        @test field(v).children[2].type == AC.ViewType(true)
+        @test !field(v).children[2].nullable
+        strs = Union{Missing,NTuple{2,String}}[("a", "b"), missing]
+        @test isequal(collect(roundtrip((p=strs,); stringview=true).p), strs)
+    end
+
+    @testset "maps from Dict and Pair-vector rows" begin
+        dicts = Union{Missing,Dict{String,Union{Missing,Int64}}}[
+            Dict("a" => 1, "b" => missing),
+            missing,
+            Dict{String,Union{Missing,Int64}}(),
+        ]
+        t = roundtrip((m=dicts,))
+        @test field(t).type isa AC.MapType
+        entries = only(field(t).children)
+        @test entries.name == "entries" && !entries.nullable
+        @test [c.name for c in entries.children] == ["key", "value"]
+        @test !entries.children[1].nullable && entries.children[2].nullable
+        @test isequal(asdict.(collect(t.m)), dicts)
+        # Pair rows keep their order and repeated keys.
+        pairs = [["k" => 1, "k" => 2, "a" => 3], Pair{String,Int}[]]
+        tp = roundtrip((m=pairs,))
+        @test field(tp).type isa AC.MapType
+        @test collect.(tp.m) == pairs
+        @test eltype(tp.m) <: Arrow.MapValue
+        # Any vector type of Pairs is a map row (Parquet's MapValue, say).
+        own = [PairRow(["a" => 1]), PairRow(["b" => 2, "c" => 3])]
+        to = roundtrip((m=own, l=[[own[1]], [own[2], own[1]]]))
+        @test field(to, 1).type isa AC.MapType
+        @test only(field(to, 2).children).type isa AC.MapType
+        @test collect.(to.m) == [r.pairs for r in own]
+        err = try
+            Arrow.tobuffer((m=[Dict{Union{Missing,String},Int}(missing => 1)],))
+        catch e
+            e
+        end
+        @test err isa ArgumentError && occursin("column m has a missing map key", err.msg)
+    end
+
+    @testset "NTuples as fixed-size lists" begin
+        rows = Union{Missing,NTuple{3,Float64}}[(1.0, 2.0, 3.0), missing]
+        t = roundtrip((p=rows,))
+        @test field(t).type == AC.FixedSizeListType(3)
+        @test !only(field(t).children).nullable
+        @test isequal(collect(t.p), rows)
+        strs = [("a", "b"), ("c", "")]
+        @test collect(roundtrip((p=strs,)).p) == strs
+    end
+
+    @testset "deep combinations with missing at every level" begin
+        Inner = @NamedTuple{k::Int64, v::Union{Missing,String}}
+        rows = [
+            [Dict("x" => Union{Missing,Inner}[(k=1, v="a"), missing, (k=2, v=missing)])],
+            Dict{String,Vector{Union{Missing,Inner}}}[],
+            [Dict{String,Vector{Union{Missing,Inner}}}()],
+        ]
+        t = roundtrip((d=rows,))
+        @test field(t).type == AC.ListType(false)
+        @test only(field(t).children).type isa AC.MapType
+        @test isequal([asdict.(r) for r in t.d], rows)
+    end
+
+    @testset "Vector{Any} columns narrow from their values" begin
+        @test collect(roundtrip((x=Any[[1, 2], [3]],)).x) == [[1, 2], [3]]
+        @test collect(roundtrip((x=Any[(a=1,), (a=2,)],)).x) == [(a=1,), (a=2,)]
+        t = roundtrip((x=Any[missing, missing],))
+        @test field(t).type isa AC.NullType
+        # Only empty rows: their declared element type.
+        t = roundtrip((x=Any[Int16[], Int16[]],))
+        @test only(field(t).children).type == AC.IntType(16, true)
+        err = try
+            Arrow.tobuffer((x=Any[Any[], Any[]],))
+        catch e
+            e
+        end
+        @test err isa ArgumentError
+        @test startswith(err.msg, "column x (child item) has")
+        # A dictionary-encoded column narrows the same way.
+        rows = [Any[1], Any[2], Any[1]]
+        t = roundtrip((x=rows,); dictencode=true)
+        @test field(t).type isa AC.DictionaryType
+        @test collect(t.x) == rows
+        nested = [[[1], [2, 3]], [[]], [[4]]]
+        @test collect(roundtrip((x=nested,); dictencode=true).x) == nested
+    end
+
+    @testset "a row that changes between passes is refused" begin
+        err = try
+            Arrow.tobuffer((x=[Grows(0)],))
+        catch e
+            e
+        end
+        @test err isa ArgumentError &&
+              occursin("changed while it was being written", err.msg)
+    end
+end
+
+@testset "typed nested rows write back" begin
+    rows = Union{Missing,Vector{Union{Missing,Int64}}}[[1, missing], missing, [], [4, 5, 6]]
+    structs = Union{Missing,@NamedTuple{a::Int32,b::Union{Missing,String}}}[
+        (a=1, b="x"),
+        missing,
+        (a=3, b=missing),
+        (a=4, b="y"),
+    ]
+    maps = [Dict("a" => 1), Dict{String,Int}(), Dict("b" => 2, "c" => 3), Dict("d" => 4)]
+    t = roundtrip((l=rows, s=structs, m=maps))
+    # A fresh write of the read views, of owned copies, and a retained rewrite
+    # all keep the schema and values.
+    for src in (Tables.columntable(t), map(copy, Tables.columntable(t)), t)
+        back = roundtrip(src)
+        @test all(j -> Arrow._fieldcontractequal(field(back, j), field(t, j)), 1:3)
+        @test isequal(collect(back.l), collect(t.l))
+        @test isequal(collect(back.s), collect(t.s))
+        @test isequal(collect(back.m), collect(t.m))
+    end
+    # Batches of a multi-batch column write as they were read.
+    chunked = roundtrip(Tables.partitioner([(l=rows[1:2],), (l=rows[3:4],)]))
+    @test isequal(collect(roundtrip(Tables.columntable(chunked)).l), rows)
+end
+
+@testset "a read list whose null rows span values" begin
+    # Arrow lets a null list slot cover child values: offsets [0, 2, 3, 3]
+    # with row 2 null over value 3.
+    child =
+        AC.ArrayData(AC.IntType(64, true), 3, [AC.BufferSlice(), AC._databuffer([1, 2, 3])])
+    lt = AC.ListType(false)
+    d = AC.ArrayData(
+        lt,
+        3,
+        [AC._bitmapbuffer([true, false, true]), AC._databuffer(Int32[0, 2, 3, 3])];
+        children=[child],
+        nullcount=1,
+    )
+    f = AC.Field("l", lt; nullable=true, children=[AC.Field("item", AC.IntType(64, true))])
+    sch = AC.Schema([f])
+    t = Arrow.Table(Arrow.writestream(sch, [AC.RecordBatch(sch, [d], 3)]))
+    @test isequal(collect(t.l), [[1, 2], missing, Int[]])
+    back = roundtrip(Tables.columntable(t))
+    @test isequal(collect(back.l), [[1, 2], missing, Int[]])
+end
+
+@testset "a retained rewrite keeps the source's child names" begin
+    child =
+        AC.ArrayData(AC.IntType(64, true), 3, [AC.BufferSlice(), AC._databuffer([1, 2, 3])])
+    lt = AC.ListType(false)
+    d = AC.ArrayData(
+        lt,
+        2,
+        [AC.BufferSlice(), AC._databuffer(Int32[0, 2, 3])];
+        children=[child],
+    )
+    f = AC.Field(
+        "l",
+        lt;
+        nullable=false,
+        children=[AC.Field("element", AC.IntType(64, true))],
+    )
+    sch = AC.Schema([f])
+    t = Arrow.Table(Arrow.writestream(sch, [AC.RecordBatch(sch, [d], 2)]))
+    back = roundtrip(t)
+    @test only(field(back).children).name == "element"
+    @test collect(back.l) == [[1, 2], [3]]
+end
+
+@testset "a Union of tuple types writes unlabelled, as a map value too" begin
+    v = Union{Tuple{Int32,Int32},Tuple{Date,Date,Date}}[
+        (Int32(1), Int32(2)),
+        (Date(2020), Date(2020), Date(2021)),
+    ]
+    for tbl in ((c=v,), (c=[Dict("a" => x) for x in v],))
+        t = roundtrip(tbl)
+        @test field(t).metadata === nothing
+        @test field(t).type isa AC.UnionType || field(t).children[1].type isa AC.StructType
+        back = collect(t.c)
+        tbl.c isa Vector{<:Dict} ? @test(Dict.(back) == tbl.c) : @test(back == v)
+    end
+end
+
+@testset "a retained rewrite routes typed union rows to their children" begin
+    # A dense union, as a fresh write makes one.
+    t = roundtrip((u=Union{Int64,String}[1, "two", 3],))
+    back = roundtrip(t)
+    @test Arrow._fieldcontractequal(field(back), field(t))
+    @test collect(back.u) == [1, "two", 3]
+    # A sparse union with a null, built as pyarrow would.
+    int = AC.ArrayData(
+        AC.IntType(64, true),
+        3,
+        [AC._bitmapbuffer([true, true, false]), AC._databuffer([1, 0, 0])];
+        nullcount=1,
+    )
+    str = last(AC.fromjulia("s", ["", "two", ""]))
+    ut = AC.UnionType(AC.SparseMode, Int8[0, 1])
+    d = AC.ArrayData(ut, 3, [AC._databuffer(Int8[0, 1, 0])]; children=[int, str])
+    children = [
+        AC.Field("i", AC.IntType(64, true)),
+        AC.Field("s", AC.Utf8Type(false); nullable=false),
+    ]
+    f = AC.Field("u", ut; nullable=false, children)
+    sch = AC.Schema([f])
+    sparse = Arrow.Table(Arrow.writestream(sch, [AC.RecordBatch(sch, [d], 3)]))
+    @test isequal(collect(sparse.u), [1, "two", missing])
+    back = roundtrip(sparse)
+    @test field(back).type.mode == AC.SparseMode
+    @test isequal(collect(back.u), [1, "two", missing])
+    # Children at another width than a fresh write's take the values too: a
+    # largelists or stringview source, or pyarrow's large_string.
+    for kw in ((largelists=true,), (stringview=true,))
+        wide = (u=Union{Int64,String}[1, "two", 3], l=Union{Int64,Vector{Int64}}[1, [2], 3])
+        src = roundtrip(wide; kw...)
+        back = roundtrip(src)
+        @test Arrow._fieldcontractequal(field(back), field(src))
+        @test Arrow._fieldcontractequal(field(back, 2), field(src, 2))
+        @test collect(back.u) == wide.u
+        @test collect(back.l) == wide.l
+    end
+    # Two children of one type cannot be told apart by value.
+    twin = AC.ArrayData(
+        ut,
+        2,
+        [AC._databuffer(Int8[0, 1])];
+        children=[
+            last(AC.fromjulia("a", Int32[1, 2])),
+            last(AC.fromjulia("b", Int32[3, 4])),
+        ],
+    )
+    tf = AC.Field(
+        "u",
+        ut;
+        nullable=false,
+        children=[AC.Field("a", AC.IntType(32, true)), AC.Field("b", AC.IntType(32, true))],
+    )
+    tsch = AC.Schema([tf])
+    twins = Arrow.Table(Arrow.writestream(tsch, [AC.RecordBatch(tsch, [twin], 2)]))
+    err = try
+        roundtrip(twins)
+        nothing
+    catch e
+        e
+    end
+    @test err isa ArgumentError && occursin("fit none or several", err.msg)
+end
+
+@testset "union children lower their values, nested and inside unions" begin
+    ut = AC.UnionType(AC.SparseMode, Int8[0, 1])
+    rewrite(f, d, n) = begin
+        sch = AC.Schema([f])
+        src = Arrow.Table(Arrow.writestream(sch, [AC.RecordBatch(sch, [d], n)]))
+        back = roundtrip(src)
+        @test Arrow._fieldcontractequal(field(back), field(src))
+        @test isequal(collect(Tables.getcolumn(back, 1)), collect(Tables.getcolumn(src, 1)))
+        return back
+    end
+    sparse(children, ids, fields) = (
+        AC.Field("u", ut; children=fields),
+        AC.ArrayData(ut, length(ids), [AC._databuffer(ids)]; children),
+    )
+    # A date child: its values lower to days, not stored as they read.
+    datef, dated = AC.fromjulia("d", Int32[19000, 0, 19002])
+    datef = AC.Field("d", AC.DateType(AC.DAY))
+    dated = AC.ArrayData(AC.DateType(AC.DAY), 3, dated.buffers)
+    strf, strd = AC.fromjulia("s", ["", "two", ""])
+    uf, ud = sparse([dated, strd], Int8[0, 1, 0], [datef, strf])
+    back = rewrite(uf, ud, 3)
+    @test collect(back.u) == [Dates.Date(2022, 1, 8), "two", Dates.Date(2022, 1, 10)]
+    # The same union as a struct field, and as list values.
+    sf = AC.Field("st", AC.StructType(); children=[uf])
+    sd = AC.ArrayData(AC.StructType(), 3, [AC.BufferSlice()]; children=[ud])
+    rewrite(sf, sd, 3)
+    lt = AC.ListType(false)
+    lf = AC.Field("l", lt; children=[uf])
+    ld = AC.ArrayData(
+        lt,
+        2,
+        [AC.BufferSlice(), AC._databuffer(Int32[0, 1, 3])];
+        children=[ud],
+    )
+    rewrite(lf, ld, 2)
+    # A union whose first child is itself a union.
+    intf, intd = AC.fromjulia("i", Int32[7, 8, 9])
+    of, od = sparse([ud, intd], Int8[0, 1, 0], [uf, intf])
+    back = rewrite(of, od, 3)
+    @test collect(Tables.getcolumn(back, 1)) ==
+          [Dates.Date(2022, 1, 8), 8, Dates.Date(2022, 1, 10)]
+end
+
+end # module NestedWritesTests
diff --git a/test/nestedvalues_tests.jl b/test/nestedvalues_tests.jl
new file mode 100644
index 00000000..4a2be12c
--- /dev/null
+++ b/test/nestedvalues_tests.jl
@@ -0,0 +1,624 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Writer symmetry for nested public values: facade rows carry public leaf
+# values (Dates, Durations, DataDecimals) at every depth, and both retained
+# rewrites and fresh composite writes lower them exactly or refuse.
+
+module NestedValuesTests
+
+using Test
+using Dates
+using Logging
+using Arrow
+import ArrowTypes, DataDecimals, Durations
+
+const AC = Arrow.AC
+const Ts = Durations.Timestamp
+const Zts = Durations.ZonedTimestamp
+const Denver = Zts{Microsecond,Symbol("America/Denver")}
+const Dec64 = DataDecimals.Decimal{10,2,Int64}
+const MonthDayNano = NamedTuple{(:months, :days, :nanos),Tuple{Int32,Int32,Int64}}
+
+# A registered logical Union. Its ArrowTypes-domain storage keeps a
+# nanosecond timestamp branch as raw Int64 and a millisecond one as DateTime.
+struct NestedStampOrLabel
+    value::Union{Int64,DateTime,String}
+end
+Base.:(==)(a::NestedStampOrLabel, b::NestedStampOrLabel) = a.value == b.value
+const NESTED_STAMP_OR_LABEL = Symbol("JuliaLang.ArrowTests.NestedStampOrLabel")
+ArrowTypes.arrowname(::Type{NestedStampOrLabel}) = NESTED_STAMP_OR_LABEL
+ArrowTypes.JuliaType(::Val{NESTED_STAMP_OR_LABEL}, S, metadata) = NestedStampOrLabel
+
+# An identity extension over its storage: nested registrations of it build
+# deeply nested isbits tuples whose restoration copies inline payload.
+const NESTED_IDENTITY = Symbol("JuliaLang.ArrowTests.NestedIdentity")
+ArrowTypes.JuliaType(::Val{NESTED_IDENTITY}, S, metadata) = S
+ArrowTypes.ArrowType(::Type{NestedStampOrLabel}) = Union{Int64,DateTime,String}
+ArrowTypes.toarrow(x::NestedStampOrLabel) = x.value
+ArrowTypes.fromarrow(::Type{NestedStampOrLabel}, x) = NestedStampOrLabel(x)
+
+validity(present) = AC._bitmapbuffer(present)
+
+"One primitive-layout leaf over `storage`; `present` makes it nullable."
+function leaf(name, t, storage::Vector; present=nothing)
+    buffers = [present === nothing ? AC.BufferSlice() : validity(present)]
+    push!(buffers, AC._databuffer(storage))
+    nulls = present === nothing ? 0 : count(!, present)
+    return AC.Field(name, t; nullable=present !== nothing),
+    AC.ArrayData(t, length(storage), buffers; nullcount=nulls)
+end
+
+samefields(a, b) = length(a) == length(b) && all(Arrow._fieldcontractequal.(a, b))
+# A map row's entries, in stored order, for comparing with `Pair` vectors.
+entries(x) = x isa Arrow.MapValue ? collect(x) : x
+
+"""
+Core-built file -> Arrow.Table -> Arrow.tobuffer -> Arrow.Table. Checks that
+both reads materialize `expected` and that the rewrite keeps every
+descriptor; returns the first table.
+"""
+function checkrewrite(field, data, expected)
+    schema = AC.Schema([field])
+    table = Arrow.Table(Arrow.writefile(schema, [AC.RecordBatch(schema, [data])]))
+    back = Arrow.Table(take!(Arrow.tobuffer(table)))
+    name = Symbol(field.name)
+    @test isequal(entries.(collect(getproperty(table, name))), expected)
+    @test isequal(entries.(collect(getproperty(back, name))), expected)
+    @test eltype(getproperty(back, name)) == eltype(getproperty(table, name))
+    @test samefields(getfield(back, :schema).fields, getfield(table, :schema).fields)
+    @test samefields(getfield(back, :schema).fields, [field])
+    return table
+end
+
+replaced(table, column) = Arrow.Table(
+    getfield(table, :names),
+    AbstractVector[column],
+    getfield(table, :lookup),
+    getfield(table, :schema),
+    AC.OwnerRegion[],
+    length(column),
+)
+
+function refusal(f)
+    try
+        f()
+    catch err
+        return err
+    end
+    return nothing
+end
+
+ns(x) = reinterpret(Ts{Nanosecond}, Int64(x))
+row(pairs...) = (; (Symbol(first(p)) => last(p) for p in pairs)...)
+const StructRows = Union{Missing,NamedTuple}
+
+const NS = AC.TimestampType(AC.NANOSECOND, nothing)
+const ST = AC.StructType()
+
+function stampedstruct()
+    whenfield, whendata =
+        leaf("when", NS, Int64[1, 0, 0, 4]; present=[true, false, false, true])
+    field = AC.Field("s", ST; nullable=true, children=[whenfield])
+    data = AC.ArrayData(
+        ST,
+        4,
+        [validity([true, false, true, true])];
+        children=[whendata],
+        nullcount=1,
+    )
+    expected = StructRows[
+        row("when" => ns(1)),
+        missing,
+        row("when" => missing),
+        row("when" => ns(4)),
+    ]
+    return field, data, expected
+end
+
+@testset "nested public values: writer symmetry" begin
+    @testset "retained struct{timestamp[ns]} with a null parent and null child" begin
+        field, data, expected = stampedstruct()
+        checkrewrite(field, data, expected)
+    end
+
+    @testset "retained struct{zoned timestamp} with a hidden non-null child" begin
+        zoned = AC.TimestampType(AC.MICROSECOND, "America/Denver")
+        atfield, atdata = leaf("at", zoned, Int64[10, 0, 30])
+        field = AC.Field("z", ST; nullable=true, children=[atfield])
+        data = AC.ArrayData(
+            ST,
+            3,
+            [validity([true, false, true])];
+            children=[atdata],
+            nullcount=1,
+        )
+        expected = StructRows[
+            row("at" => reinterpret(Denver, Int64(10))),
+            missing,
+            row("at" => reinterpret(Denver, Int64(30))),
+        ]
+        table = checkrewrite(field, data, expected)
+        @test table.z[1].at isa Denver
+    end
+
+    @testset "retained list{date32} with null rows and null items" begin
+        itemfield, itemdata = leaf(
+            "item",
+            AC.DateType(AC.DAY),
+            Int32[0, 1, 0, 19000];
+            present=[true, true, false, true],
+        )
+        lt = AC.ListType(false)
+        field = AC.Field("days", lt; nullable=true, children=[itemfield])
+        data = AC.ArrayData(
+            lt,
+            3,
+            [validity([true, false, true]), AC._databuffer(Int32[0, 2, 2, 4])];
+            children=[itemdata],
+            nullcount=1,
+        )
+        epoch = Date(1970, 1, 1)
+        expected = Union{Missing,Vector{Any}}[
+            Any[epoch, epoch + Day(1)],
+            missing,
+            Any[missing, epoch + Day(19000)],
+        ]
+        checkrewrite(field, data, expected)
+    end
+
+    @testset "retained map{utf8 => duration[ms]} with a null row and value" begin
+        keyfield, keydata = AC.fromjulia("key", ["a", "b", "c"])
+        valuefield, valuedata = leaf(
+            "value",
+            AC.DurationType(AC.MILLISECOND),
+            Int64[5, 0, 7];
+            present=[true, false, true],
+        )
+        entries = AC.Field("entries", ST; nullable=false, children=[keyfield, valuefield])
+        entriesdata = AC.ArrayData(
+            ST,
+            3,
+            [AC.BufferSlice()];
+            children=[keydata, valuedata],
+            nullcount=0,
+        )
+        mt = AC.MapType(false)
+        field = AC.Field("m", mt; nullable=true, children=[entries])
+        data = AC.ArrayData(
+            mt,
+            3,
+            [validity([true, false, true]), AC._databuffer(Int32[0, 2, 2, 3])];
+            children=[entriesdata],
+            nullcount=1,
+        )
+        expected = Union{Missing,Vector{Pair{Any,Any}}}[
+            Pair{Any,Any}["a" => Millisecond(5), "b" => missing],
+            missing,
+            Pair{Any,Any}["c" => Millisecond(7)],
+        ]
+        checkrewrite(field, data, expected)
+    end
+
+    @testset "retained fixed-size-list{decimal64} with a hidden row" begin
+        itemfield, itemdata =
+            leaf("item", AC.DecimalType(10, 2, 64), Int64[125, -5, 0, 0, 999, 1])
+        ft = AC.FixedSizeListType(2)
+        field = AC.Field("amounts", ft; nullable=true, children=[itemfield])
+        data = AC.ArrayData(
+            ft,
+            3,
+            [validity([true, false, true])];
+            children=[itemdata],
+            nullcount=1,
+        )
+        dec(x) = reinterpret(Dec64, Int64(x))
+        expected = Union{Missing,Tuple}[(dec(125), dec(-5)), missing, (dec(999), dec(1))]
+        checkrewrite(field, data, expected)
+    end
+
+    @testset "retained registered dense union{timestamp[ns], timestamp[ms, UTC], utf8}" begin
+        # Plain retained Unions refuse (their type ids are not recoverable
+        # from public values); a registered logical Union keeps its routes.
+        nsfield, nsdata = leaf("0", NS, Int64[11, 22])
+        msfield, msdata =
+            leaf("1", AC.TimestampType(AC.MILLISECOND, "UTC"), Int64[86_400_000])
+        strfield, strdata = AC.fromjulia("2", ["x"])
+        ut = AC.UnionType(AC.DenseMode, Int8[0, 1, 2])
+        field = AC.Field(
+            "u",
+            ut;
+            nullable=false,
+            metadata=[
+                "ARROW:extension:name" => String(NESTED_STAMP_OR_LABEL),
+                "ARROW:extension:metadata" => "",
+            ],
+            children=[nsfield, msfield, strfield],
+        )
+        data = AC.ArrayData(
+            ut,
+            4,
+            [AC._databuffer(Int8[0, 2, 1, 0]), AC._databuffer(Int32[0, 0, 0, 1])];
+            children=[nsdata, msdata, strdata],
+            nullcount=0,
+        )
+        expected = NestedStampOrLabel.(Any[Int64(11), "x", DateTime(1970, 1, 2), Int64(22)])
+        checkrewrite(field, data, expected)
+    end
+
+    @testset "retained run-end encoded interval with a null run" begin
+        runfield, rundata = AC.fromjulia("run_ends", Int32[2, 3])
+        valuefield, valuedata = leaf(
+            "values",
+            AC.IntervalType(AC.MONTH_DAY_NANO),
+            MonthDayNano[MonthDayNano((1, 2, 3)), MonthDayNano((0, 0, 0))];
+            present=[true, false],
+        )
+        rt = AC.RunEndEncodedType()
+        field = AC.Field("r", rt; nullable=true, children=[runfield, valuefield])
+        data = AC.ArrayData(
+            rt,
+            3,
+            AC.BufferSlice[];
+            children=[rundata, valuedata],
+            nullcount=0,
+        )
+        span = Durations.Duration(1, 2, 3)
+        checkrewrite(field, data, Union{Missing,Durations.Duration}[span, span, missing])
+    end
+
+    @testset "retained dictionary of struct{timestamp[ns]}" begin
+        whenfield, whendata = leaf("when", NS, Int64[100, 200])
+        pool = AC.ArrayData(ST, 2, [AC.BufferSlice()]; children=[whendata], nullcount=0)
+        dt = AC.DictionaryType(AC.IntType(32, true), ST, false)
+        field = AC.Field("d", dt; nullable=true, children=[whenfield])
+        data = AC.ArrayData(
+            dt,
+            4,
+            [validity([true, true, false, true]), AC._databuffer(Int32[1, 0, 0, 1])];
+            dictionary=pool,
+            nullcount=1,
+        )
+        expected = StructRows[
+            row("when" => ns(200)),
+            row("when" => ns(100)),
+            missing,
+            row("when" => ns(200)),
+        ]
+        checkrewrite(field, data, expected)
+    end
+
+    @testset "retained hidden slots on the non-masked storage path" begin
+        # decimal128 storage is not isbits, and run-end values are a plain
+        # vector, so both lower visible values one at a time.
+        dt = AC.DecimalType(20, 3, 128)
+        bytes = zeros(UInt8, 48)
+        bytes[1] = 0x07
+        bytes[33] = 0x09
+        decfield = AC.Field("x", dt; nullable=false)
+        decdata =
+            AC.ArrayData(dt, 3, [AC.BufferSlice(), AC._databuffer(bytes)]; nullcount=0)
+        runfield, rundata = AC.fromjulia("run_ends", Int32[1, 3])
+        valuefield, valuedata = leaf("values", NS, Int64[5, 9])
+        rt = AC.RunEndEncodedType()
+        reefield = AC.Field("r", rt; nullable=false, children=[runfield, valuefield])
+        reedata = AC.ArrayData(
+            rt,
+            3,
+            AC.BufferSlice[];
+            children=[rundata, valuedata],
+            nullcount=0,
+        )
+        field = AC.Field("s", ST; nullable=true, children=[decfield, reefield])
+        data = AC.ArrayData(
+            ST,
+            3,
+            [validity([true, false, true])];
+            children=[decdata, reedata],
+            nullcount=1,
+        )
+        D = DataDecimals.Decimal{20,3,Int128}
+        expected = StructRows[
+            row("x" => reinterpret(D, Int128(7)), "r" => ns(5)),
+            missing,
+            row("x" => reinterpret(D, Int128(9)), "r" => ns(9)),
+        ]
+        checkrewrite(field, data, expected)
+    end
+
+    @testset "retained nested columns refuse replaced values" begin
+        field, data, expected = stampedstruct()
+        table = checkrewrite(field, data, expected)
+        for bad in (
+            # typed child path: a String is not a timestamp value
+            StructRows[row("when" => "oops")],
+            # a raw storage count is not a public timestamp value
+            StructRows[row("when" => Int64(1))],
+            # masked child path (a null parent hides one slot)
+            StructRows[missing, row("when" => Int64(1))],
+        )
+            err = refusal(() -> Arrow.write(IOBuffer(), replaced(table, bad); file=false))
+            @test err isa ArgumentError
+            @test occursin("retained Arrow type", sprint(showerror, err))
+        end
+    end
+
+    @testset "incremental writer and append keep nested public values" begin
+        field, data, expected = stampedstruct()
+        table = checkrewrite(field, data, expected)
+        io = IOBuffer()
+        w = Arrow.Writer(io; file=false)
+        Arrow.write(w, table)
+        Arrow.write(w, table)
+        close(w)
+        written = Arrow.Table(take!(io))
+        @test isequal(collect(written.s), vcat(expected, expected))
+        @test samefields(getfield(written, :schema).fields, [field])
+
+        io = IOBuffer()
+        Arrow.write(io, table; file=false)
+        Arrow.append(io, table)
+        appended = Arrow.Table(take!(io))
+        @test isequal(collect(appended.s), vcat(expected, expected))
+        @test samefields(getfield(appended, :schema).fields, [field])
+    end
+
+    @testset "fresh NamedTuple rows lower public leaf fields" begin
+        rows = [
+            (
+                dt=DateTime(2026, 1, 2, 3, 4, 5),
+                n=Ts{Nanosecond}(2026, 1, 1) + Nanosecond(7),
+                d=Date(2026, 3, 4),
+            ),
+            (dt=DateTime(1969, 12, 31), n=Ts{Nanosecond}(1900, 1, 1), d=Date(1, 1, 1)),
+        ]
+        table = Arrow.Table(take!(Arrow.tobuffer((s=rows,))))
+        field = only(getfield(table, :schema).fields)
+        @test [child.type for child in field.children] == [
+            AC.TimestampType(AC.MILLISECOND, nothing),
+            AC.TimestampType(AC.NANOSECOND, nothing),
+            AC.DateType(AC.DAY),
+        ]
+        @test all(keys(r) == (:dt, :n, :d) for r in table.s)
+        @test [collect(Any, values(r)) for r in table.s] == [collect(Any, r) for r in rows]
+        @test table.s[1].dt isa Ts{Millisecond}
+        back = Arrow.Table(take!(Arrow.tobuffer(table)))
+        @test isequal(collect(back.s), collect(table.s))
+        @test samefields(getfield(back, :schema).fields, [field])
+    end
+
+    @testset "fresh nullable NamedTuple rows lower through the masked path" begin
+        Row = @NamedTuple{at::DateTime, amount::Dec64, span::Durations.Duration}
+        rows = Union{Missing,Row}[
+            (at=DateTime(2026, 1, 1), amount=Dec64(1.25), span=Durations.Duration(1, 2, 3)),
+            missing,
+        ]
+        table = Arrow.Table(take!(Arrow.tobuffer((s=rows,))))
+        field = only(getfield(table, :schema).fields)
+        @test [child.type for child in field.children] == [
+            AC.TimestampType(AC.MILLISECOND, nothing),
+            AC.DecimalType(10, 2, 128),
+            AC.IntervalType(AC.MONTH_DAY_NANO),
+        ]
+        @test ismissing(table.s[2])
+        @test collect(Any, values(table.s[1])) == collect(Any, rows[1])
+        back = Arrow.Table(take!(Arrow.tobuffer(table)))
+        @test isequal(collect(back.s), collect(table.s))
+    end
+
+    @testset "fresh list of Timestamp round-trips" begin
+        lists = [
+            [Ts{Nanosecond}(2026, 1, 1), Ts{Nanosecond}(2026, 1, 2)],
+            Ts{Nanosecond}[],
+            missing,
+        ]
+        table = Arrow.Table(take!(Arrow.tobuffer((l=lists,))))
+        field = only(getfield(table, :schema).fields)
+        @test field.type == AC.ListType(false)
+        @test only(field.children).type == AC.TimestampType(AC.NANOSECOND, nothing)
+        @test isequal(collect(table.l), lists)
+        back = Arrow.Table(take!(Arrow.tobuffer(table)))
+        @test isequal(collect(back.l), lists)
+        @test samefields(getfield(back, :schema).fields, [field])
+    end
+
+    @testset "fresh union and map children lower public values" begin
+        values = Union{Ts{Nanosecond},String}[Ts{Nanosecond}(2026, 1, 1), "x"]
+        table = Arrow.Table(take!(Arrow.tobuffer((u=values,))))
+        field = only(getfield(table, :schema).fields)
+        @test field.type isa AC.UnionType
+        @test AC.TimestampType(AC.NANOSECOND, nothing) in [c.type for c in field.children]
+        @test collect(table.u) == values
+
+        maps = [Dict("a" => Millisecond(5))]
+        mtable = Arrow.Table(take!(Arrow.tobuffer((m=maps,))))
+        @test mtable.m == maps
+    end
+
+    @testset "fresh nested temporal columns refuse like the top level" begin
+        z1 = Denver(Ts{Microsecond}(2026, 1, 1), Dates.UTC)
+        z2 = Durations.astimezone(z1, :UTC)
+        ZRow = NamedTuple{(:z,),Tuple{Zts{Microsecond}}}
+        for column in ([[z1, z2]], ZRow[(z=z1,), (z=z2,)])
+            err = refusal(() -> Arrow.tobuffer((c=column,)))
+            @test err isa ArgumentError
+            @test occursin("astimezone", sprint(showerror, err))
+        end
+        mixed = Ts[Ts{Nanosecond}(2026, 1, 1), Ts{Millisecond}(2026, 1, 1)]
+        err = refusal(() -> Arrow.tobuffer((c=[mixed],)))
+        @test err isa ArgumentError
+        @test occursin("abstract Timestamp", sprint(showerror, err))
+        # One resolution narrows, as at the top level.
+        one = Arrow.Table(take!(Arrow.tobuffer((c=[Ts[Ts{Nanosecond}(2026, 1, 1)]],))))
+        @test eltype(only(one.c)) === Ts{Nanosecond}
+    end
+
+    @testset "nested conversion consumes the reader allocation budget" begin
+        n = 20_000
+        function streamread(bytes, cap)
+            stream = Arrow.Stream(
+                copy(bytes);
+                limits=Arrow.Limits(max_total_allocated_bytes=cap),
+            )
+            return only(collect(stream))
+        end
+        # The smallest cap that reads the stream: its batch's charge, which
+        # outweighs opening the stream here.
+        function charge(bytes)
+            lo, hi = 0, 1 << 32
+            while lo < hi
+                mid = (lo + hi) >>> 1
+                fits = try
+                    streamread(bytes, mid)
+                    true
+                catch e
+                    e isa Arrow.AllocationLimitError || rethrow()
+                    false
+                end
+                fits ? (hi = mid) : (lo = mid + 1)
+            end
+            return lo
+        end
+        function corebytes(field, data)
+            schema = AC.Schema([field])
+            return Arrow.writestream(schema, [AC.RecordBatch(schema, [data])])
+        end
+        decfield, decdata = leaf("x", AC.DecimalType(10, 2, 64), fill(Int64(70000), n))
+        decbytes = corebytes(AC.Field("x", decfield.type), decdata)
+
+        tsfield, tsdata = leaf("0", NS, collect(Int64, 1:n))
+        ut = AC.UnionType(AC.DenseMode, Int8[1])
+        unionbytes = corebytes(
+            AC.Field("x", ut; nullable=false, children=[tsfield]),
+            AC.ArrayData(
+                ut,
+                n,
+                [AC._databuffer(ones(Int8, n)), AC._databuffer(Int32.(0:(n - 1)))];
+                children=[tsdata],
+                nullcount=0,
+            ),
+        )
+
+        runsfield, runsdata = AC.fromjulia("run_ends", Int32.(1:n))
+        reetype = AC.RunEndEncodedType()
+        valfield, valdata = leaf("values", NS, collect(Int64, 1:n))
+        unknown = [
+            "ARROW:extension:name" => "JuliaLang.ArrowTests.NestedUnknown",
+            "ARROW:extension:metadata" => "",
+        ]
+        reebytes = corebytes(
+            AC.Field(
+                "x",
+                reetype;
+                nullable=false,
+                metadata=unknown,
+                children=[runsfield, valfield],
+            ),
+            AC.ArrayData(
+                reetype,
+                n,
+                AC.BufferSlice[];
+                children=[runsdata, valdata],
+                nullcount=0,
+            ),
+        )
+
+        lifted = [NestedStampOrLabel(isodd(i) ? Int64(i) : "s$(i)") for i = 1:n]
+        liftedbytes = take!(Arrow.tobuffer((x=lifted,)))
+
+        # Fifteen singleton fixed-size-list identity registrations around a
+        # 128-float leaf: every level's restored tuple copies the full
+        # inline payload, so charges must scale with the row's byte size.
+        fslrows, fslwidth, fsldepth = 500, 128, 15
+        identity_meta = [
+            "ARROW:extension:name" => String(NESTED_IDENTITY),
+            "ARROW:extension:metadata" => "",
+        ]
+        fslfield, fsldata = AC.fromjulia("item", fill(1.5, fslrows * fslwidth))
+        fslexpected = ntuple(_ -> 1.5, fslwidth)
+        for level = 1:fsldepth
+            width = level == 1 ? fslwidth : 1
+            t = AC.FixedSizeListType(width)
+            fslfield = AC.Field(
+                "x",
+                t;
+                nullable=false,
+                metadata=identity_meta,
+                children=[
+                    AC.Field(
+                        "item",
+                        fslfield.type;
+                        nullable=fslfield.nullable,
+                        metadata=fslfield.metadata,
+                        children=fslfield.children,
+                    ),
+                ],
+            )
+            fsldata = AC.ArrayData(
+                t,
+                fslrows,
+                [AC.BufferSlice()];
+                children=[fsldata],
+                nullcount=0,
+            )
+            level == 1 || (fslexpected = (fslexpected,))
+        end
+        fslschema = AC.Schema([fslfield])
+        fslbytes = Arrow.writestream(fslschema, [AC.RecordBatch(fslschema, [fsldata])])
+        # Two payload copies per level per row is the reserve model.
+        fslfloor = 2 * fslrows * fsldepth * 8 * fslwidth
+
+        # Each dynamic-conversion seam reserves a fixed per-value overhead
+        # (`_publicvalue`'s converted leaf and the ArrowTypes raw-domain and
+        # fromarrow tails), and composite restorations reserve the row's
+        # inline payload besides. The floors below fail if a reserve is
+        # dropped. A flat decimal column reads as a view over its buffer,
+        # with no per-value charge; an unlabeled union as one typed row
+        # vector (8 bytes per row); and a run-end column whose unknown label
+        # reads as storage as a run-end view (its run ends copied, 8 bytes
+        # per run).
+        with_logger(NullLogger()) do
+            for (name, bytes, floor, first_expected) in (
+                ("flat decimal", decbytes, 0, reinterpret(Dec64, Int64(70000))),
+                ("union timestamp", unionbytes, 8n, ns(1)),
+                ("unknown-label run-end timestamp", reebytes, 8n, ns(1)),
+                ("registered fromarrow union", liftedbytes, 224n, lifted[1]),
+                ("nested fixed-size-list identity", fslbytes, fslfloor, fslexpected),
+            )
+                table = streamread(bytes, typemax(Int64))
+                @test isequal(first(table.x), first_expected)
+                charged = charge(bytes)
+                @test charged > floor
+                # The charge is the security bound: a cap below it refuses,
+                # and the exact charge admits the read.
+                @test_throws Arrow.AllocationLimitError streamread(bytes, charged - 1)
+                streamread(bytes, charged)
+                @static if VERSION >= v"1.12"
+                    # Warmed, the read's true allocation stays within its
+                    # charge (boxing differs on older runtimes, so the
+                    # allocation pin runs on the tested-current one). The
+                    # input copy `streamread` makes is not the reader's.
+                    streamread(bytes, charged)
+                    GC.gc()
+                    allocated = @allocated streamread(bytes, charged)
+                    @test allocated <= charged + sizeof(bytes) + 200_000
+                end
+            end
+        end
+    end
+end
+
+end # module
diff --git a/test/old_zdt.arrow b/test/old_zdt.arrow
deleted file mode 100644
index b8e55ba8..00000000
Binary files a/test/old_zdt.arrow and /dev/null differ
diff --git a/test/polars_tests.jl b/test/polars_tests.jl
new file mode 100644
index 00000000..884820e7
--- /dev/null
+++ b/test/polars_tests.jl
@@ -0,0 +1,98 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Files written by Polars (frozen bytes; regenerate with
+# `python test/support/generate_polars_fixtures.py`).
+
+using Test, Arrow, Tables, Dates, DataDecimals, Durations
+
+const POLARS_FIXTURES = joinpath(@__DIR__, "fixtures-polars")
+
+struct PolarsBytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::PolarsBytesSource) = length(s.data)
+Arrow.readrange(s::PolarsBytesSource, off, len) = s.data[(off + 1):(off + len)]
+
+const POLARS_EXPECTED = (
+    i=[1, 2, missing],
+    f=[1.5, missing, 3.0],
+    s=["a", missing, "a much longer string value"],
+    b=[true, false, missing],
+    d=[Date(2024, 1, 1), missing, Date(2024, 1, 3)],
+    ts=[
+        Durations.Timestamp{Microsecond}(DateTime(2024, 1, 1, 12)),
+        missing,
+        Durations.Timestamp{Microsecond}(DateTime(2024, 1, 3)),
+    ],
+    dur=[Microsecond(5_000_000), missing, Microsecond(86_400_000_000)],
+    t=[Time(1, 2, 3), missing, Time(23, 59)],
+    dec=[
+        reinterpret(Decimal{10,2,Int128}, Int128(125)),
+        missing,
+        reinterpret(Decimal{10,2,Int128}, Int128(-350)),
+    ],
+    cat=["x", "y", "x"],
+    l=[[1, 2], missing, Int[]],
+    bin=[UInt8[0x00, 0x01], missing, Vector{UInt8}("xyz")],
+)
+
+function polars_matches(t)
+    Tables.columnnames(t) == collect(keys(POLARS_EXPECTED)) || return false
+    for (nm, want) in pairs(POLARS_EXPECTED)
+        col = Tables.getcolumn(t, nm)
+        length(col) == length(want) || return false
+        all(isequal(col[k], want[k]) for k in eachindex(want)) || return false
+    end
+    return true
+end
+
+@testset "Polars IPC files" begin
+    # Polars writes the file format's leading Schema message as a bare
+    # FlatBuffer; the footer carries the schema every reader uses.
+    for name in ("default", "lz4", "zstd")
+        path = joinpath(POLARS_FIXTURES, "$name.arrowbytes")
+        bytes = read(path)
+        @test bytes[9:12] != fill(0xff, 4)
+        @test polars_matches(Arrow.Table(path))
+        @test polars_matches(Arrow.Table(path; mmap=false))
+        @test polars_matches(Arrow.Table(bytes))
+        @test polars_matches(open(io -> Arrow.Table(io), path))
+        @test polars_matches(only(collect(Arrow.Stream(path))))
+        scanned =
+            Arrow.Table(PolarsBytesSource(bytes); scan=Tables.Scan(select=(:s, :dec, :l)))
+        @test isequal(collect(scanned.s), POLARS_EXPECTED.s)
+        @test isequal(collect(scanned.dec), POLARS_EXPECTED.dec)
+    end
+    @test polars_matches(Arrow.Table(joinpath(POLARS_FIXTURES, "stream.arrowbytes")))
+
+    # Polars' 128-bit integers (non-standard Int bitWidth 128).
+    t = Arrow.Table(joinpath(POLARS_FIXTURES, "int128.arrowbytes"))
+    @test eltype(t.i128) == Union{Missing,Int128}
+    @test isequal(collect(t.i128), [1, -Int128(2)^100, missing])
+    @test eltype(t.u128) == Union{Missing,UInt128}
+    @test isequal(collect(t.u128), [UInt128(2)^127 + 5, UInt128(0), missing])
+    # They rewrite, from the table or as bare columns, as a fresh Int128 column
+    # writes: fixed-size binary plus the JuliaLang.(U)Int128 label, which
+    # pyarrow reads (it refuses Int bitWidth 128).
+    for src in (t, (; i128=t.i128, u128=t.u128))
+        back = Arrow.Table(Arrow.tobuffer(src))
+        @test isequal(back.i128, t.i128) && isequal(back.u128, t.u128)
+        fields = getfield(back, :schema).fields
+        @test all(f -> f.type == Arrow.ArrowCore.FixedSizeBinaryType(16), fields)
+        @test [Dict(f.metadata)["ARROW:extension:name"] for f in fields] == ["JuliaLang.Int128", "JuliaLang.UInt128"]
+    end
+end
diff --git a/test/property_tests.jl b/test/property_tests.jl
new file mode 100644
index 00000000..4a90419b
--- /dev/null
+++ b/test/property_tests.jl
@@ -0,0 +1,267 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+# Seeded end-to-end properties over the public IPC read/write paths, driven
+# by the SeededFuzz generators; included from runtests.jl.
+
+module PropertyTests
+
+using Arrow
+using Test
+
+include(joinpath(@__DIR__, "support", "SeededFuzz.jl"))
+import .SeededFuzz
+
+const SEED = SeededFuzz.DEFAULT_SEED
+# CI runs every generated case on one job and one case in n on the others:
+# ARROW_PROPERTY_CASES is "k/n" (case indices k + 1 modulo n); unset or "all"
+# runs every case.
+const SAMPLE = let spec = get(ENV, "ARROW_PROPERTY_CASES", "all")
+    k, n = spec == "all" ? (0, 1) : parse.(Int, split(spec, "/"))
+    (mod(k, n), n)
+end
+
+@testset "public IPC properties (seed=$(string(SEED; base=16)))" begin
+    @testset "fuzz failure artifacts are complete and shell-safe" begin
+        @test SeededFuzz._REPLAY_SCRIPT == "sh ./replay.sh /path/to/Arrow.jl"
+        artifact = "reproductions/space and 'quote'\n`literal`.arrowbytes"
+        @test SeededFuzz._shellquote("a b'c\n`d`") == "'a b'\"'\"'c\n`d`'"
+        entry = SeededFuzz.MutationCorpus(:fixture, false, UInt8[])
+        text = SeededFuzz._mutation_repro_text(
+            SEED,
+            UInt64(0x1234),
+            7,
+            entry,
+            :stream_full,
+            "flip[1]=0x01",
+            artifact,
+            "failure details",
+        )
+        for required in (
+            "julia_version=",
+            "source_revision=",
+            "master_seed=",
+            "case_seed=",
+            "index=7",
+            "corpus=fixture",
+            "lane=stream_full",
+            "recipe=flip[1]=0x01",
+            "replay_generated=$(SeededFuzz._REPLAY_SCRIPT)",
+            "replay_bytes=$(SeededFuzz._REPLAY_SCRIPT)",
+            "--mutation-index 7 --skip-layouts",
+            "--mutation-file $(SeededFuzz._shellquote(basename(artifact)))",
+            "failure details",
+        )
+            @test occursin(required, text)
+        end
+        @test !occursin(dirname(artifact), text)
+
+        caseoptions = SeededFuzz.parse_options([
+            "--case-index",
+            "7",
+            "--cases",
+            "99",
+            "--mutations",
+            "99",
+        ])
+        @test caseoptions.case_index == 7
+        @test caseoptions.mutation_index === nothing
+        @test caseoptions.cases == caseoptions.mutations == 0
+        @test !caseoptions.include_layouts
+        @test !caseoptions.verify_determinism
+        @test caseoptions.determinism_every == 0
+
+        mutationoptions =
+            SeededFuzz.parse_options(["--mutation-index=9", "--determinism-every=256"])
+        @test mutationoptions.case_index === nothing
+        @test mutationoptions.mutation_index == 9
+        @test mutationoptions.cases == mutationoptions.mutations == 0
+        @test !mutationoptions.include_layouts
+        @test mutationoptions.verify_determinism
+        @test mutationoptions.determinism_every == 256
+        @test SeededFuzz._shouldverify(1, 41, 256)
+        @test SeededFuzz._shouldverify(41, 41, 256)
+        @test !SeededFuzz._shouldverify(42, 41, 256)
+        @test SeededFuzz._shouldverify(256, 41, 256)
+
+        outcome = SeededFuzz._classify_mutation(UInt8[], :stream_full)
+        @test outcome.category === :validation
+        @test outcome.error isa Arrow.ValidationError
+
+        base = UInt8[0x00, 0x01, 0xff]
+        for seed = UInt64(1):UInt64(256), operation in SeededFuzz._MUTATION_OPERATIONS
+            mutated, _, _ =
+                SeededFuzz._mutatebytes(base, SeededFuzz.StableRNG(seed), operation)
+            @test mutated != base
+        end
+
+        mktempdir() do dir
+            active = joinpath(dir, "active")
+            mkpath(active)
+            project = joinpath(active, "Project.toml")
+            projecttext = "[deps]\n"
+            manifesttext =
+                "julia_version = \"$(VERSION)\"\n" *
+                "manifest_format = \"2.0\"\n" *
+                "project_hash = \"0000000000000000000000000000000000000000\"\n"
+            write(project, projecttext)
+            write(joinpath(active, "Manifest.toml"), manifesttext)
+            artifact = joinpath(dir, "artifact-original")
+            SeededFuzz._snapshot_environment(artifact, project)
+            moved = joinpath(dir, "artifact-renamed")
+            mv(artifact, moved)
+            @test isfile(joinpath(moved, "environment", "Project.toml"))
+            @test isfile(joinpath(moved, "environment", "Manifest.toml"))
+            @test isfile(joinpath(moved, "replay.sh"))
+            replaytext = read(joinpath(moved, "replay.sh"), String)
+            @test occursin("Pkg.instantiate()", replaytext)
+            restore = read(joinpath(moved, "environment", "RESTORE.txt"), String)
+            @test startswith(restore, "environment_restore=")
+            @test !occursin(dir, restore)
+
+            checkout = joinpath(dir, "checkout")
+            mkpath(joinpath(checkout, "test"))
+            write(joinpath(checkout, "Project.toml"), "old project\n")
+            write(joinpath(checkout, "Manifest.toml"), "old manifest\n")
+            write(joinpath(checkout, "test", "fuzz.jl"), "")
+            if !Sys.iswindows()
+                observedproject = joinpath(dir, "observed-project")
+                observedmanifest = joinpath(dir, "observed-manifest")
+                fakejulia = joinpath(dir, "fake-julia")
+                write(
+                    fakejulia,
+                    "#!/bin/sh\ncp \"\$ARROW_REPLAY_CHECKOUT/Project.toml\" " *
+                    "\"\$ARROW_REPLAY_PROJECT\"\n" *
+                    "cp \"\$ARROW_REPLAY_CHECKOUT/Manifest.toml\" " *
+                    "\"\$ARROW_REPLAY_MANIFEST\"\n" *
+                    "for arg in \"\$@\"; do\n" *
+                    "    [ \"\$arg\" = -e ] && exit 0\n" *
+                    "done\n" *
+                    "exit \"\${ARROW_REPLAY_EXIT:-0}\"\n",
+                )
+                chmod(fakejulia, 0o700)
+                replaycommand = Cmd([
+                    "sh",
+                    joinpath(moved, "replay.sh"),
+                    checkout,
+                    "--cases",
+                    "0",
+                    "--mutations",
+                    "0",
+                    "--skip-layouts",
+                ])
+                command = addenv(
+                    replaycommand,
+                    "JULIA" => fakejulia,
+                    "ARROW_REPLAY_CHECKOUT" => checkout,
+                    "ARROW_REPLAY_PROJECT" => observedproject,
+                    "ARROW_REPLAY_MANIFEST" => observedmanifest,
+                )
+                run(command)
+                @test read(observedproject, String) == projecttext
+                @test read(observedmanifest, String) == manifesttext
+                @test read(joinpath(checkout, "Project.toml"), String) == "old project\n"
+                @test read(joinpath(checkout, "Manifest.toml"), String) == "old manifest\n"
+                failed = run(addenv(command, "ARROW_REPLAY_EXIT" => "7"); wait=false)
+                wait(failed)
+                @test failed.exitcode == 7
+                @test read(joinpath(checkout, "Project.toml"), String) == "old project\n"
+                @test read(joinpath(checkout, "Manifest.toml"), String) == "old manifest\n"
+            end
+            SeededFuzz._save_active_repro(moved, :mutation, "active coordinate"; bytes=base)
+            @test read(SeededFuzz._active_repro_path(moved, :mutation, "txt"), String) ==
+                  "active coordinate"
+            @test read(SeededFuzz._active_repro_path(moved, :mutation, "arrowbytes")) ==
+                  base
+            SeededFuzz._clear_active_repro(moved, :mutation)
+            @test sort(readdir(moved)) == ["environment", "replay.sh"]
+        end
+    end
+
+    @testset "declared struct child types survive empty and all-missing values" begin
+        Row = @NamedTuple{x::Int16, label::Union{Missing,String}}
+        for rows in (Row[], Row[(x=1, label=missing), (x=2, label=missing)])
+            io = IOBuffer()
+            Arrow.write(io, (structs=rows,); file=false)
+            bytes = take!(io)
+            stream = Arrow.readstream(bytes)
+            children = stream.schema.fields[1].children
+            @test children[1].type == Arrow.AC.IntType(16, true)
+            @test !children[1].nullable
+            @test children[2].type == Arrow.AC.Utf8Type(false)
+            @test children[2].nullable
+            table = Arrow.Table(bytes)
+            @test isequal(collect(table.structs), rows)
+        end
+
+        EmptyRow = NamedTuple{(),Tuple{}}
+        for rows in (EmptyRow[], EmptyRow[(;), (;)])
+            io = IOBuffer()
+            Arrow.write(io, (structs=rows,); file=false)
+            bytes = take!(io)
+            field = Arrow.readstream(bytes).schema.fields[1]
+            @test field.type isa Arrow.AC.StructType
+            @test isempty(field.children)
+            @test Arrow.Table(bytes).structs == rows
+        end
+    end
+
+    @testset "one deterministic PR suite" begin
+        summary = SeededFuzz.run_pr_suite(; seed=SEED, sample=SAMPLE)
+        differential = summary.differential
+        cases = length((1 + first(SAMPLE)):last(SAMPLE):SeededFuzz.PR_CASES)
+        @test differential.cases == cases
+        @test differential.variants == 6 * cases
+        @test differential.rewrites == 6 * cases
+        @test differential.scanchecks == 54 * cases
+        @test differential.layoutchecks == 48
+        @test Set([
+            :generated_differential,
+            :arrowtypes_extension,
+            :arrowtypes_struct_extension,
+            :map,
+            :map_sorted,
+            :dense_union,
+            :sparse_union,
+            :binary,
+            :large_binary,
+            :utf8_view,
+            :binary_view,
+            :fixed_size_binary,
+            :fixed_size_list,
+            :date_units,
+            :time_units,
+            :timestamp_units,
+            :duration_units,
+            :run_end_encoded,
+            :nullable_struct_parent,
+            :retained_rewrite,
+        ]) ⊆ differential.coverage
+
+        mutations = summary.mutations
+        @test mutations.mutations == SeededFuzz.PR_MUTATIONS
+        @test sum(values(mutations.counts)) == SeededFuzz.PR_MUTATIONS
+        @test mutations.counts[:validation] + mutations.counts[:allocation_limit] > 0
+        @test length(mutations.routecounts) == 38
+        @test mutations.determinismchecks == SeededFuzz.PR_MUTATIONS
+        @test Set(keys(mutations.operationcounts)) ==
+              Set((:flip, :set, :delete, :insert, :truncate))
+        @test SeededFuzz.case_fingerprint(SEED, 17) == UInt64(0x2253_fcc7_c2ac_cadb)
+    end
+end
+
+end # module PropertyTests
diff --git a/test/pyarrow_roundtrip.jl b/test/pyarrow_roundtrip.jl
deleted file mode 100644
index b1b32dab..00000000
--- a/test/pyarrow_roundtrip.jl
+++ /dev/null
@@ -1,76 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-ENV["PYTHON"] = "python3"
-import PyCall
-pa = PyCall.pyimport("pyarrow")
-include(joinpath(dirname(pathof(Arrow)), "../test/testtables.jl"))
-
-for (nm, t, writekw, readkw, extratests) in testtables
-    nm == "unions" && continue
-    @testset "pyarrow roundtrip: $nm" begin
-        io = IOBuffer()
-        Arrow.write(io, t; writekw...)
-        seekstart(io)
-        buf = PyCall.pybytes(take!(io))
-        reader = pa.ipc.open_stream(buf)
-        sink = pa.BufferOutputStream()
-        writer = pa.ipc.new_stream(sink, reader.schema)
-        for batch in reader
-            writer.write_batch(batch)
-        end
-        writer.close()
-        buf = sink.getvalue()
-        jbytes = copy(reinterpret(UInt8, buf))
-        tt = Arrow.Table(jbytes)
-    end
-    @testset "pyarrow roundtrip w/ compression: $nm" begin
-        io = IOBuffer()
-        Arrow.write(io, t; compress=((:lz4, :zstd)[rand(1:2)]), writekw...)
-        seekstart(io)
-        buf = PyCall.pybytes(take!(io))
-        reader = pa.ipc.open_stream(buf)
-        sink = pa.BufferOutputStream()
-        writer = pa.ipc.new_stream(sink, reader.schema)
-        for batch in reader
-            writer.write_batch(batch)
-        end
-        writer.close()
-        buf = sink.getvalue()
-        jbytes = copy(reinterpret(UInt8, buf))
-        tt = Arrow.Table(jbytes)
-    end
-end
-
-f1 = pa.field("f1", pa.float64(), true)
-f2 = pa.field("f2", pa.int64(), false)
-fu = pa.field("col1", pa.union([f1, f2], "dense"))
-sch = pa.schema([fu])
-
-xs = pa.array([2.0, 4.0, PyCall.pynothing[]], type=pa.float64())
-ys = pa.array([1, 3], type=pa.int64())
-types = pa.array([0, 1, 0, 1, 1], type=pa.int8())
-offsets = pa.array([0, 0, 1, 1, 2], type=pa.int32())
-union_arr = pa.UnionArray.from_dense(types, offsets, [xs, ys])
-data = [union_arr]
-batch = pa.record_batch(data, names=["col1"])
-sink = pa.BufferOutputStream()
-writer = pa.ipc.new_stream(sink, batch.schema)
-writer.write_batch(batch)
-writer.close()
-buf = sink.getvalue()
-jbytes = copy(reinterpret(UInt8, buf))
-tt = Arrow.Table(jbytes)
diff --git a/test/ranged_scan_budget_tests.jl b/test/ranged_scan_budget_tests.jl
new file mode 100644
index 00000000..a3622c9d
--- /dev/null
+++ b/test/ranged_scan_budget_tests.jl
@@ -0,0 +1,41 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module RangedScanBudgetTests
+
+using Test, Arrow
+
+struct BytesSource <: Arrow.AbstractArrowSource
+    bytes::Vector{UInt8}
+end
+Arrow.sourcelength(s::BytesSource) = length(s.bytes)
+Arrow.readrange(s::BytesSource, offset, len) = s.bytes[(offset + 1):(offset + len)]
+
+@testset "filtered range scans budget many batches linearly" begin
+    for compress in (nothing, :lz4, :zstd)
+        io = IOBuffer()
+        Arrow.Writer(io; file=true, compress) do writer
+            for i = 1:3000
+                Arrow.write(writer, (x=Int32[i],))
+            end
+        end
+        source = Arrow.SourceFile(BytesSource(take!(io)))
+        table = Arrow.Table(source; filter=Arrow.col(:x) < 0, limit=1)
+        @test isempty(table.x)
+    end
+end
+
+end
diff --git a/test/ranged_scan_tests.jl b/test/ranged_scan_tests.jl
new file mode 100644
index 00000000..0e094852
--- /dev/null
+++ b/test/ranged_scan_tests.jl
@@ -0,0 +1,230 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module RangedScanTests
+
+using Test, Arrow, Tables, Dates
+
+struct MeteredSource <: Arrow.AbstractArrowSource
+    bytes::Vector{UInt8}
+    fetched::Base.RefValue{Int}
+    requests::Base.RefValue{Int}
+end
+MeteredSource(bytes, fetched) = MeteredSource(bytes, fetched, Ref(0))
+Arrow.sourcelength(s::MeteredSource) = length(s.bytes)
+function Arrow.readrange(s::MeteredSource, offset, len)
+    s.fetched[] += len
+    s.requests[] += 1
+    return s.bytes[(offset + 1):(offset + len)]
+end
+
+@testset "filtered range scans stop fetching at their limit" begin
+    for compress in (nothing, :lz4, :zstd)
+        io = IOBuffer()
+        Arrow.Writer(io; file=true, compress) do writer
+            for batch = 1:32
+                Arrow.write(
+                    writer,
+                    (
+                        id=collect(((batch - 1) * 2048 + 1):(batch * 2048)),
+                        category=Arrow.DictEncode(fill("batch-$batch", 2048)),
+                    ),
+                )
+            end
+        end
+        bytes = take!(io)
+        for limit in (0, 1)
+            fetched = Ref(0)
+            source = Arrow.SourceFile(MeteredSource(bytes, fetched); tailbytes=1024)
+            table = Arrow.Table(source; filter=Arrow.col(:id) > 0, limit)
+            @test collect(table.id) == collect(1:limit)
+            @test collect(table.category) == fill("batch-1", limit)
+            @test fetched[] < length(bytes) ÷ 2
+        end
+        source = Arrow.SourceFile(MeteredSource(bytes, Ref(0)); tailbytes=1024)
+        table = Arrow.Table(
+            source;
+            scan=Tables.Scan(filter=Arrow.col(:id) > 2048, offset=2050, limit=5),
+        )
+        @test collect(table.id) == collect(4099:4103)
+        @test collect(table.category) == fill("batch-3", 5)
+    end
+end
+
+@testset "filters on converted columns fetch only their columns" begin
+    n = 20_000
+    io = IOBuffer()
+    Arrow.Writer(io; file=true) do writer
+        for batch = 1:4
+            Arrow.write(
+                writer,
+                (
+                    x=collect(((batch - 1) * n + 1):(batch * n)),
+                    t=[Time(0) + Second(i % 86_400) for i = 1:n],
+                    k=[Symbol(:key, i % 7) for i = 1:n],
+                    pad=fill(repeat("p", 64), n),
+                ),
+            )
+        end
+    end
+    bytes = take!(io)
+    full = Arrow.Table(copy(bytes))
+    for filter in (
+        Arrow.colcmp(>=, Arrow.col(:t), Time(5, 30)),
+        Arrow.colcmp(==, Arrow.col(:t), Time(0, 0, 7)),
+        Arrow.colin(Arrow.col(:t), (Time(0, 0, 7), Time(0, 0, 9))),
+        Arrow.colcmp(==, Arrow.col(:k), :key3),
+    )
+        fetched = Ref(0)
+        source = Arrow.SourceFile(MeteredSource(bytes, fetched); tailbytes=1024, gapbytes=0)
+        got = Arrow.Table(source; select=[:x], filter)
+        want = Tables.scan(full, Tables.Scan(select=(:x,), filter=filter))
+        @test collect(got.x) == collect(want.x)
+        @test fetched[] < length(bytes) ÷ 4
+    end
+end
+
+@testset "a select through a source builds what a mapped read builds" begin
+    n = 20_000
+    io = IOBuffer()
+    Arrow.Writer(io; file=true) do writer
+        for batch = 1:4
+            Arrow.write(
+                writer,
+                (
+                    x=collect(((batch - 1) * n + 1):(batch * n)),
+                    s=[string("value number ", i) for i = 1:n],
+                    pad=fill(repeat("p", 64), n),
+                ),
+            )
+        end
+    end
+    bytes = take!(io)
+    path = tempname()
+    write(path, bytes)
+    fetched = Ref(0)
+    mapped() = Arrow.Table(path; select=[:x, :s])
+    ranged() = Arrow.Table(Arrow.SourceFile(MeteredSource(bytes, fetched)); select=[:x, :s])
+    m, r = mapped(), ranged()
+    @test typeof(m.x) == typeof(r.x) && typeof(m.s) == typeof(r.s)
+    @test m.x == r.x && m.s == r.s
+    # Beyond the bytes the source hands over, a ranged read allocates what a
+    # mapped read does, plus a few KiB per batch of range planning.
+    mappedbytes = @allocated mapped()
+    fetched[] = 0
+    rangedbytes = @allocated ranged()
+    @test rangedbytes - fetched[] <= mappedbytes + 256 * 1024
+    rm(path)
+end
+
+@testset "a select through a source keeps only the bytes its columns use" begin
+    io = IOBuffer()
+    Arrow.Writer(io; file=true) do writer
+        for batch = 1:200
+            Arrow.write(
+                writer,
+                (
+                    i1=collect((1000batch - 999):(1000batch)),
+                    s1=fill(repeat("s", 40), 1000),
+                    pad=fill(repeat("p", 60), 1000),
+                ),
+            )
+        end
+    end
+    bytes = take!(io)
+    mapped = Arrow.Table(copy(bytes))
+    # One small column of the object keeps about its own bytes.
+    t = Arrow.Table(MeteredSource(bytes, Ref(0)); select=[:i1])
+    @test t.i1 == mapped.i1
+    @test Base.summarysize(t.i1) < 1.5 * 8 * 200_000 < length(bytes) / 8
+    # Columns that fill most of what was fetched view it in place.
+    fetched = Ref(0)
+    ranged() = Arrow.Table(MeteredSource(bytes, fetched); select=[:s1, :pad])
+    t = ranged()
+    @test t.s1 == mapped.s1 && t.pad == mapped.pad
+    fetched[] = 0
+    copied = @allocated(ranged()) - fetched[]
+    @test copied < length(bytes) / 4
+end
+
+@testset "a Stream over a source fetches only the columns it reads" begin
+    n = 20_000
+    io = IOBuffer()
+    Arrow.Writer(io; file=true) do writer
+        for batch = 1:4
+            Arrow.write(
+                writer,
+                (
+                    x=collect(((batch - 1) * n + 1):(batch * n)),
+                    pad=fill(repeat("p", 64), n),
+                ),
+            )
+        end
+    end
+    bytes = take!(io)
+    for (kw, want) in (
+        ((select=[:x],), collect(1:(4n))),
+        ((select=[:x], filter=Arrow.col(:x) > 3n), collect((3n + 1):(4n))),
+    )
+        fetched = Ref(0)
+        stream = Arrow.Stream(Arrow.SourceFile(MeteredSource(bytes, fetched)); kw...)
+        @test reduce(vcat, [collect(t.x) for t in stream]) == want
+        @test fetched[] < length(bytes) ÷ 3
+    end
+    # A stream that reads every column reads whole blocks.
+    fetched = Ref(0)
+    stream = Arrow.Stream(Arrow.SourceFile(MeteredSource(bytes, fetched)))
+    @test sum(t -> length(t.x), stream) == 4n
+    @test fetched[] >= length(bytes) - 1024
+end
+
+@testset "a read that fetches many ranges at once finds each of them" begin
+    io = IOBuffer()
+    Arrow.Writer(io; file=true) do writer
+        for batch = 1:64
+            Arrow.write(writer, (x=collect((100batch - 99):(100batch)), y=fill(batch, 100)))
+        end
+    end
+    bytes = take!(io)
+    want = Arrow.Table(bytes; select=[:x], filter=Arrow.col(:y) > 8)
+    for gapbytes in (0, 64)
+        source = Arrow.SourceFile(MeteredSource(bytes, Ref(0)); gapbytes)
+        got = Arrow.Table(source; select=[:x], filter=Arrow.col(:y) > 8)
+        @test got.x == want.x == 801:6400
+    end
+end
+
+@testset "small record batches cost few requests" begin
+    io = IOBuffer()
+    Arrow.Writer(io; file=true) do writer
+        for batch = 1:2000
+            Arrow.write(writer, (x=collect((10batch - 9):(10batch)), y=fill(batch, 10)))
+        end
+    end
+    bytes = take!(io)
+    # A Stream reads small batches whole, many to a request.
+    source = MeteredSource(bytes, Ref(0))
+    @test sum(t -> sum(t.x), Arrow.Stream(source; select=[:x])) == sum(1:20_000)
+    @test source.requests[] <= 2000 ÷ 100
+    # A filtered window fetches a small batch's columns in one request.
+    source = MeteredSource(bytes, Ref(0))
+    t = Arrow.Table(source; select=[:x], filter=Arrow.col(:y) > 0, limit=10^9)
+    @test t.x == 1:20_000
+    metadata = 2000
+    @test source.requests[] <= metadata + 2000 + 2
+end
+
+end
diff --git a/test/reject_reason_trimmed.arrow b/test/reject_reason_trimmed.arrow
deleted file mode 100644
index b6ac1439..00000000
Binary files a/test/reject_reason_trimmed.arrow and /dev/null differ
diff --git a/test/rewrite_regressions.jl b/test/rewrite_regressions.jl
new file mode 100644
index 00000000..790bd067
--- /dev/null
+++ b/test/rewrite_regressions.jl
@@ -0,0 +1,750 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Regressions in read-then-rewrite fidelity: bytes read through Arrow.Table
+# and re-emitted with Arrow.write must preserve names, descriptors, dictionary
+# order, metadata order, and null typing. Plus reader-budget accounting.
+
+module RewriteRegressions
+
+using Test
+using Dates
+using Tables
+import DataAPI
+import CategoricalArrays
+using Arrow
+using DataStrings
+using DataStrings: StringVector, StringPayload, BytesVector, DataBytes
+
+const AC = Arrow.ArrowCore
+
+struct _BytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+end
+Arrow.sourcelength(s::_BytesSource) = length(s.data)
+Arrow.readrange(s::_BytesSource, off, len) = s.data[(off + 1):(off + len)]
+
+function _rewrite(bytes; file=false)
+    io = IOBuffer()
+    Arrow.write(io, Arrow.Table(bytes); file=file)
+    return take!(io)
+end
+
+function _dictbytes(poolfield, pooldata, indices; ordered=false, name="d")
+    indextype = AC.IntType(8, true)
+    t = AC.DictionaryType(indextype, poolfield.type, ordered)
+    data = AC.ArrayData(
+        t,
+        length(indices),
+        [AC.BufferSlice(), AC._databuffer(collect(Int8, indices))];
+        dictionary=pooldata,
+        nullcount=0,
+    )
+    field =
+        AC.Field(name, t; nullable=false, children=collect(AC.Field, poolfield.children))
+    schema = AC.Schema([field])
+    return Arrow.writestream(schema, [AC.RecordBatch(schema, [data], length(indices))])
+end
+
+function _fixedlistnullbytes(listsize::Int; file::Bool)
+    childtype = AC.NullType()
+    childfield = AC.Field("item", childtype; nullable=true)
+    childdata = AC.ArrayData(childtype, listsize, AC.BufferSlice[]; nullcount=listsize)
+    listtype = AC.FixedSizeListType(listsize)
+    field = AC.Field("x", listtype; nullable=false, children=[childfield])
+    data = AC.ArrayData(listtype, 1, [AC.BufferSlice()]; children=[childdata], nullcount=0)
+    schema = AC.Schema([field])
+    batch = AC.RecordBatch(schema, [data], 1)
+    return file ? Arrow.writefile(schema, [batch]) : Arrow.writestream(schema, [batch])
+end
+
+# A run-end column of 4 runs over `n` rows.
+function _reebytes(n)
+    runfield, runs = AC.fromjulia("run_ends", Int32[n ÷ 4, n ÷ 2, 3n ÷ 4, n])
+    _, values = AC.fromjulia("values", Int64[1, 2, 3, 4])
+    t = AC.RunEndEncodedType()
+    field = AC.Field(
+        "r",
+        t;
+        nullable=false,
+        children=[runfield, AC.Field("values", AC.IntType(64, true); nullable=false)],
+    )
+    data = AC.ArrayData(t, n, AC.BufferSlice[]; children=[runs, values], nullcount=0)
+    schema = AC.Schema([field])
+    return Arrow.writestream(schema, [AC.RecordBatch(schema, [data], n)])
+end
+_rewriteallocations(t) = @allocated Arrow.write(IOBuffer(), t)
+
+@testset "facade rewrite correctness regressions" begin
+    @testset "repeated names read as x, x_1, as CSV.jl names them" begin
+        f1, d1 = AC.fromjulia("x", Int64[1, 2])
+        f2, d2 = AC.fromjulia("x", Int64[10, 20])
+        f3, d3 = AC.fromjulia("x_1", Int64[5, 6])
+        f1 = AC.Field("x", f1.type; nullable=false, metadata=["slot" => "first"])
+        f2 = AC.Field("x", f2.type; nullable=false, metadata=["slot" => "second"])
+        schema = AC.Schema([f1, f2, f3])
+        batch = AC.RecordBatch(schema, [d1, d2, d3], 2)
+        for bytes in (Arrow.writestream(schema, [batch]), Arrow.writefile(schema, [batch]))
+            table = Arrow.Table(bytes)
+            # A suffix never takes a name the file already has.
+            @test Tables.columnnames(table) == [:x, :x_2, :x_1]
+            @test table.x == [1, 2]
+            @test table.x_2 == [10, 20]
+            @test table.x_1 == [5, 6]
+            @test DataAPI.colmetadata(table, :x, "slot") == "first"
+            @test DataAPI.colmetadata(table, :x_2, "slot") == "second"
+            # Selections, filters, and streams see the same names.
+            sel = Arrow.Table(bytes; select=[:x_2], filter=Arrow.col(:x) > 1)
+            @test Tables.columnnames(sel) == [:x_2] && sel.x_2 == [20]
+            for b in Arrow.Stream(bytes)
+                @test Tables.columnnames(b) == [:x, :x_2, :x_1]
+            end
+            @test Tables.columnnames(Arrow.Stream(bytes)) == [:x, :x_2, :x_1]
+            # A rewrite writes the unique names, each column's metadata kept.
+            rewritten = Arrow.readstream(_rewrite(bytes))
+            @test [f.name for f in rewritten.schema.fields] == ["x", "x_2", "x_1"]
+            back = rewritten.batches[1]
+            @test AC.materialize(rewritten.schema.fields[2], back.columns[2]) == [10, 20]
+            @test collect(rewritten.schema.fields[1].metadata) == ["slot" => "first"]
+            @test collect(rewritten.schema.fields[2].metadata) == ["slot" => "second"]
+        end
+    end
+
+    @testset "NullType is inferred and retained" begin
+        io = IOBuffer()
+        Arrow.write(io, (n=Missing[missing, missing],); file=false)
+        fresh = take!(io)
+        @test Arrow.readstream(fresh).schema.fields[1].type isa AC.NullType
+        @test isequal(Arrow.Table(fresh).n, Missing[missing, missing])
+        retained = _rewrite(fresh)
+        @test Arrow.readstream(retained).schema.fields[1].type isa AC.NullType
+        @test_throws ArgumentError Arrow.write(IOBuffer(), (n=Union{}[],); file=false)
+    end
+
+    @testset "retained dictionaries keep value descriptors and order" begin
+        datefield, datedata = Arrow._constructcolumn(
+            Symbol("date-values"),
+            Date[Date(2024, 1, 1), Date(2024, 1, 2)],
+        )
+        datebytes = _dictbytes(datefield, datedata, Int8[1, 0])
+        dateback = Arrow.readstream(_rewrite(datebytes))
+        datetype = dateback.schema.fields[1].type::AC.DictionaryType
+        @test datetype.valuetype isa AC.DateType
+        @test Arrow.Table(_rewrite(datebytes)).d == [Date(2024, 1, 2), Date(2024, 1, 1)]
+
+        listfield, listdata = AC.fromjulia("list-values", [Int64[1], Int64[2, 3]])
+        listbytes = _dictbytes(listfield, listdata, Int8[1, 0])
+        listback = Arrow.readstream(_rewrite(listbytes))
+        listtype = listback.schema.fields[1].type::AC.DictionaryType
+        @test listtype.valuetype isa AC.ListType
+        @test isequal(Arrow.Table(_rewrite(listbytes)).d, [[2, 3], [1]])
+
+        poolfield, pooldata = AC.fromjulia("ordered-values", ["a", "b", "unused"])
+        orderedbytes = _dictbytes(poolfield, pooldata, Int8[1, 0]; ordered=true)
+        orderedback = Arrow.readstream(_rewrite(orderedbytes))
+        field = orderedback.schema.fields[1]
+        batch = orderedback.batches[1]
+        @test (field.type::AC.DictionaryType).ordered
+        valuefield = AC.dictvaluefield(field, field.type)
+        @test AC.materialize(valuefield, batch.columns[1].dictionary) ==
+              ["a", "b", "unused"]
+        @test AC.materialize(field, batch.columns[1]) == ["b", "a"]
+
+        nullfield, nulldata =
+            AC.fromjulia("nullable-values", Union{Missing,String}["a", missing])
+        nullbytes = _dictbytes(nullfield, nulldata, Int8[1, 0])
+        nullback = Arrow.readstream(_rewrite(nullbytes))
+        @test !nullback.schema.fields[1].nullable
+        @test isequal(
+            AC.materialize(nullback.schema.fields[1], nullback.batches[1].columns[1]),
+            [missing, "a"],
+        )
+    end
+
+    @testset "ordered dictionaries keep their order and flag through rewrites" begin
+        sizes = CategoricalArrays.categorical(
+            ["small", "large", "medium", "small"];
+            ordered=true,
+            levels=["small", "medium", "large"],
+        )
+        order = ["small", "medium", "large"]
+        isordereddict(t) = (getfield(t, :schema).fields[1].type::AC.DictionaryType).ordered
+        one = Arrow.Table(Arrow.tobuffer((; sizes)))
+        two = Arrow.Table(
+            Arrow.tobuffer(Tables.partitioner([(; sizes=sizes[1:2]), (; sizes)])),
+        )
+        @test two.sizes isa Arrow.ChainedVector
+        for t in (one, two)
+            @test isordereddict(t)
+            @test DataAPI.levels(t.sizes) == order
+            @test CategoricalArrays.isordered(t.sizes)
+            # The table, a bare column (as DataFrame(t; copycols=false) holds
+            # it), and a copy of the table all write an ordered dictionary.
+            for src in (t, (; sizes=t.sizes), copy(t))
+                back = Arrow.Table(Arrow.tobuffer(src))
+                @test isordereddict(back)
+                @test DataAPI.levels(back.sizes) == order
+            end
+        end
+        plain =
+            Arrow.Table(Arrow.tobuffer((; sizes=CategoricalArrays.categorical(["b", "a"]))))
+        @test !CategoricalArrays.isordered(plain.sizes)
+        @test !isordereddict(Arrow.Table(Arrow.tobuffer((; sizes=plain.sizes))))
+    end
+
+    @testset "scan results retain dictionary pools" begin
+        # An ordered dictionary rewrites only with its category pool. A scan
+        # keeps the pool, unused categories included, as a full read does.
+        poolfield, pooldata = AC.fromjulia("ordered-values", ["a", "b", "unused"])
+        t = AC.DictionaryType(AC.IntType(8, true), poolfield.type, true)
+        ddata = AC.ArrayData(
+            t,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int8[1, 0])];
+            dictionary=pooldata,
+            nullcount=0,
+        )
+        dfield =
+            AC.Field("d", t; nullable=false, children=collect(AC.Field, poolfield.children))
+        # A Decimal predicate has no storage-domain form: the public fallback.
+        Dec = Arrow.DataDecimals.Decimal64{2}
+        xio = IOBuffer()
+        Arrow.write(xio, (x=[Dec("1.00"), Dec("2.00")],); file=false)
+        xs = Arrow.readstream(take!(xio))
+        schema = AC.Schema([dfield, xs.schema.fields[1]])
+        batch = AC.RecordBatch(schema, [ddata, xs.batches[1].columns[1]], 2)
+        streambytes = Arrow.writestream(schema, [batch])
+        filebytes = Arrow.writefile(schema, [batch])
+        scans = (
+            Tables.Scan(
+                select=(:d => :e,),
+                filter=Tables.colcmp(==, Tables.col(:d), "a"),
+            ) => ["a"],
+            Tables.Scan(select=(:d => :e,), filter=Tables.col(:x) < Dec("2.00")) =>
+                ["b"],
+        )
+        for (scan, want) in scans,
+            source in (streambytes, filebytes, _BytesSource(filebytes))
+
+            got = Arrow.Table(source isa Vector{UInt8} ? copy(source) : source; scan=scan)
+            @test got.e == want
+            io = IOBuffer()
+            Arrow.write(io, got; file=true)
+            back = Arrow.readfile(take!(io))
+            field = back.schema.fields[1]
+            @test (field.type::AC.DictionaryType).ordered
+            pool = back[1].columns[1].dictionary
+            @test AC.materialize(AC.dictvaluefield(field, field.type), pool) ==
+                  ["a", "b", "unused"]
+        end
+    end
+
+    @testset "retained byte and scalar layouts rebuild exactly" begin
+        raw = Vector{UInt8}(codeunits("short-thirteen-byte"))
+        payloads = StringPayload[
+            DataStrings.inline_payload(raw, 1, 5),
+            DataStrings.view_payload(raw, 7, 13, 0, 6),
+        ]
+        strings = StringVector{DataString}(payloads, [raw])
+        io = IOBuffer()
+        Arrow.write(io, (s=strings,); file=false, stringview=true)
+        viewbytes = take!(io)
+        viewback = Arrow.readstream(_rewrite(viewbytes))
+        @test viewback.schema.fields[1].type == AC.ViewType(true)
+        @test Arrow.Table(_rewrite(viewbytes)).s == ["short", "thirteen-byte"]
+
+        binarytype = AC.BinaryType(true)
+        binarydata = AC.ArrayData(
+            binarytype,
+            2,
+            [
+                AC.BufferSlice(),
+                AC._databuffer(Int64[0, 2, 5]),
+                AC._databuffer(UInt8[1, 2, 3, 4, 5]),
+            ],
+            nullcount=0,
+        )
+        binaryfield = AC.Field("b", binarytype; nullable=false)
+        binaryschema = AC.Schema([binaryfield])
+        binarybytes =
+            Arrow.writestream(binaryschema, [AC.RecordBatch(binaryschema, [binarydata], 2)])
+        binaryback = Arrow.readstream(_rewrite(binarybytes))
+        @test binaryback.schema.fields[1].type == binarytype
+        @test isequal(Arrow.Table(_rewrite(binarybytes)).b, [UInt8[1, 2], UInt8[3, 4, 5]])
+
+        decimaltype = AC.DecimalType(10, 2, 64)
+        decimaldata = AC.ArrayData(
+            decimaltype,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int64[123, 456])],
+            nullcount=0,
+        )
+        decimalfield = AC.Field("dec", decimaltype; nullable=false)
+        decimalschema = AC.Schema([decimalfield])
+        decimalbytes = Arrow.writestream(
+            decimalschema,
+            [AC.RecordBatch(decimalschema, [decimaldata], 2)],
+        )
+        decimalback = Arrow.readstream(_rewrite(decimalbytes))
+        @test decimalback.schema.fields[1].type == decimaltype
+        @test Arrow.Table(_rewrite(decimalbytes)).dec ==
+              Arrow.DataDecimals.Decimal{10,2,Int64}.(["1.23", "4.56"])
+    end
+
+    @testset "retained composites rebuild recursively" begin
+        Row = NamedTuple{(:x, :y),Tuple{Int64,Union{Missing,String}}}
+        pool = Row[(x=1, y=missing), (x=2, y=missing)]
+        structfield, structdata = Arrow._constructcolumn(:pool, pool)
+        structbytes = _dictbytes(structfield, structdata, Int8[1, 0])
+        structback = Arrow.readstream(_rewrite(structbytes))
+        dictionaryfield = structback.schema.fields[1]
+        @test (dictionaryfield.type::AC.DictionaryType).valuetype isa AC.StructType
+        @test dictionaryfield.children[2].nullable
+        @test isequal(
+            AC.materialize(dictionaryfield, structback.batches[1].columns[1]),
+            Any[
+                Pair{String,Any}["x" => 2, "y" => missing],
+                Pair{String,Any}["x" => 1, "y" => missing],
+            ],
+        )
+
+        xfield, xdata = AC.fromjulia("x", Int64[0, 0])
+        yfield, ydata = AC.fromjulia("y", Union{Missing,String}[missing, missing])
+        allnullfield =
+            AC.Field("s", AC.StructType(); nullable=true, children=[xfield, yfield])
+        allnulldata = AC.ArrayData(
+            AC.StructType(),
+            2,
+            [AC._bitmapbuffer(Bool[false, false])];
+            children=[xdata, ydata],
+            nullcount=2,
+        )
+        allnullschema = AC.Schema([allnullfield])
+        allnullbytes = Arrow.writestream(
+            allnullschema,
+            [AC.RecordBatch(allnullschema, [allnulldata], 2)],
+        )
+        allnullback = Arrow.readstream(_rewrite(allnullbytes))
+        @test allnullback.schema.fields[1].type isa AC.StructType
+        @test isequal(
+            AC.materialize(allnullback.schema.fields[1], allnullback.batches[1].columns[1]),
+            Missing[missing, missing],
+        )
+
+        keyfield, keydata = AC.fromjulia("key", ["a", "b", "c"])
+        valuefield, valuedata = AC.fromjulia("value", Union{Missing,Int64}[1, missing, 3])
+        entriesfield = AC.Field(
+            "entries",
+            AC.StructType();
+            nullable=false,
+            children=[keyfield, valuefield],
+        )
+        entriesdata = AC.ArrayData(
+            AC.StructType(),
+            3,
+            [AC.BufferSlice()];
+            children=[keydata, valuedata],
+            nullcount=0,
+        )
+        maptype = AC.MapType(true)
+        mapfield = AC.Field("m", maptype; nullable=false, children=[entriesfield])
+        mapdata = AC.ArrayData(
+            maptype,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 2, 3])];
+            children=[entriesdata],
+            nullcount=0,
+        )
+        mapschema = AC.Schema([mapfield])
+        mapbytes = Arrow.writestream(mapschema, [AC.RecordBatch(mapschema, [mapdata], 2)])
+        mapback = Arrow.readstream(_rewrite(mapbytes))
+        @test mapback.schema.fields[1].type == maptype
+        @test isequal(
+            AC.materialize(mapback.schema.fields[1], mapback.batches[1].columns[1]),
+            Any[Any["a" => 1, "b" => missing], Any["c" => 3]],
+        )
+
+        runfield, rundata = AC.fromjulia("run_ends", Int16[2, 4])
+        reevaluefield, reevaluedata =
+            AC.fromjulia("values", Union{Missing,String}["x", missing])
+        reetype = AC.RunEndEncodedType()
+        reefield = AC.Field("r", reetype; nullable=true, children=[runfield, reevaluefield])
+        reedata = AC.ArrayData(
+            reetype,
+            4,
+            AC.BufferSlice[];
+            children=[rundata, reevaluedata],
+            nullcount=0,
+        )
+        reeschema = AC.Schema([reefield])
+        reebytes = Arrow.writestream(reeschema, [AC.RecordBatch(reeschema, [reedata], 4)])
+        reeback = Arrow.readstream(_rewrite(reebytes))
+        @test reeback.schema.fields[1].type isa AC.RunEndEncodedType
+        @test reeback.schema.fields[1].children[1].type == AC.IntType(16, true)
+        @test isequal(
+            AC.materialize(reeback.schema.fields[1], reeback.batches[1].columns[1]),
+            Union{Missing,String}["x", "x", missing, missing],
+        )
+
+        datefield = AC.Field("item", AC.DateType(AC.DAY); nullable=false)
+        datedata = AC.ArrayData(
+            datefield.type,
+            3,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 1, 2])],
+            nullcount=0,
+        )
+        listviewtype = AC.ListViewType(false)
+        listviewfield =
+            AC.Field("dates", listviewtype; nullable=false, children=[datefield])
+        listviewdata = AC.ArrayData(
+            listviewtype,
+            2,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 2]), AC._databuffer(Int32[2, 1])];
+            children=[datedata],
+            nullcount=0,
+        )
+        listviewschema = AC.Schema([listviewfield])
+        listviewbytes = Arrow.writestream(
+            listviewschema,
+            [AC.RecordBatch(listviewschema, [listviewdata], 2)],
+        )
+        listviewback = Arrow.readstream(_rewrite(listviewbytes))
+        @test listviewback.schema.fields[1].type == listviewtype
+        @test isequal(
+            AC.materialize(
+                listviewback.schema.fields[1],
+                listviewback.batches[1].columns[1],
+            ),
+            Any[Any[Int32(0), Int32(1)], Any[Int32(2)]],
+        )
+
+        liststructtype = AC.ListType(true)
+        liststructfield =
+            AC.Field("rows", liststructtype; nullable=false, children=[structfield])
+        liststructdata = AC.ArrayData(
+            liststructtype,
+            1,
+            [AC.BufferSlice(), AC._databuffer(Int64[0, 2])];
+            children=[structdata],
+            nullcount=0,
+        )
+        liststructschema = AC.Schema([liststructfield])
+        liststructbytes = Arrow.writestream(
+            liststructschema,
+            [AC.RecordBatch(liststructschema, [liststructdata], 1)],
+        )
+        liststructback = Arrow.readstream(_rewrite(liststructbytes))
+        @test liststructback.schema.fields[1].type == liststructtype
+        @test liststructback.schema.fields[1].children[1].type isa AC.StructType
+
+        uniontype = AC.UnionType(AC.DenseMode, Int8[0, 1])
+        unionintfield, unionintdata = AC.fromjulia("i", Int64[1])
+        unionstrfield, unionstrdata = AC.fromjulia("s", ["x"])
+        unionfield = AC.Field(
+            "u",
+            uniontype;
+            nullable=false,
+            children=[unionintfield, unionstrfield],
+        )
+        uniondata = AC.ArrayData(
+            uniontype,
+            2,
+            [AC._databuffer(Int8[0, 1]), AC._databuffer(Int32[0, 0])];
+            children=[unionintdata, unionstrdata],
+            nullcount=0,
+        )
+        unionschema = AC.Schema([unionfield])
+        unionbytes =
+            Arrow.writestream(unionschema, [AC.RecordBatch(unionschema, [uniondata], 2)])
+        # Each value goes back to the child of its type, under the same field.
+        unionback = Arrow.readstream(_rewrite(unionbytes))
+        @test Arrow._fieldcontractequal(unionback.schema.fields[1], unionfield)
+        @test isequal(collect(Arrow.Table(_rewrite(unionbytes)).u), [1, "x"])
+    end
+
+    @testset "metadata duplicates and order survive" begin
+        field0, data = AC.fromjulia("x", Int64[1])
+        field = AC.Field(
+            "x",
+            field0.type;
+            nullable=false,
+            metadata=["z" => "one", "a" => "middle", "z" => "two"],
+        )
+        metadata = ["z" => "one", "a" => "middle", "z" => "two"]
+        schema = AC.Schema([field]; metadata=metadata)
+        bytes = Arrow.writestream(schema, [AC.RecordBatch(schema, [data], 1)])
+        decoded = Arrow.readstream(bytes)
+        @test collect(decoded.schema.metadata) == metadata
+        @test collect(decoded.schema.fields[1].metadata) == metadata
+        rewritten = Arrow.readstream(_rewrite(bytes))
+        @test collect(rewritten.schema.metadata) == metadata
+        @test collect(rewritten.schema.fields[1].metadata) == metadata
+    end
+
+    @testset "NUL field names stay Core-only and fail cleanly at the facade" begin
+        field, data = AC.fromjulia("a\0b", Int64[1])
+        schema = AC.Schema([field])
+        streambytes = Arrow.writestream(schema, [AC.RecordBatch(schema, [data], 1)])
+        filebytes = Arrow.writefile(schema, [AC.RecordBatch(schema, [data], 1)])
+        @test Arrow.readstream(streambytes).schema.fields[1].name == "a\0b"
+        @test Arrow.readfile(filebytes).schema.fields[1].name == "a\0b"
+        @test_throws AC.ValidationError Arrow.Table(streambytes)
+        @test_throws AC.ValidationError Arrow.Table(filebytes; scan=Tables.Scan())
+        @test_throws AC.ValidationError first(Arrow.Stream(streambytes))
+        @test_throws AC.ValidationError Arrow.Table(
+            _BytesSource(filebytes);
+            scan=Tables.Scan(),
+        )
+    end
+
+    @testset "reader budget includes public materialization" begin
+        limit = Int64(1_000_000)
+        limits() = Arrow.Limits(max_total_allocated_bytes=limit)
+        listsize = 200_000
+        streambytes = _fixedlistnullbytes(listsize; file=false)
+        filebytes = _fixedlistnullbytes(listsize; file=true)
+        @test length(streambytes) < 1_000
+        @test length(filebytes) < 1_000
+
+        openstream() = Arrow.readstream(copy(streambytes); limits=limits())
+        openfile() = Arrow.readfile(copy(filebytes); limits=limits())
+
+        # The facade reads the row as a view of one owned `Vector{Missing}`,
+        # which stores no elements, so it fits the budget at every entry point.
+        ranged() = Arrow.SourceFile(
+            _BytesSource(copy(filebytes));
+            limits=limits(),
+            tailbytes=32,
+            gapbytes=0,
+        )
+        for t in (
+            Arrow.Table(openstream()),
+            Arrow.Table(openstream(); scan=Tables.Scan(select=(:x,))),
+            Arrow.Table(openfile()),
+            Arrow.Table(openfile(); scan=Tables.Scan(select=(:x,))),
+            first(Arrow.Stream(openstream())),
+            first(Arrow.Stream(openfile())),
+            Arrow.Table(ranged(); scan=Tables.Scan(select=(:x,))),
+        )
+            @test length(t.x) == 1 && length(t.x[1]) == listsize && all(ismissing, t.x[1])
+        end
+
+        largeio = IOBuffer()
+        Arrow.write(largeio, (x=zeros(Int64, 200_000),); file=true)
+        largebytes = take!(largeio)
+        @test length(largebytes) > limit
+        wholesource = Arrow.SourceFile(
+            _BytesSource(largebytes);
+            limits=limits(),
+            tailbytes=32,
+            gapbytes=0,
+        )
+        @test_throws Arrow.AllocationLimitError Arrow.Table(wholesource)
+    end
+
+    @testset "DictEncode pools dedup structurally before construction" begin
+        # Identity-only dedup used to build an O(rows) candidate pool for
+        # identity-distinct (mutable) categories such as Vector{Int} rows.
+        rows = [isodd(i) ? [1, 2] : [3, 4] for i = 1:50_000]
+        pool = Arrow._dictionarypool(rows, nothing)
+        @test length(pool) == 2
+        @test pool == [[1, 2], [3, 4]]
+
+        io = IOBuffer()
+        Arrow.write(io, (v=Arrow.DictEncode(rows),); file=false)
+        bytes = take!(io)
+        back = Arrow.readstream(bytes)
+        @test back.schema.fields[1].type isa AC.DictionaryType
+        @test length(back.batches[1].columns[1].dictionary::AC.ArrayData) == 2
+        @test isequal(Arrow.Table(bytes).v, rows)
+
+        # Candidate categories compare as `===`: floats by bits (0.0 and -0.0
+        # stay distinct, one NaN payload is one category), mutable values by
+        # reference, arrays of plain values by contents.
+        floatpool = Arrow._dictionarypool(Float64[0.0, -0.0, NaN, NaN], nothing)
+        @test length(floatpool) == 3
+        a = Ref(1)
+        b = Ref(1)
+        refpool = Arrow._dictionarypool([a, b, a], nothing)
+        @test length(refpool) == 2
+    end
+
+    @testset "dictionary and run-end columns rewrite from their buffers" begin
+        # Indices and runs are reused, not found again value by value.
+        n = 1_000_000
+        dict = Arrow.Table(
+            take!(Arrow.tobuffer((d=Arrow.DictEncode(rand(["a", "b", "c"], n)),))),
+        )
+        ree = Arrow.Table(_reebytes(n))
+        for t in (dict, ree)
+            _rewriteallocations(t)
+            once = take!(Arrow.tobuffer(t))
+            @test take!(Arrow.tobuffer(Arrow.Table(once))) == once
+            @test isequal(Arrow.Table(once)[1], t[1])
+        end
+        @test _rewriteallocations(dict) < 40n
+        @test _rewriteallocations(ree) < n
+        @test getfield(Arrow.Table(take!(Arrow.tobuffer(ree))), :schema).fields[1].type isa
+              AC.RunEndEncodedType
+    end
+
+    @testset "a child whose values in a batch are all null rewrites" begin
+        function onebatch(f, d)
+            sch = AC.Schema([f])
+            return Arrow.writestream(sch, [AC.RecordBatch(sch, [d], Int(d.len))])
+        end
+        # Unions whose Int64 child holds only a null, as pyarrow writes them.
+        for sparse in (false, true)
+            fi, di = AC.fromjulia("i", Union{Missing,Int64}[missing for _ = 1:(1 + sparse)])
+            fs, ds = AC.fromjulia("s", sparse ? ["", "x"] : ["x"])
+            t = AC.UnionType(sparse ? AC.SparseMode : AC.DenseMode, Int8[0, 1])
+            buffers = AC.BufferSlice[AC._databuffer(Int8[0, 1])]
+            sparse || push!(buffers, AC._databuffer(Int32[0, 0]))
+            f = AC.Field("u", t; nullable=true, children=[fi, fs])
+            bytes = onebatch(f, AC.ArrayData(t, 2, buffers; children=[di, ds], nullcount=0))
+            @test isequal(collect(Arrow.Table(bytes).u), [missing, "x"])
+            @test isequal(collect(Arrow.Table(_rewrite(bytes)).u), [missing, "x"])
+        end
+        # A list view of structs whose `a` field is all null.
+        fa, da = AC.fromjulia("a", Union{Missing,Int64}[missing, missing])
+        fb, db = AC.fromjulia("b", ["x", "y"])
+        st, lt = AC.StructType(), AC.ListViewType(false)
+        item = AC.Field("item", st; nullable=true, children=[fa, fb])
+        itemdata = AC.ArrayData(st, 2, [AC.BufferSlice()]; children=[da, db], nullcount=0)
+        buffers = [AC.BufferSlice(), AC._databuffer(Int32[0]), AC._databuffer(Int32[2])]
+        f = AC.Field("lv", lt; nullable=true, children=[item])
+        bytes = onebatch(f, AC.ArrayData(lt, 1, buffers; children=[itemdata], nullcount=0))
+        before = collect(Arrow.Table(bytes).lv)
+        @test isequal(collect(Arrow.Table(_rewrite(bytes)).lv), before)
+    end
+
+    @testset "VersionNumber columns rewrite" begin
+        v = [v"1.2.3", v"2"]
+        m = Union{Missing,VersionNumber}[v"1", missing]
+        bytes = read(Arrow.tobuffer((v=v, m=m)))
+        for file in (false, true)
+            t = Arrow.Table(_rewrite(bytes; file))
+            @test t.v == v
+            @test isequal(collect(t.m), m)
+        end
+    end
+
+    @testset "dictencode refuses struct rows that would write as a map" begin
+        # Repeated field names read as ordered `name => value` pair rows.
+        fa, da = AC.fromjulia("a", Int64[1, 2])
+        fb, db = AC.fromjulia("a", ["x", "y"])
+        st = AC.StructType()
+        f = AC.Field("s", st; nullable=false, children=[fa, fb])
+        sch = AC.Schema([f])
+        d = AC.ArrayData(st, 2, [AC.BufferSlice()]; children=[da, db], nullcount=0)
+        bytes = Arrow.writestream(sch, [AC.RecordBatch(sch, [d], 2)])
+        rows = collect(Arrow.Table(bytes).s)
+        @test isequal(collect(Arrow.Table(_rewrite(bytes)).s), rows)
+        for file in (false, true)
+            err = @test_throws ArgumentError Arrow.write(
+                IOBuffer(),
+                Arrow.Table(bytes);
+                dictencode=true,
+                file,
+            )
+            @test occursin("column s holds struct rows", err.value.msg)
+        end
+    end
+
+    @testset "map rows that repeat a key rewrite from any read" begin
+        # Arrow leaves unique keys to the application: keys stored as
+        # themselves keep a row's repeats however the column was read.
+        plain(x) =
+            x isa Pair ? plain(first(x)) => plain(last(x)) :
+            x isa Union{AbstractDict,AbstractVector} ? [plain(y) for y in x] : x
+        io = IOBuffer()
+        Arrow.Writer(io; file=false) do w
+            m = [["k" => 1, "k" => 2], ["j" => 3]]
+            Arrow.write(w, (id=[1, 2], m=m, l=[[m[1]], [m[2]]]))
+            Arrow.write(w, (id=[3], m=[["k" => 4, "k" => 5]], l=[[["j" => 6, "j" => 7]]]))
+        end
+        two = take!(io)
+        U = Union{Int,Vector{Pair{String,Int}}}
+        @testset "$label" for (label, t) in (
+            ("two batches", Arrow.Table(two)),
+            ("a filtered read", Arrow.Table(two; filter=Arrow.col(:id) > 1)),
+            ("a union child", Arrow.Table(Arrow.tobuffer((u=U[1, ["k" => 1, "k" => 2]],)))),
+            ("labelled values", Arrow.Table(Arrow.tobuffer((m=[["k" => :a, "k" => :b]],)))),
+        )
+            out = Arrow.Table(Arrow.tobuffer(t))
+            for name in Tables.columnnames(t)
+                @test isequal(
+                    plain(Tables.getcolumn(out, name)),
+                    plain(Tables.getcolumn(t, name)),
+                )
+            end
+        end
+    end
+
+    @testset "hidden dictionary slots point at one pool value" begin
+        for value in (["x"], Int64[1]), nullable in (false, true)
+            valuefield, _ = AC.fromjulia("d", value)
+            dicttype = AC.DictionaryType(AC.IntType(32, true), valuefield.type, false)
+            dict = AC.Field("d", dicttype; nullable)
+            parent = AC.Field("p", AC.StructType(); nullable=true, children=[dict])
+            f, d = Arrow._constructhiddenpart(parent, 2, Arrow._WriterContext("p"))
+            AC.validate_full(f, d)
+            @test all(ismissing, AC.materialize(f, d))
+            # A non-nullable dictionary's valid indices need one pool value.
+            @test only(d.children).dictionary.len == (nullable ? 0 : 1)
+        end
+    end
+
+    # Arrow 2.x's FlatBuffers builder deduplicates vtables comparing slot
+    # offsets only, so a DictionaryEncoding table can reuse a KeyValue vtable
+    # whose declared object length understates the id field's extent. The
+    # verifier must bound inline fields by the buffer (as the reference
+    # implementation does), not by the reused vtable's object length, or
+    # every 2.x file with a dict-encoded, metadata-carrying field is refused.
+    # Fixtures written by registered Arrow 2.8.1 (+ CategoricalArrays 1.1.1
+    # for the categorical pair).
+    @testset "2.x vtable dedup: dict-encoded fields with metadata read" begin
+        fixture(name) = read(joinpath(@__DIR__, "fixtures2x", name * ".arrowbytes"))
+
+        t = Arrow.Table(fixture("dict-ext-metadata"))
+        @test t.a == [1, 2, 1]
+        @test "ARROW:extension:name" in collect(DataAPI.colmetadatakeys(t, :a))
+
+        t = Arrow.Table(fixture("colmeta-plain"))
+        @test t.a == [1, 2]
+        @test DataAPI.colmetadata(t, :a, "k") == "v"
+
+        # The CategoricalArrays extension labels are unregistered here, so the
+        # reader warns (once per process) and reads the dictionary-encoded
+        # strings the label is stored as.
+        empty!(Arrow._WARNED_EXTENSIONS)
+        t =
+            @test_logs (:warn, r"unsupported ARROW:extension:name") match_mode = :any Arrow.Table(
+                fixture("categorical-column"),
+            )
+        @test t.x == ["a", "b", "a", "c"]
+
+        empty!(Arrow._WARNED_EXTENSIONS)
+        t =
+            @test_logs (:warn, r"unsupported ARROW:extension:name") match_mode = :any Arrow.Table(
+                fixture("categorical-missing"),
+            )
+        @test isequal(t.y, ["a", missing, "b"])
+        @test eltype(t.y) == Union{Missing,DataString}
+    end
+end
+
+end # module RewriteRegressions
diff --git a/test/runtests.jl b/test/runtests.jl
index 4f7d28b2..5bdcb954 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -15,1139 +15,64 @@
 # limitations under the License.
 
 using Test
+using Aqua
 using Arrow
-using ArrowTypes
-using Tables
-using Dates
-using PooledArrays
-using TimeZones
-using UUIDs
-using Sockets
-using CategoricalArrays
-using DataAPI
-using FilePathsBase
-using DataFrames
-using OffsetArrays
-import Random: randstring
-using TestSetExtensions: ExtendedTestSet
 
-# this formulation tests the loaded ArrowTypes, even if it's not the dev version
-# within the mono-repo
-include(joinpath(dirname(pathof(ArrowTypes)), "../test/tests.jl"))
+# Core unit tests (ArrowCore in isolation).
+include("core_tests.jl")
 
-include(joinpath(@__DIR__, "testtables.jl"))
-include(joinpath(@__DIR__, "testappend.jl"))
-include(joinpath(@__DIR__, "integrationtest.jl"))
-include(joinpath(@__DIR__, "dates.jl"))
+# The public facade (Arrow.Table / Arrow.Stream / Arrow.write).
+include("facade_tests.jl")
+include("nestedvalues_tests.jl")
+include("nested_writes_tests.jl")
+include("sharedvalues.jl")
 
-struct CustomStruct
-    x::Int
-    y::Float64
-    z::String
-end
+# ArrowTypes logical-type lowering, extension metadata, and lifting.
+include("arrowtypes_compat_tests.jl")
 
-struct CustomStruct2{sym}
-    x::Int
-end
+# Seeded end-to-end properties over public IPC paths.
+include("property_tests.jl")
 
-@testset ExtendedTestSet "Arrow" begin
-    @testset "table roundtrips" begin
-        for case in testtables
-            testtable(case...)
-        end
-    end # @testset "table roundtrips"
+# Persist only referenced content from shared Utf8View/BinaryView buffers.
+include("ipc_view_output_tests.jl")
+include("ipc_dictionary_tests.jl")
+include("stream_lifetime_tests.jl")
+include("ranged_scan_tests.jl")
+include("ranged_scan_budget_tests.jl")
+include("eager_source_tests.jl")
 
-    @testset "table append" begin
-        # skip windows since file locking prevents mktemp cleanup
-        if !Sys.iswindows()
-            for case in testtables
-                testappend(case...)
-            end
+# Read-side column construction for flat layouts.
+include("columns_tests.jl")
+include("limits_tests.jl")
 
-            testappend_partitions()
+# Files written by Polars (footer-authoritative file reads, 128-bit ints).
+include("polars_tests.jl")
 
-            for compression_option in (:lz4, :zstd)
-                testappend_compression(compression_option)
-            end
-        end
-    end # @testset "table append"
+# Read-then-rewrite fidelity through the facade, plus reader-budget accounting.
+include("rewrite_regressions.jl")
+include("detached_values_tests.jl")
 
-    @testset "arrow json integration tests" begin
-        for file in readdir(joinpath(dirname(pathof(Arrow)), "../test/arrowjson"))
-            jsonfile = joinpath(joinpath(dirname(pathof(Arrow)), "../test/arrowjson"), file)
-            @testset "integration test for $jsonfile" begin
-                df = ArrowJSON.parsefile(jsonfile)
-                io = Arrow.tobuffer(df)
-                tbl = Arrow.Table(io; convert=false)
-                @test isequal(df, tbl)
-            end
-        end
-    end # @testset "arrow json integration tests"
+# The Arrow 2.x compatibility surface (getmetadata, tobuffer, curried write,
+# removed-keyword warnings, typed scan overrides) and the ArrowTimeZonesExt
+# child suite.
+include("compat_tests.jl")
+include("dataframes_tests.jl")
+include("invalidations.jl")
 
-    @testset "abstract path" begin
-        # Make a custom path type that simulates how AWSS3.jl's S3Path works
-        struct CustomPath <: AbstractPath
-            path::PosixPath
-        end
+# The incremental writer (Arrow.Writer) and stream append (Arrow.append).
+include("incremental_writer_tests.jl")
+include("writer_sink_tests.jl")
 
-        Base.read(p::CustomPath) = read(p.path)
+# Shared acceptance/conformance support contracts and adapter composition.
+include("conformance_support_tests.jl")
 
-        io = Arrow.tobuffer((col=[0],))
-        tt = Arrow.Table(io)
+# The CloudStore.jl extension against a local S3-compatible server.
+include("cloudstore_tests.jl")
 
-        mktempdir() do dir
-            p = Path(joinpath(dir, "test.arrow"))
-            Arrow.write(p, tt)
-            @test isfile(p)
+# The adapter acceptance batteries: assertion-dense scripts over the
+# package's internals, sharing one explicit private support module.
+include("batteries.jl")
 
-            # skip windows since file locking prevents mktemp cleanup
-            if !Sys.iswindows()
-                tt2 = Arrow.Table(p)
-                @test values(tt) == values(tt2)
-
-                tt3 = Arrow.Table(CustomPath(p))
-                @test values(tt) == values(tt3)
-            end
-        end
-    end # @testset "abstract path"
-
-    @testset "misc" begin
-        @testset "# multiple record batches" begin
-            t = Tables.partitioner((
-                (col1=Union{Int64,Missing}[1, 2, 3, 4, 5, 6, 7, 8, 9, missing],),
-                (col1=Union{Int64,Missing}[missing, 11],),
-            ))
-            io = Arrow.tobuffer(t)
-            tt = Arrow.Table(io)
-            @test length(tt) == 1
-            @test isequal(
-                tt.col1,
-                vcat([1, 2, 3, 4, 5, 6, 7, 8, 9, missing], [missing, 11]),
-            )
-            @test eltype(tt.col1) === Union{Int64,Missing}
-
-            # Arrow.Stream
-            seekstart(io)
-            str = Arrow.Stream(io)
-            @test eltype(str) == Arrow.Table
-            @test !Base.isdone(str)
-            state = iterate(str)
-            @test state !== nothing
-            tt, st = state
-            @test length(tt) == 1
-            @test isequal(tt.col1, [1, 2, 3, 4, 5, 6, 7, 8, 9, missing])
-
-            state = iterate(str, st)
-            @test state !== nothing
-            tt, st = state
-            @test length(tt) == 1
-            @test isequal(tt.col1, [missing, 11])
-
-            @test iterate(str, st) === nothing
-
-            @test isequal(collect(str)[1].col1, [1, 2, 3, 4, 5, 6, 7, 8, 9, missing])
-            @test isequal(collect(str)[2].col1, [missing, 11])
-        end
-
-        @testset "# 610: dictionary replacement between record batches" begin
-            for compress in (nothing, :lz4, :zstd)
-                first = (a=Arrow.DictEncode(["alpha", "beta"]),)
-                second = (a=Arrow.DictEncode(["gamma", "delta"]),)
-                third = (a=Arrow.DictEncode(["gamma", "epsilon"]),)
-                b1 = take!(Arrow.tobuffer(Tables.partitioner((first, first)); compress))
-                b2 = take!(Arrow.tobuffer(Tables.partitioner((second, third)); compress))
-
-                # Replace the first stream's EOS with the second stream after its schema.
-                _, (pos, _) = iterate(Arrow.BatchIterator(Arrow.ArrowBlob(b2, 1, nothing)))
-                bytes = vcat(b1[1:(end - 8)], b2[pos:end])
-                batches = Arrow.BatchIterator(Arrow.ArrowBlob(bytes, 1, nothing))
-                @test count(batches) do batch
-                    header = batch.msg.header
-                    header isa Arrow.Meta.DictionaryBatch && header.isDelta
-                end == 1
-
-                expected = [first.a.data, first.a.data, second.a.data, third.a.data]
-                @test Arrow.Table(bytes).a == vcat(expected...)
-                @test Arrow.Table([b1, b2]).a == vcat(expected...)
-                @test [collect(batch.a) for batch in Arrow.Stream(bytes)] == expected
-            end
-        end
-
-        @testset "# dictionary batch isDelta" begin
-            t = (
-                col1=Int64[1, 2, 3, 4],
-                col2=Union{String,Missing}["hey", "there", "sailor", missing],
-                col3=NamedTuple{
-                    (:a, :b),
-                    Tuple{Int64,Union{Missing,NamedTuple{(:c,),Tuple{String}}}},
-                }[
-                    (a=Int64(1), b=missing),
-                    (a=Int64(1), b=missing),
-                    (a=Int64(3), b=(c="sailor",)),
-                    (a=Int64(4), b=(c="jo-bob",)),
-                ],
-            )
-            t2 = (
-                col1=Int64[1, 2, 5, 6],
-                col2=Union{String,Missing}["hey", "there", "sailor2", missing],
-                col3=NamedTuple{
-                    (:a, :b),
-                    Tuple{Int64,Union{Missing,NamedTuple{(:c,),Tuple{String}}}},
-                }[
-                    (a=Int64(1), b=missing),
-                    (a=Int64(1), b=missing),
-                    (a=Int64(5), b=(c="sailor2",)),
-                    (a=Int64(4), b=(c="jo-bob",)),
-                ],
-            )
-            tt = Tables.partitioner((t, t2))
-            tt = Arrow.Table(Arrow.tobuffer(tt; dictencode=true, dictencodenested=true))
-            @test tt.col1 == [1, 2, 3, 4, 1, 2, 5, 6]
-            @test isequal(
-                tt.col2,
-                ["hey", "there", "sailor", missing, "hey", "there", "sailor2", missing],
-            )
-            @test isequal(
-                tt.col3,
-                vcat(
-                    NamedTuple{
-                        (:a, :b),
-                        Tuple{Int64,Union{Missing,NamedTuple{(:c,),Tuple{String}}}},
-                    }[
-                        (a=Int64(1), b=missing),
-                        (a=Int64(1), b=missing),
-                        (a=Int64(3), b=(c="sailor",)),
-                        (a=Int64(4), b=(c="jo-bob",)),
-                    ],
-                    NamedTuple{
-                        (:a, :b),
-                        Tuple{Int64,Union{Missing,NamedTuple{(:c,),Tuple{String}}}},
-                    }[
-                        (a=Int64(1), b=missing),
-                        (a=Int64(1), b=missing),
-                        (a=Int64(5), b=(c="sailor2",)),
-                        (a=Int64(4), b=(c="jo-bob",)),
-                    ],
-                ),
-            )
-        end
-
-        @testset "metadata" begin
-            t = (col1=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],)
-            meta = Dict("key1" => "value1", "key2" => "value2")
-            meta2 = Dict("colkey1" => "colvalue1", "colkey2" => "colvalue2")
-            tt = Arrow.Table(
-                Arrow.tobuffer(t; colmetadata=Dict(:col1 => meta2), metadata=meta),
-            )
-            @test length(tt) == length(t)
-            @test tt.col1 == t.col1
-            @test eltype(tt.col1) === Int64
-            @test Arrow.getmetadata(tt) == Arrow.toidict(meta)
-            @test Arrow.getmetadata(tt.col1) == Arrow.toidict(meta2)
-
-            t = (col1=collect(1:10), col2=collect('a':'j'), col3=collect(1:10))
-            meta = ("key1" => :value1, :key2 => "value2")
-            meta2 = ("colkey1" => :colvalue1, :colkey2 => "colvalue2")
-            meta3 = ("colkey3" => :colvalue3,)
-            tt = Arrow.Table(
-                Arrow.tobuffer(
-                    t;
-                    colmetadata=Dict(:col2 => meta2, :col3 => meta3),
-                    metadata=meta,
-                ),
-            )
-            @test Arrow.getmetadata(tt) ==
-                  Arrow.toidict(String(k) => String(v) for (k, v) in meta)
-            @test Arrow.getmetadata(tt.col1) === nothing
-            @test Arrow.getmetadata(tt.col2)["colkey1"] == "colvalue1"
-            @test Arrow.getmetadata(tt.col2)["colkey2"] == "colvalue2"
-            @test Arrow.getmetadata(tt.col3)["colkey3"] == "colvalue3"
-        end
-
-        @testset "# custom compressors" begin
-            lz4 = Arrow.CodecLz4.LZ4FrameCompressor(; compressionlevel=8)
-            Arrow.CodecLz4.TranscodingStreams.initialize(lz4)
-            t = (col1=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],)
-            tt = Arrow.Table(Arrow.tobuffer(t; compress=lz4))
-            @test length(tt) == length(t)
-            @test all(isequal.(values(t), values(tt)))
-
-            zstd = Arrow.CodecZstd.ZstdCompressor(; level=8)
-            Arrow.CodecZstd.TranscodingStreams.initialize(zstd)
-            t = (col1=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],)
-            tt = Arrow.Table(Arrow.tobuffer(t; compress=zstd))
-            @test length(tt) == length(t)
-            @test all(isequal.(values(t), values(tt)))
-        end
-
-        @testset "# custom alignment" begin
-            t = (col1=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],)
-            tt = Arrow.Table(Arrow.tobuffer(t; alignment=64))
-            @test length(tt) == length(t)
-            @test all(isequal.(values(t), values(tt)))
-        end
-
-        @testset "# 53" begin
-            s = "a"^100
-            t = (a=[SubString(s, 1:10), SubString(s, 11:20)],)
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test tt.a == ["aaaaaaaaaa", "aaaaaaaaaa"]
-        end
-
-        @testset "# 49" begin
-            @test_throws SystemError Arrow.Table("file_that_doesnt_exist")
-            @test_throws SystemError Arrow.Table(p"file_that_doesnt_exist")
-        end
-
-        @testset "# 52" begin
-            t = (a=Arrow.DictEncode(string.(1:129)),)
-            tt = Arrow.Table(Arrow.tobuffer(t))
-        end
-
-        @testset "# 60: unequal column lengths" begin
-            io = IOBuffer()
-            @test_throws ArgumentError Arrow.write(
-                io,
-                (a=Int[], b=["asd"], c=collect(1:100)),
-            )
-        end
-
-        @testset "# nullability of custom extension types" begin
-            t = (a=['a', missing],)
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test isequal(tt.a, ['a', missing])
-        end
-
-        @testset "# automatic custom struct serialization/deserialization" begin
-            t = (col1=[CustomStruct(1, 2.3, "hey"), CustomStruct(4, 5.6, "there")],)
-
-            Arrow.ArrowTypes.arrowname(::Type{CustomStruct}) =
-                Symbol("JuliaLang.CustomStruct")
-            Arrow.ArrowTypes.JuliaType(::Val{Symbol("JuliaLang.CustomStruct")}, S) =
-                CustomStruct
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test length(tt) == length(t)
-            @test all(isequal.(values(t), values(tt)))
-        end
-
-        @testset "# 76" begin
-            t = (col1=NamedTuple{(:a,),Tuple{Union{Int,String}}}[(a=1,), (a="x",)],)
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test length(tt) == length(t)
-            @test all(isequal.(values(t), values(tt)))
-        end
-
-        @testset "# 89 etc. - UUID FixedSizeListKind overloads" begin
-            @test Arrow.ArrowTypes.gettype(Arrow.ArrowTypes.ArrowKind(UUID)) == UInt8
-            @test Arrow.ArrowTypes.getsize(Arrow.ArrowTypes.ArrowKind(UUID)) == 16
-        end
-
-        @testset "# 98" begin
-            t = (
-                a=[Nanosecond(0), Nanosecond(1)],
-                b=[uuid4(), uuid4()],
-                c=[missing, Nanosecond(1)],
-            )
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test copy(tt.a) isa Vector{Nanosecond}
-            @test copy(tt.b) isa Vector{UUID}
-            @test copy(tt.c) isa Vector{Union{Missing,Nanosecond}}
-        end
-
-        @testset "# copy on DictEncoding w/ missing values" begin
-            x = PooledArray(["hey", missing])
-            x2 = Arrow.toarrowvector(x)
-            @test isequal(copy(x2), x)
-        end
-
-        @testset "# some dict encoding coverage" begin
-            # signed indices for DictEncodedKind #112 #113 #114
-            av = Arrow.toarrowvector(PooledArray(repeat(["a", "b"], inner=5)))
-            @test isa(first(av.indices), Signed)
-
-            av = Arrow.toarrowvector(CategoricalArray(repeat(["a", "b"], inner=5)))
-            @test isa(first(av.indices), Signed)
-
-            av = Arrow.toarrowvector(CategoricalArray(["a", "bb", missing]))
-            @test isa(first(av.indices), Signed)
-            @test length(av) == 3
-            @test eltype(av) == Union{String,Missing}
-
-            av = Arrow.toarrowvector(CategoricalArray(["a", "bb", "ccc"]))
-            @test isa(first(av.indices), Signed)
-            @test length(av) == 3
-            @test eltype(av) == String
-        end
-
-        @testset "# 120" begin
-            x = PooledArray(["hey", missing])
-            x2 = Arrow.toarrowvector(x)
-            @test eltype(DataAPI.refpool(x2)) == Union{Missing,String}
-            @test eltype(DataAPI.levels(x2)) == String
-            @test DataAPI.refarray(x2) == [1, 2]
-        end
-
-        @testset "# 121" begin
-            a = PooledArray(repeat(string.('S', 1:130), inner=5), compress=true)
-            @test eltype(a.refs) == UInt8
-            av = Arrow.toarrowvector(a)
-            @test eltype(av.indices) == Int16
-        end
-
-        @testset "# 123" begin
-            t = (x=collect(zip(rand(10), rand(10))),)
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test tt.x == t.x
-        end
-
-        @testset "# 144" begin
-            t = Tables.partitioner((
-                (a=Arrow.DictEncode([1, 2, 3]),),
-                (a=Arrow.DictEncode(fill(1, 129)),),
-            ))
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test length(tt.a) == 132
-        end
-
-        @testset "# 126" begin
-            # XXX This test also captures a race condition in multithreaded
-            # writes of dictionary encoded arrays
-            t = Tables.partitioner((
-                (a=Arrow.toarrowvector(PooledArray([1, 2, 3])),),
-                (a=Arrow.toarrowvector(PooledArray([1, 2, 3, 4])),),
-                (a=Arrow.toarrowvector(PooledArray([1, 2, 3, 4, 5])),),
-            ))
-            tt = Arrow.Table(Arrow.tobuffer(t))
-            @test length(tt.a) == 12
-            @test tt.a == [1, 2, 3, 1, 2, 3, 4, 1, 2, 3, 4, 5]
-
-            t = Tables.partitioner((
-                (
-                    a=Arrow.toarrowvector(
-                        PooledArray([1, 2, 3], signed=true, compress=true),
-                    ),
-                ),
-                (a=Arrow.toarrowvector(PooledArray(collect(1:129))),),
-            ))
-            io = IOBuffer()
-            @test_logs (:error, "error writing arrow data on partition = 2") begin
-                @test_throws ErrorException Arrow.write(io, t)
-            end
-        end
-
-        @testset "# 75" begin
-            tbl = Arrow.Table(Arrow.tobuffer((sets=[Set([1, 2, 3]), Set([1, 2, 3])],)))
-            @test eltype(tbl.sets) <: Set
-        end
-
-        @testset "# 85" begin
-            tbl = Arrow.Table(Arrow.tobuffer((tups=[(1, 3.14, "hey"), (1, 3.14, "hey")],)))
-            @test eltype(tbl.tups) <: Tuple
-        end
-
-        @testset "Nothing" begin
-            tbl = Arrow.Table(Arrow.tobuffer((nothings=[nothing, nothing, nothing],)))
-            @test tbl.nothings == [nothing, nothing, nothing]
-        end
-
-        @testset "arrowmetadata" begin
-            # arrowmetadata
-            t = (col1=[CustomStruct2{:hey}(1), CustomStruct2{:hey}(2)],)
-            ArrowTypes.arrowname(::Type{<:CustomStruct2}) = Symbol("CustomStruct2")
-            @test_logs (:warn, r"unsupported ARROW:extension:name type: \"CustomStruct2\"") begin
-                tbl = Arrow.Table(Arrow.tobuffer(t))
-            end
-            @test eltype(tbl.col1) <: NamedTuple
-            ArrowTypes.arrowmetadata(::Type{CustomStruct2{sym}}) where {sym} = sym
-            ArrowTypes.JuliaType(::Val{:CustomStruct2}, S, meta) =
-                CustomStruct2{Symbol(meta)}
-            tbl = Arrow.Table(Arrow.tobuffer(t))
-            @test eltype(tbl.col1) == CustomStruct2{:hey}
-        end
-
-        @testset "# 166" begin
-            t = (col1=[zero(Arrow.Timestamp{Arrow.Meta.TimeUnit.NANOSECOND,nothing})],)
-            tbl = Arrow.Table(Arrow.tobuffer(t))
-            @test_logs (
-                :warn,
-                r"automatically converting Arrow.Timestamp with precision = NANOSECOND",
-            ) begin
-                @test tbl.col1[1] == Dates.DateTime(1970)
-            end
-        end
-
-        @testset "# 95; Arrow.ToTimestamp" begin
-            x = [ZonedDateTime(Dates.DateTime(2020), tz"Europe/Paris")]
-            c = Arrow.ToTimestamp(x)
-            @test eltype(c) ==
-                  Arrow.Timestamp{Arrow.Flatbuf.TimeUnit.MILLISECOND,Symbol("Europe/Paris")}
-            @test c[1] ==
-                  Arrow.Timestamp{Arrow.Flatbuf.TimeUnit.MILLISECOND,Symbol("Europe/Paris")}(
-                1577833200000,
-            )
-        end
-
-        @testset "# 158" begin
-            # arrow ipc stream generated from pyarrow with no record batches
-            bytes = UInt8[
-                0xff,
-                0xff,
-                0xff,
-                0xff,
-                0x78,
-                0x00,
-                0x00,
-                0x00,
-                0x10,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x0a,
-                0x00,
-                0x0c,
-                0x00,
-                0x06,
-                0x00,
-                0x05,
-                0x00,
-                0x08,
-                0x00,
-                0x0a,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x01,
-                0x04,
-                0x00,
-                0x0c,
-                0x00,
-                0x00,
-                0x00,
-                0x08,
-                0x00,
-                0x08,
-                0x00,
-                0x00,
-                0x00,
-                0x04,
-                0x00,
-                0x08,
-                0x00,
-                0x00,
-                0x00,
-                0x04,
-                0x00,
-                0x00,
-                0x00,
-                0x01,
-                0x00,
-                0x00,
-                0x00,
-                0x14,
-                0x00,
-                0x00,
-                0x00,
-                0x10,
-                0x00,
-                0x14,
-                0x00,
-                0x08,
-                0x00,
-                0x06,
-                0x00,
-                0x07,
-                0x00,
-                0x0c,
-                0x00,
-                0x00,
-                0x00,
-                0x10,
-                0x00,
-                0x10,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x01,
-                0x02,
-                0x10,
-                0x00,
-                0x00,
-                0x00,
-                0x1c,
-                0x00,
-                0x00,
-                0x00,
-                0x04,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x01,
-                0x00,
-                0x00,
-                0x00,
-                0x61,
-                0x00,
-                0x00,
-                0x00,
-                0x08,
-                0x00,
-                0x0c,
-                0x00,
-                0x08,
-                0x00,
-                0x07,
-                0x00,
-                0x08,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x01,
-                0x40,
-                0x00,
-                0x00,
-                0x00,
-                0xff,
-                0xff,
-                0xff,
-                0xff,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-            ]
-            tbl = Arrow.Table(bytes)
-            @test length(tbl.a) == 0
-            @test eltype(tbl.a) == Union{Int64,Missing}
-        end
-
-        @testset "# 181" begin
-            # XXX this test hangs on Julia 1.12 when using a deeper nesting
-            d = Dict{Int,Int}()
-            for i = 1:1
-                d = Dict(i => d)
-            end
-            tbl = (x=[d],)
-            msg = "reached nested serialization level (2) deeper than provided max depth argument (1); to increase allowed nesting level, pass `maxdepth=X`"
-            @test_throws ErrorException(msg) Arrow.tobuffer(tbl; maxdepth=1)
-            @test Arrow.Table(Arrow.tobuffer(tbl; maxdepth=5)).x == tbl.x
-        end
-
-        @testset "# 167" begin
-            t = (col1=[["boop", "she"], ["boop", "she"], ["boo"]],)
-            tbl = Arrow.Table(Arrow.tobuffer(t))
-            @test eltype(tbl.col1) <: AbstractVector{String}
-        end
-
-        @testset "# 200 VersionNumber" begin
-            t = (col1=[v"1"],)
-            tbl = Arrow.Table(Arrow.tobuffer(t))
-            @test eltype(tbl.col1) == VersionNumber
-        end
-
-        @testset "`show`" begin
-            str = nothing
-            table = (; a=1:5, b=fill(1.0, 5))
-            arrow_table = Arrow.Table(Arrow.tobuffer(table))
-            # 2 and 3-arg show with no metadata
-            for outer str in
-                (sprint(show, arrow_table), sprint(show, MIME"text/plain"(), arrow_table))
-                @test length(str) < 100
-                @test occursin("5 rows", str)
-                @test occursin("2 columns", str)
-                @test occursin("Int", str)
-                @test occursin("Float64", str)
-                @test !occursin("metadata entries", str)
-            end
-
-            # 2-arg show with metadata
-            big_dict = Dict((randstring(rand(5:10)) => randstring(rand(1:3)) for _ = 1:100))
-            arrow_table = Arrow.Table(Arrow.tobuffer(table; metadata=big_dict))
-            str2 = sprint(show, arrow_table)
-            @test length(str2) > length(str)
-            @test length(str2) < 200
-            @test occursin("metadata entries", str2)
-
-            # 3-arg show with metadata
-            str3 = sprint(
-                show,
-                MIME"text/plain"(),
-                arrow_table;
-                context=IOContext(IOBuffer(), :displaysize => (24, 100), :limit => true),
-            )
-            @test length(str3) < 1000
-            # some but not too many `=>`'s for printing the metadata
-            @test 5 < length(collect(eachmatch(r"=>", str3))) < 20
-        end
-
-        @testset "# 194" begin
-            @test isempty(Arrow.Table(Arrow.tobuffer(Dict{Symbol,Vector}())))
-        end
-
-        @testset "# 229" begin
-            struct Foo229{x}
-                y::String
-                z::Int
-            end
-            Arrow.ArrowTypes.arrowname(::Type{<:Foo229}) = Symbol("JuliaLang.Foo229")
-            Arrow.ArrowTypes.ArrowType(::Type{Foo229{x}}) where {x} =
-                Tuple{String,String,Int}
-            Arrow.ArrowTypes.toarrow(row::Foo229{x}) where {x} = (String(x), row.y, row.z)
-            Arrow.ArrowTypes.JuliaType(::Val{Symbol("JuliaLang.Foo229")}, ::Any) = Foo229
-            Arrow.ArrowTypes.fromarrow(::Type{<:Foo229}, x, y, z) = Foo229{Symbol(x)}(y, z)
-            cols = (
-                k1=[Foo229{:a}("a", 1), Foo229{:b}("b", 2)],
-                k2=[Foo229{:c}("c", 3), Foo229{:d}("d", 4)],
-            )
-            tbl = Arrow.Table(Arrow.tobuffer(cols))
-            @test tbl.k1 == cols.k1
-            @test tbl.k2 == cols.k2
-        end
-
-        @testset "# PR 234" begin
-            # bugfix parsing primitive arrays
-            buf = [
-                0x14,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x0e,
-                0x00,
-                0x14,
-                0x00,
-                0x00,
-                0x00,
-                0x10,
-                0x00,
-                0x0c,
-                0x00,
-                0x08,
-                0x00,
-                0x04,
-                0x00,
-                0x0e,
-                0x00,
-                0x00,
-                0x00,
-                0x2c,
-                0x00,
-                0x00,
-                0x00,
-                0x38,
-                0x00,
-                0x00,
-                0x00,
-                0x38,
-                0x00,
-                0x00,
-                0x00,
-                0x38,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x03,
-                0x00,
-                0x00,
-                0x00,
-                0x01,
-                0x00,
-                0x00,
-                0x00,
-                0x02,
-                0x00,
-                0x00,
-                0x00,
-                0x03,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-                0x00,
-            ]
-
-            struct TestData <: Arrow.FlatBuffers.Table
-                bytes::Vector{UInt8}
-                pos::Base.Int
-            end
-
-            function Base.getproperty(x::TestData, field::Symbol)
-                if field === :DataInt32
-                    o = Arrow.FlatBuffers.offset(x, 12)
-                    o != 0 && return Arrow.FlatBuffers.Array{Int32}(x, o)
-                else
-                    @warn "field $field not supported"
-                end
-            end
-
-            d = Arrow.FlatBuffers.getrootas(TestData, buf, 0)
-            @test d.DataInt32 == UInt32[1, 2, 3]
-        end
-
-        @testset "# test multiple inputs treated as one table" begin
-            t = (col1=[1, 2, 3, 4, 5], col2=[1.2, 2.3, 3.4, 4.5, 5.6])
-            tbl = Arrow.Table([Arrow.tobuffer(t), Arrow.tobuffer(t)])
-            @test tbl.col1 == [1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
-            @test tbl.col2 == [1.2, 2.3, 3.4, 4.5, 5.6, 1.2, 2.3, 3.4, 4.5, 5.6]
-
-            # schemas must match between multiple inputs
-            t2 = (col1=[1.2, 2.3, 3.4, 4.5, 5.6],)
-            @test_throws ArgumentError Arrow.Table([Arrow.tobuffer(t), Arrow.tobuffer(t2)])
-
-            # test multiple inputs treated as one table
-            tbls = collect(Arrow.Stream([Arrow.tobuffer(t), Arrow.tobuffer(t)]))
-            @test tbls[1].col1 == tbls[2].col1
-            @test tbls[1].col2 == tbls[2].col2
-
-            # schemas must match between multiple inputs
-            t2 = (col1=[1.2, 2.3, 3.4, 4.5, 5.6],)
-            @test_throws ArgumentError collect(
-                Arrow.Stream([Arrow.tobuffer(t), Arrow.tobuffer(t2)]),
-            )
-        end
-
-        @testset "# 253" begin
-            # https://github.com/apache/arrow-julia/issues/253
-            @test Arrow.toidict(Pair{String,String}[]) ==
-                  Base.ImmutableDict{String,String}()
-        end
-
-        @testset "# 232" begin
-            # https://github.com/apache/arrow-julia/issues/232
-            t = (; x=[Dict(true => 1.32, 1.2 => 0.53495216)])
-            @test_throws ArgumentError(
-                "`keytype(d)` must be concrete to serialize map-like `d`, but `keytype(d) == Real`",
-            ) Arrow.tobuffer(t)
-            t = (; x=[Dict(32.0 => true, 1.2 => 0.53495216)])
-            @test_throws ArgumentError(
-                "`valtype(d)` must be concrete to serialize map-like `d`, but `valtype(d) == Real`",
-            ) Arrow.tobuffer(t)
-            t = (; x=[Dict(true => 1.32, 1.2 => true)])
-            @test_throws ArgumentError(
-                "`keytype(d)` must be concrete to serialize map-like `d`, but `keytype(d) == Real`",
-            ) Arrow.tobuffer(t)
-        end
-
-        @testset "# 214" begin
-            # https://github.com/apache/arrow-julia/issues/214
-            t1 = (; x=[(Nanosecond(42),)])
-            t2 = Arrow.Table(Arrow.tobuffer(t1))
-            t3 = Arrow.Table(Arrow.tobuffer(t2))
-            @test t3.x == t1.x
-
-            t1 = (; x=[(; a=Nanosecond(i), b=Nanosecond(i + 1)) for i = 1:5])
-            t2 = Arrow.Table(Arrow.tobuffer(t1))
-            t3 = Arrow.Table(Arrow.tobuffer(t2))
-            @test t3.x == t1.x
-        end
-
-        @testset "Writer" begin
-            io = IOBuffer()
-            writer = open(Arrow.Writer, io)
-            a = 1:26
-            b = 'A':'Z'
-            partitionsize = 10
-            iter_a = Iterators.partition(a, partitionsize)
-            iter_b = Iterators.partition(b, partitionsize)
-            for (part_a, part_b) in zip(iter_a, iter_b)
-                Arrow.write(writer, (a=part_a, b=part_b))
-            end
-            close(writer)
-            seekstart(io)
-            table = Arrow.Table(io)
-            @test table.a == collect(a)
-            @test table.b == collect(b)
-        end
-
-        @testset "# Empty input" begin
-            @test Arrow.Table(UInt8[]) isa Arrow.Table
-            @test isempty(Tables.rows(Arrow.Table(UInt8[])))
-            @test Arrow.Stream(UInt8[]) isa Arrow.Stream
-            @test isempty(Tables.partitions(Arrow.Stream(UInt8[])))
-        end
-
-        @testset "# 324" begin
-            # https://github.com/apache/arrow-julia/issues/324
-            @test_throws ArgumentError filter!(x -> x > 1, Arrow.toarrowvector([1, 2, 3]))
-        end
-
-        @testset "# 327" begin
-            # https://github.com/apache/arrow-julia/issues/327
-            zdt =
-                ZonedDateTime(DateTime(2020, 11, 1, 6), tz"America/New_York"; from_utc=true)
-            arrow_zdt = ArrowTypes.toarrow(zdt)
-            zdt_again = ArrowTypes.fromarrow(ZonedDateTime, arrow_zdt)
-            @test zdt == zdt_again
-
-            # Check that we still correctly read in old TimeZones
-            original_table =
-                (; col=[ZonedDateTime(DateTime(1, 2, 3, 4, 5, 6), tz"UTC+3") for _ = 1:5])
-            table = Arrow.Table(joinpath(@__DIR__, "old_zdt.arrow"))
-            @test original_table.col == table.col
-        end
-
-        @testset "# 243" begin
-            table = (; col=[(; v=v"1"), (; v=v"2"), missing])
-            @test isequal(Arrow.Table(Arrow.tobuffer(table)).col, table.col)
-        end
-
-        @testset "# 367" begin
-            t = (; x=Union{ZonedDateTime,Missing}[missing])
-            a = Arrow.Table(Arrow.tobuffer(t))
-            @test Tables.schema(a) == Tables.schema(t)
-            @test isequal(a.x, t.x)
-        end
-
-        # https://github.com/apache/arrow-julia/issues/414
-        df = DataFrame(("$i" => rand(1000) for i = 1:65536)...)
-        df_load = Arrow.Table(Arrow.tobuffer(df))
-        @test Tables.schema(df) == Tables.schema(df_load)
-        for (col1, col2) in zip(Tables.columns(df), Tables.columns(df_load))
-            @test col1 == col2
-        end
-
-        @testset "# 411" begin
-            # Vector{UInt8} are written as List{UInt8} in Arrow
-            # Base.CodeUnits are written as Binary
-            t = (
-                a=[[0x00, 0x01], UInt8[], [0x03]],
-                am=[[0x00, 0x01], [0x03], missing],
-                b=[b"01", b"", b"3"],
-                bm=[b"01", b"3", missing],
-                c=["a", "b", "c"],
-                cm=["a", "c", missing],
-            )
-            buf = Arrow.tobuffer(t)
-            tt = Arrow.Table(buf)
-            @test t.a == tt.a
-            @test isequal(t.am, tt.am)
-            @test t.b == tt.b
-            @test isequal(t.bm, tt.bm)
-            @test t.c == tt.c
-            @test isequal(t.cm, tt.cm)
-            @test Arrow.schema(tt)[].fields[1].type isa Arrow.Flatbuf.List
-            @test Arrow.schema(tt)[].fields[3].type isa Arrow.Flatbuf.Binary
-            pos = position(buf)
-            Arrow.append(buf, tt)
-            seekstart(buf)
-            buf1 = read(buf, pos)
-            buf2 = read(buf)
-            t1 = Arrow.Table(buf1)
-            t2 = Arrow.Table(buf2)
-            @test isequal(t1.a, t2.a)
-            @test isequal(t1.am, t2.am)
-            @test isequal(t1.b, t2.b)
-            @test isequal(t1.bm, t2.bm)
-            @test isequal(t1.c, t2.c)
-            @test isequal(t1.cm, t2.cm)
-        end
-
-        @testset "# 435" begin
-            t = Arrow.Table(
-                joinpath(dirname(pathof(Arrow)), "../test/java_compress_len_neg_one.arrow"),
-            )
-            @test length(t) == 15
-            @test length(t.isA) == 102
-        end
-
-        @testset "# 293" begin
-            t = (a=[1, 2, 3], b=[1.0, 2.0, 3.0])
-            buf = Arrow.tobuffer(t)
-            tbl = Arrow.Table(buf)
-            parts = Tables.partitioner((t, t))
-            buf2 = Arrow.tobuffer(parts)
-            tbl2 = Arrow.Table(buf2)
-            for t in Tables.partitions(tbl2)
-                @test t.a == tbl.a
-                @test t.b == tbl.b
-            end
-        end
-
-        @testset "# 437" begin
-            t = Arrow.Table(
-                joinpath(
-                    dirname(pathof(Arrow)),
-                    "../test/java_compressed_zero_length.arrow",
-                ),
-            )
-            @test length(t) == 2
-            @test length(t.name) == 0
-        end
-
-        @testset "# 458" begin
-            x = (; a=[[[[1]]]])
-            buf = Arrow.tobuffer(x)
-            t = Arrow.Table(buf)
-            @test t.a[1][1][1][1] == 1
-        end
-
-        @testset "# 456" begin
-            NT = @NamedTuple{x::Int, y::Union{Missing,Int}}
-            data = NT[(x=1, y=2), (x=2, y=missing), (x=3, y=4), (x=4, y=5)]
-            t = [(a=1, b=view(data, 1:2)), (a=2, b=view(data, 3:4)), missing]
-            @test Arrow.toarrowvector(t) isa Arrow.Struct
-        end
-
-        # @testset "# 461" begin
-
-        # table = (; v=[v"1", v"2", missing])
-        # buf = Arrow.tobuffer(table)
-        # table2 = Arrow.Table(buf)
-        # @test isequal(table.v, table2.v)
-
-        # end
-        if isdefined(ArrowTypes, :StructElement)
-            @testset "# 493" begin
-                # This test stresses the existence of the mechanism
-                # implemented in https://github.com/apache/arrow-julia/pull/493,
-                # but doesn't stress the actual use case that motivates
-                # that mechanism, simply because it'd be more annoying to
-                # write that test; see the PR for details.
-                struct Foo493
-                    x::Int
-                    y::Int
-                end
-                ArrowTypes.arrowname(::Type{Foo493}) = Symbol("JuliaLang.Foo493")
-                ArrowTypes.JuliaType(::Val{Symbol("JuliaLang.Foo493")}, T) = Foo493
-                function ArrowTypes.fromarrowstruct(
-                    ::Type{Foo493},
-                    ::Val{fnames},
-                    x...,
-                ) where {fnames}
-                    nt = NamedTuple{fnames}(x)
-                    return Foo493(nt.x + 1, nt.y + 1)
-                end
-                t = (; f=[Foo493(1, 2), Foo493(3, 4)])
-                buf = Arrow.tobuffer(t)
-                tbl = Arrow.Table(buf)
-                @test tbl.f[1] === Foo493(2, 3)
-                @test tbl.f[2] === Foo493(4, 5)
-            end
-        end
-
-        @testset "# 504" begin
-            struct Foo504
-                x::Int
-            end
-
-            struct Bar504
-                a::Foo504
-            end
-
-            v = [Bar504(Foo504(i)) for i = 1:3]
-            io = IOBuffer()
-            Arrow.write(io, v; file=false)
-            seekstart(io)
-            Arrow.append(io, v) # testing the compatility between the schema of the arrow Table, and the "schema" of v (using the fallback mechanism of Tables.jl)
-            seekstart(io)
-            t = Arrow.Table(io)
-            @test Arrow.Tables.rowcount(t) == 6
-        end
-
-        @testset "# 526: Arrow.Time" begin
-            tt = testtables[4]
-            # just to make sure we're grabbing the correct table
-            @test first(tt) == "arrow date/time types"
-            tbl = Arrow.Table(Arrow.tobuffer(tt[2]))
-            @test tbl.col16[1] == Dates.Time(0, 0, 0)
-        end
-
-        @testset "#511: Bug in reading Utf8View data" begin
-            t = Arrow.Table(
-                joinpath(dirname(pathof(Arrow)), "../test/reject_reason_trimmed.arrow"),
-            )
-            @test t.reject_reason[end] == "POST_ONLY"
-        end
-    end # @testset "misc"
-
-    @testset "DataAPI.metadata" begin
-        df = DataFrame(a=1, b=2, c=3)
-        for i = 1:2
-            io = IOBuffer()
-            if i == 1 # skip writing metadata in the first iteration
-                Arrow.write(io, df)
-            else
-                Arrow.write(io, df, metadata=metadata(df), colmetadata=colmetadata(df))
-            end
-            seekstart(io)
-            tbl = Arrow.Table(io)
-
-            @test DataAPI.metadatasupport(typeof(tbl)) == (read=true, write=false)
-            @test metadata(tbl) == metadata(df)
-            @test metadata(tbl; style=true) == metadata(df; style=true)
-            @test_throws Exception metadata(tbl, "xyz")
-            @test metadata(tbl, "xyz", "something") == "something"
-            @test metadata(tbl, "xyz", "something"; style=true) == ("something", :default)
-            @test metadatakeys(tbl) == metadatakeys(df)
-
-            @test DataAPI.colmetadatasupport(typeof(tbl)) == (read=true, write=false)
-            @test colmetadata(tbl) == colmetadata(df)
-            @test colmetadata(tbl; style=true) == colmetadata(df; style=true)
-            @test_throws MethodError colmetadata(tbl, "xyz")
-            @test_throws KeyError colmetadata(tbl, :xyz)
-            @test colmetadata(tbl, :b) == colmetadata(df, :b)
-            @test_throws MethodError colmetadata(tbl, :b, "xyz")
-            @test colmetadata(tbl, :b, "xyz", "something") == "something"
-            @test colmetadata(tbl, :b, "xyz", "something"; style=true) ==
-                  ("something", :default)
-            @test Set(colmetadatakeys(tbl)) == Set(colmetadatakeys(df))
-
-            # add metadata for the second iteration
-            metadata!(df, "tkey", "tvalue")
-            metadata!(df, "tkey2", "tvalue2")
-            colmetadata!(df, :a, "ackey", "acvalue")
-            colmetadata!(df, :a, "ackey2", "acvalue2")
-            colmetadata!(df, :c, "cckey", "ccvalue")
-        end
-    end # @testset "DataAPI.metadata"
-end
+# Package hygiene: compat bounds, stale dependencies, ambiguities, exports,
+# and unbound type parameters.
+Aqua.test_all(Arrow)
diff --git a/test/scan_battery.jl b/test/scan_battery.jl
new file mode 100644
index 00000000..269b19aa
--- /dev/null
+++ b/test/scan_battery.jl
@@ -0,0 +1,1377 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ---------------------------------------------------------------------------
+# Acceptance: differential against the generic Tables.scan executor, plus skip proofs
+# ---------------------------------------------------------------------------
+
+struct _ScanOverrideValue
+    value::Int64
+end
+Base.convert(::Type{_ScanOverrideValue}, x::Integer) = _ScanOverrideValue(Int64(x))
+
+struct _ScanDomain
+    value::Int64
+end
+Base.in(x::Integer, d::_ScanDomain) = x == d.value
+
+struct _DateScanDomain
+    value::Arrow.Dates.Date
+end
+Base.in(x::Arrow.Dates.Date, d::_DateScanDomain) = x == d.value
+
+mutable struct _ScanOverrideVector{T} <: AbstractVector{T}
+    values::Vector{T}
+end
+_ScanOverrideVector{T}(::UndefInitializer, n::Integer) where {T} =
+    _ScanOverrideVector{T}(Vector{T}(undef, n))
+Base.size(v::_ScanOverrideVector) = size(v.values)
+Base.getindex(v::_ScanOverrideVector, i::Int) = v.values[i]
+Base.setindex!(v::_ScanOverrideVector, x, i::Int) = (v.values[i] = x)
+Arrow.DataAPI.defaultarray(::Type{_ScanOverrideValue}, _) =
+    _ScanOverrideVector{_ScanOverrideValue}
+
+function _rangeintersects(a::NTuple{2,Int64}, b::NTuple{2,Int64})
+    a[2] == 0 && return false
+    b[2] == 0 && return false
+    return a[1] < b[1] + b[2] && b[1] < a[1] + a[2]
+end
+
+_requestintersects(log::FetchLog, span::NTuple{2,Int64}) =
+    any(request -> _rangeintersects(request, span), log.ranges)
+
+function _footerblocks(bytes::Vector{UInt8})
+    footerlen = Int64(reinterpret(Int32, bytes[(end - 9):(end - 6)])[1])
+    footerbytes = bytes[(end - 9 - footerlen):(end - 10)]
+    _, _, dictionaries, records, _ = verify_footer(footerbytes, Limits())
+    return dictionaries, records
+end
+
+_bodyrange(block::NTuple{3,Int64}) = (block[1] + block[2], block[3])
+
+function _recordbufferranges(bytes::Vector{UInt8}, i::Int)
+    file = readfile(copy(bytes))
+    block = file.recordblocks[i]
+    budget = AllocationBudget(file.limits.max_total_allocated_bytes)
+    fm = _blockmessage(heapregion(copy(bytes)), block, file.dataend, file.limits, budget)
+    header = fm.msg.header::Meta.RecordBatch
+    bodystart = block[1] + block[2]
+    return NTuple{2,Int64}[
+        (bodystart + Int64(buffer.offset), Int64(buffer.length)) for
+        buffer in header.buffers
+    ]
+end
+
+function _tables_values_equal(a, b)
+    ca, cb = Tables.columns(a), Tables.columns(b)
+    Tables.rowcount(ca) == Tables.rowcount(cb) || return false
+    na, nb = Tables.columnnames(ca), Tables.columnnames(cb)
+    collect(na) == collect(nb) || return false
+    for n in na
+        cola = Tables.getcolumn(ca, n)
+        colb = Tables.getcolumn(cb, n)
+        isequal(collect(Any, cola), collect(Any, colb)) || return false
+    end
+    return true
+end
+
+function _tables_equal(a, b)
+    _tables_values_equal(a, b) || return false
+    ca, cb = Tables.columns(a), Tables.columns(b)
+    _schemas_equal(Tables.schema(ca), Tables.schema(cb)) || return false
+    return all(
+        eltype(Tables.getcolumn(ca, n)) == eltype(Tables.getcolumn(cb, n)) for
+        n in Tables.columnnames(ca)
+    )
+end
+
+# The generic executor reports no schema for a result with no columns.
+_schemacolumns(s) =
+    s === nothing ? (Symbol[], Type[]) : (collect(s.names), collect(s.types))
+_schemas_equal(a, b) = _schemacolumns(a) == _schemacolumns(b)
+
+"Body byte range of buffer number `bufindex` (1-based) of record batch `i`."
+function _bufferposition(bytes::Vector{UInt8}, i::Int, bufindex::Int)
+    file = readfile(copy(bytes))
+    block = file.recordblocks[i]
+    budget = AllocationBudget(file.limits.max_total_allocated_bytes)
+    fm = _blockmessage(heapregion(copy(bytes)), block, file.dataend, file.limits, budget)
+    header = fm.msg.header::Meta.RecordBatch
+    buf = header.buffers[bufindex]
+    bodystart = block[1] + block[2]
+    return bodystart + Int64(buf.offset), Int64(buf.length)
+end
+
+function _setbufferlength!(
+    bytes::Vector{UInt8},
+    block::NTuple{3,Int64},
+    bufindex::Int,
+    len::Int64,
+)
+    meta = copy(bytes[(block[1] + 9):(block[1] + block[2])])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    header = _headertable(meta, msg)
+    kind = _vu8(meta, _vfield(msg, 1, 1; required=true))
+    rb = kind == UInt8(2) ? _vtable(meta, _vref(header, 1; required=true)) : header
+    start, n = _vvector(rb, 2, 16; required=true)
+    1 <= bufindex <= n || throw(BoundsError(1:n, bufindex))
+    _write_i64!(meta, start + (bufindex - 1) * 16 + 8, len)
+    copyto!(bytes, block[1] + 9, meta, 1, length(meta))
+    return bytes
+end
+
+function _setnodelength!(
+    bytes::Vector{UInt8},
+    block::NTuple{3,Int64},
+    nodeindex::Int,
+    len::Int64,
+)
+    meta = copy(bytes[(block[1] + 9):(block[1] + block[2])])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    header = _headertable(meta, msg)
+    kind = _vu8(meta, _vfield(msg, 1, 1; required=true))
+    rb = kind == UInt8(2) ? _vtable(meta, _vref(header, 1; required=true)) : header
+    start, n = _vvector(rb, 1, 16; required=true)
+    1 <= nodeindex <= n || throw(BoundsError(1:n, nodeindex))
+    _write_i64!(meta, start + (nodeindex - 1) * 16, len)
+    copyto!(bytes, block[1] + 9, meta, 1, length(meta))
+    return bytes
+end
+
+function _setnodenullcount!(
+    bytes::Vector{UInt8},
+    block::NTuple{3,Int64},
+    nodeindex::Int,
+    count::Int64,
+)
+    meta = copy(bytes[(block[1] + 9):(block[1] + block[2])])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    header = _headertable(meta, msg)
+    kind = _vu8(meta, _vfield(msg, 1, 1; required=true))
+    rb = kind == UInt8(2) ? _vtable(meta, _vref(header, 1; required=true)) : header
+    start, n = _vvector(rb, 1, 16; required=true)
+    1 <= nodeindex <= n || throw(BoundsError(1:n, nodeindex))
+    _write_i64!(meta, start + (nodeindex - 1) * 16 + 8, count)
+    copyto!(bytes, block[1] + 9, meta, 1, length(meta))
+    return bytes
+end
+
+"File fixture carrying Arrow 0.17's V4 message-level compression marker."
+function _legacyv4file()
+    stream = _experimental_v4_stream(Int64(42))
+    frames = _frameinfo(stream)
+    schemaframe = stream[frames[1].frame]
+    recordframe = stream[frames[2].frame]
+    metalen = Int64(8 + length(frames[2].metadata))
+    bodylen = Int64(length(recordframe)) - metalen
+
+    out = UInt8[]
+    append!(out, FILE_MAGIC)
+    append!(out, zeros(UInt8, 2))
+    append!(out, schemaframe)
+    recordoffset = Int64(length(out))
+    append!(out, recordframe)
+    append!(out, reinterpret(UInt8, UInt32[CONTINUATION, UInt32(0)]))
+
+    sch = Schema(Field[Field("x", IntType(64, true); nullable=true)])
+    fielddictids = assigndictids(sch.fields)
+    b = FB.Builder(512)
+    schoff = _metaschema!(b, sch, fielddictids, Int64[])
+    Meta.footerStartDictionariesVector(b, 0)
+    dictvec = FB.endvector!(b, 0)
+    Meta.footerStartRecordBatchesVector(b, 1)
+    Meta.createBlock(b, recordoffset, Int32(metalen), bodylen)
+    recordvec = FB.endvector!(b, 1)
+    Meta.footerStart(b)
+    Meta.footerAddVersion(b, Meta.MetadataVersion.V4)
+    Meta.footerAddSchema(b, schoff)
+    Meta.footerAddDictionaries(b, dictvec)
+    Meta.footerAddRecordBatches(b, recordvec)
+    FB.finish!(b, Meta.footerEnd(b))
+    footer = collect(FB.finishedbytes(b))
+    append!(out, footer)
+    append!(out, reinterpret(UInt8, Int32[Int32(length(footer))]))
+    append!(out, FILE_MAGIC)
+    return out, (recordoffset, metalen, bodylen)
+end
+
+function _scan_main()
+    @assert !_tables_equal((x=Any[1],), (x=Int64[1],))
+    streambytes = _mixed_two_partitions_bytes()
+    filebytes = writefile(readstream(streambytes))
+    full = Arrow.Table(copy(filebytes))
+    # Every kind of source a scan reads: a mapped path, a byte vector, an IO,
+    # and a byte-range source.
+    function sources(bytes)
+        path = tempname()
+        write(path, bytes)
+        return (
+            path,
+            copy(bytes),
+            IOBuffer(copy(bytes)),
+            SourceFile(BytesSource(copy(bytes)); tailbytes=32),
+        )
+    end
+
+    scans = Tables.Scan[
+        Tables.Scan(),
+        Tables.Scan(select=(:ints, :strs)),
+        Tables.Scan(select=(:strs => :s2, :ints)),
+        Tables.Scan(select=()),
+        Tables.Scan(select=(), filter=Tables.col(:ints) > 2),
+        Tables.Scan(select=(r"s",)),
+        Tables.Scan(select=(Tables.Not(:dict),)),
+        Tables.Scan(select=(:dict,)),
+        Tables.Scan(filter=Tables.col(:ints) > 2),
+        Tables.Scan(select=(:floats,), filter=Tables.col(:ints) > 2),
+        Tables.Scan(select=(:dict,), filter=Tables.isnull(Tables.col(:floats))),
+        Tables.Scan(limit=3),
+        Tables.Scan(offset=7),
+        Tables.Scan(offset=4, limit=3),
+        Tables.Scan(offset=10),
+        Tables.Scan(select=(:ints => Float64,)),
+        Tables.Scan(select=(:ints,), filter=Tables.col(:ints) > 2, limit=2),
+        Tables.Scan(filter=Tables.colin(Tables.col(:strs), ("hey", "last"))),
+        Tables.Scan(filter=Tables.colin(Tables.col(:strs), (missing,))),
+        Tables.Scan(select=(:strs, :lists), filter=Tables.colcmp(==, Tables.col(3), true)),
+        Tables.Scan(
+            select=(:strs => :ints,),
+            filter=Tables.colcmp(==, Tables.col(4), "hey"),
+        ),
+    ]
+    for scan in scans
+        want = Tables.scan(full, scan)
+        for src in (sources(filebytes)..., sources(streambytes)...)
+            got = Arrow.Table(src; scan=scan)
+            @assert _tables_equal(got, want) sprint(show, scan)
+        end
+    end
+    println("differential scans match Tables.scan over the full table ✓")
+
+    # Membership keeps the caller's collection semantics through facade
+    # planning. Sets use `isequal`, so they match NaN and distinguish signed
+    # zero; rebuilding them as tuples would change both results.
+    specialio = IOBuffer()
+    Arrow.write(specialio, (x=[NaN, 0.0, -0.0], id=Int64[1, 2, 3]); file=true)
+    specialbytes = take!(specialio)
+    specialfull = Arrow.Table(copy(specialbytes))
+    for (values, expectedids) in ((Set([NaN]), [1]), (Set([0.0]), [2]))
+        scan = Tables.Scan(select=(:id,), filter=Tables.colin(Tables.col(:x), values))
+        reference = Tables.scan(specialfull, scan)
+        @assert reference.id == expectedids
+        for src in sources(specialbytes)
+            @assert Arrow.Table(src; scan=scan).id == expectedids
+        end
+    end
+    println("facade membership preserves Set NaN and signed-zero semantics ✓")
+
+    # Membership objects need not be iterable. Planning must pass them to
+    # their custom `in` method unchanged.
+    domainscan =
+        Tables.Scan(select=(:id,), filter=Tables.colin(Tables.col(:id), _ScanDomain(2)))
+    @assert Tables.scan(specialfull, domainscan).id == [2]
+    for src in sources(specialbytes)
+        @assert Arrow.Table(src; scan=domainscan).id == [2]
+    end
+    println("facade membership preserves custom non-iterable domains ✓")
+
+    # Nullability is advisory at the reader tier. A window does not inspect an
+    # unread violating batch merely to widen the selected vector. Conforming
+    # batches still match the generic executor's value and schema exactly.
+    nonnullable = Field("x", IntType(64, true); nullable=false)
+    nn_schema = Schema([nonnullable])
+    firstdata = ArrayData(
+        IntType(64, true),
+        2,
+        [BufferSlice(), AC._databuffer(Int64[1, 2])];
+        nullcount=0,
+    )
+    violatingdata = ArrayData(
+        IntType(64, true),
+        2,
+        [AC._databuffer(UInt8[0b10]), AC._databuffer(Int64[0, 3])];
+        nullcount=1,
+    )
+    conformingdata = ArrayData(
+        IntType(64, true),
+        2,
+        [BufferSlice(), AC._databuffer(Int64[3, 4])];
+        nullcount=0,
+    )
+    windowresults(bytes) =
+        Any[Arrow.Table(src; scan=Tables.Scan(limit=2)) for src in sources(bytes)]
+    violatingbytes = writefile(
+        nn_schema,
+        [
+            AC.RecordBatch(nn_schema, [firstdata], 2),
+            AC.RecordBatch(nn_schema, [violatingdata], 2),
+        ],
+    )
+    violatingfull = Arrow.Table(copy(violatingbytes))
+    violatingreference = Tables.scan(violatingfull, Tables.Scan(limit=2))
+    @assert violatingreference.x == [1, 2]
+    @assert eltype(violatingreference.x) === Union{Missing,Int64}
+    for got in windowresults(violatingbytes)
+        @assert got.x == [1, 2]
+        @assert eltype(got.x) === Int64
+    end
+
+    conformingbytes = writefile(
+        nn_schema,
+        [
+            AC.RecordBatch(nn_schema, [firstdata], 2),
+            AC.RecordBatch(nn_schema, [conformingdata], 2),
+        ],
+    )
+    conformingreference =
+        Tables.scan(Arrow.Table(copy(conformingbytes)), Tables.Scan(limit=2))
+    for got in windowresults(conformingbytes)
+        @assert _tables_equal(got, conformingreference)
+    end
+    println("windowed nullability keeps the skip boundary and conforming schema parity ✓")
+
+    # A column's element type is a property of the SCHEMA, not of how many
+    # rows a scan kept: a zero limit, an offset past the input, and a decoded
+    # filter that keeps nothing have exactly the schema of the full scan, from
+    # every kind of source.
+    fullschema = Tables.schema(Arrow.Table(copy(filebytes); scan=Tables.Scan()))
+    for emptyscan in (
+        Tables.Scan(limit=0),
+        Tables.Scan(offset=10_000),
+        Tables.Scan(filter=Tables.col(:ints) > 10_000),
+    )
+        for src in sources(filebytes)
+            got = Arrow.Table(src; scan=emptyscan)
+            @assert Tables.rowcount(got) == 0
+            @assert _schemas_equal(Tables.schema(got), fullschema) sprint(show, emptyscan)
+        end
+    end
+    println("empty scans keep the full scan's schema from every source ✓")
+
+    # The bound scan is consumed exactly: selection, renames, filter, window,
+    # and type overrides all cross the facade once, with no reconstructed
+    # residual.
+    t1 = Arrow.Table(
+        copy(filebytes);
+        scan=Tables.Scan(select=(:ints => :i,), offset=4, limit=3),
+    )
+    @assert collect(Tables.columnnames(t1)) == [:i] && length(t1.i) == 3
+    t2 = Arrow.Table(
+        copy(filebytes);
+        scan=Tables.Scan(select=(:ints,), filter=Tables.col(:ints) > 2, limit=2),
+    )
+    @assert t2.ints == [3, 4]
+    t3 = Arrow.Table(copy(filebytes); scan=Tables.Scan(select=(:ints => Float64,)))
+    @assert eltype(t3.ints) === Float64 && t3.ints == Float64.(full.ints)
+    println("the bound scan is consumed exactly, including type overrides ✓")
+
+    # Type overrides use Tables.jl's allocation seam. This is observable for
+    # scalar types that choose a custom default column container.
+    containerscan = Tables.Scan(select=(:ints => _ScanOverrideValue,))
+    reference = Tables.scan(full, containerscan).ints
+    @assert reference isa _ScanOverrideVector{_ScanOverrideValue}
+    for src in sources(filebytes)
+        overridden = Arrow.Table(src; scan=containerscan).ints
+        @assert typeof(overridden) === typeof(reference)
+        @assert getfield.(overridden, :value) == collect(Int64, full.ints)
+    end
+    println("type overrides honor Tables.allocatecolumn ✓")
+
+    # Extreme-but-valid windows: the sink saturates like Tables.scan, so the
+    # whole pipeline agrees on the empty result.
+    extreme = Tables.Scan(select=(:ints,), offset=typemax(Int), limit=typemax(Int))
+    extremewant = Tables.scan(full, extreme)
+    for src in sources(filebytes)
+        got = Arrow.Table(src; scan=extreme)
+        @assert _tables_equal(got, extremewant)
+        @assert length(got.ints) == 0
+    end
+    println("extreme scan windows saturate to the empty result ✓")
+
+    # Skip proof 1 (columns): corrupt the `strs` OFFSETS buffer of batch 2 so
+    # semantic validation must reject any decode that touches it. Buffer
+    # order: ints(v,d) floats(v,d) bools(v,d) strs(v,o,d) → offsets is #8.
+    off, len = _bufferposition(filebytes, 2, 8)
+    @assert len > 8
+    corrupt = copy(filebytes)
+    corrupt[(off + 5):(off + 8)] .= reinterpret(UInt8, Int32[Int32(2) ^ 30])
+    @assert _rejects(() -> readfile(copy(corrupt))[2])       # full decode sees it
+    @assert _rejects(() -> Arrow.Table(copy(corrupt)))
+    got = Arrow.Table(copy(corrupt); scan=Tables.Scan(select=(:ints, :floats)))
+    @assert isequal(collect(Any, got.ints), collect(Any, full.ints))
+    @assert _rejects(() -> Arrow.Table(copy(corrupt); scan=Tables.Scan(select=(:strs,))))
+    println("skipped columns are never decoded (corruption stays invisible) ✓")
+
+    # Skip proof 2 (batches): the same corruption sits in batch 2; a window
+    # ending inside batch 1 never decodes batch 2 even when selecting strs.
+    got = Arrow.Table(copy(corrupt); scan=Tables.Scan(select=(:strs,), limit=5))
+    # A filter keeps the window in the sink: the window fills inside batch 1,
+    # so batch 2 is never decoded either.
+    gotf = Arrow.Table(
+        copy(corrupt);
+        scan=Tables.Scan(select=(:strs,), filter=Tables.col(:ints) > 0, limit=5),
+    )
+    @assert length(gotf.strs) == 5
+    @assert isequal(collect(Any, got.strs), collect(Any, full.strs[1:5]))
+    @assert _rejects(
+        () -> Arrow.Table(copy(corrupt); scan=Tables.Scan(select=(:strs,), limit=6)),
+    )
+    println("window-excluded batches are never decoded ✓")
+
+    # Buffer-table invariants cannot be weakened by skipping: `skipbuffer!`
+    # shares `_buffermeta!` with `takebuffer!` by construction, so a batch
+    # whose buffers move backwards is refused whichever columns are decoded.
+    overlap = copy(filebytes)
+    block = readfile(copy(filebytes)).recordblocks[1]
+    fmoff = block[1]
+    # rewrite floats-data's declared offset backwards via the metadata:
+    # locate buffer entry 4 inside the block metadata and zero its offset.
+    meta = copy(overlap[(fmoff + 9):(fmoff + block[2])])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    rb = _headertable(meta, msg)
+    start, n = _vvector(rb, 2, 16; required=true)
+    @assert n >= 4
+    _write_i64!(meta, start + 3 * 16, Int64(0))
+    copyto!(overlap, fmoff + 9, meta, 1, length(meta))
+    @assert _rejects(() -> readfile(copy(overlap))[1])
+    for src in sources(overlap)
+        @assert _rejects(() -> Arrow.Table(src; scan=Tables.Scan(select=(:ints,))))
+    end
+    println("buffer-table invariants hold before any skip can run ✓")
+
+    # Duplicate source names.
+    dupfields = Field[
+        Field("x", IntType(64, true), true, nothing, Field[]),
+        Field("x", IntType(64, true), true, nothing, Field[]),
+    ]
+    dupsch = Schema(dupfields)
+    dupcol() = ArrayData(
+        IntType(64, true),
+        1,
+        [BufferSlice(), AC._databuffer(Int64[7])];
+        nullcount=0,
+    )
+    dupbytes = writefile(dupsch, [AC.RecordBatch(dupsch, ArrayData[dupcol(), dupcol()], 1)])
+    # They read as x, x_1, as CSV.jl names them, scans included.
+    dupscan = Arrow.Table(dupbytes; scan=Tables.Scan(select=(2,)))
+    @assert collect(Tables.columnnames(dupscan)) == [:x_1]
+    println("duplicate source names scan as x, x_1 ✓")
+
+    # Window row counts are metadata, but they are not trusted until the
+    # RecordBatch length agrees with every top-level FieldNode. Otherwise a
+    # corrupt skipped batch can shift the window and return valid but wrong
+    # rows from a later batch.
+    xbytes = writefile(
+        readstream(
+            _fixture2x("int64-two-batches") do
+                xio = IOBuffer()
+                Arrow.write(
+                    xio,
+                    Tables.partitioner([
+                        (x=collect(Int64, 1:5),),
+                        (x=collect(Int64, 6:10),),
+                    ]);
+                    file=false,
+                )
+                take!(xio)
+            end,
+        ),
+    )
+    badrows = copy(xbytes)
+    xfile = readfile(copy(xbytes))
+    block = xfile.recordblocks[1]
+    meta = copy(badrows[(block[1] + 9):(block[1] + block[2])])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    rb = _headertable(meta, msg)
+    _write_i64!(meta, _vfield(rb, 0, 8; required=true), Int64(4))
+    copyto!(badrows, block[1] + 9, meta, 1, length(meta))
+    shifted = Tables.Scan(select=(:x,), offset=5, limit=1)
+    for src in sources(badrows)
+        @assert _rejects(() -> Arrow.Table(src; scan=shifted))
+    end
+    println("window row counts require top-level FieldNode agreement ✓")
+
+    # Checked buffer-span addition is required before a zero-row window may
+    # exclude the body. Without it, these three individually valid counts
+    # wrap to the six fixed buffers and make corrupt metadata look exact.
+    ovt = ViewType(true)
+    ovfields = Field[Field("v$i", ovt) for i = 1:3]
+    ovcols = ArrayData[
+        ArrayData(ovt, 1, [BufferSlice(), AC._databuffer(zeros(UInt8, 16))]; nullcount=0) for _ = 1:3
+    ]
+    ovsch = Schema(ovfields)
+    ovbytes = writefile(ovsch, [AC.RecordBatch(ovsch, ovcols, 1)])
+    ovfile = readfile(copy(ovbytes))
+    ovblock = only(ovfile.recordblocks)
+    ovmeta = copy(ovbytes[(ovblock[1] + 9):(ovblock[1] + ovblock[2])])
+    ovmsg = _vtable(ovmeta, Int64(_vu32(ovmeta, 0)))
+    ovrb = _headertable(ovmeta, ovmsg)
+    ovstart, ovn = _vvector(ovrb, 4, 8; required=true)
+    @assert ovn == 3
+    for (i, count) in enumerate(Int64[typemax(Int64) - 2, typemax(Int64) - 2, 6])
+        _write_i64!(ovmeta, ovstart + (i - 1) * 8, count)
+    end
+    copyto!(ovbytes, ovblock[1] + 9, ovmeta, 1, length(ovmeta))
+    overflowed = try
+        badfile = readfile(copy(ovbytes))
+        badfm = _blockmessage(
+            badfile.region,
+            only(badfile.recordblocks),
+            badfile.dataend,
+            badfile.limits,
+            AllocationBudget(badfile.limits.max_total_allocated_bytes),
+        )
+        _recordbatchmeta(
+            badfm.msg.header::Meta.RecordBatch,
+            badfile.fields,
+            badfile.limits,
+            badfm.body.len,
+        )
+        false
+    catch e
+        e isa ValidationError &&
+            occursin("record-batch buffer span overflows", sprint(showerror, e))
+    end
+    @assert overflowed
+    for src in sources(ovbytes)
+        @assert _rejects(() -> Arrow.Table(src; scan=Tables.Scan(limit=0)))
+    end
+    println("overflowing variadic buffer spans reject before window exclusion ✓")
+
+    # A column table cannot infer row count when it has no columns. The table
+    # keeps the RecordBatch lengths so an empty scan remains identity.
+    zerosch = Schema(Field[])
+    zerobatches = AC.RecordBatch[
+        AC.RecordBatch(zerosch, ArrayData[], 3),
+        AC.RecordBatch(zerosch, ArrayData[], 0),
+        AC.RecordBatch(zerosch, ArrayData[], 2),
+    ]
+    zerobytes = writefile(zerosch, zerobatches)
+    for src in sources(zerobytes)
+        got = Arrow.Table(src; scan=Tables.Scan())
+        @assert isempty(Tables.columnnames(got))
+        @assert Tables.rowcount(got) == 5
+    end
+    println("zero-column scans preserve their row count ✓")
+
+    # A zero-column file can declare an addressable row count without body
+    # bytes. The aggregate result must still fit Tables' Int row-count API;
+    # a larger total is refused, whatever the window asks for.
+    maxrows = Int64(typemax(Int))
+    edgebatches = AC.RecordBatch[
+        AC.RecordBatch(zerosch, ArrayData[], maxrows - 1),
+        AC.RecordBatch(zerosch, ArrayData[], 1),
+    ]
+    overflowbatches = AC.RecordBatch[
+        AC.RecordBatch(zerosch, ArrayData[], maxrows),
+        AC.RecordBatch(zerosch, ArrayData[], 1),
+    ]
+    edgebytes = writefile(zerosch, edgebatches)
+    overflowbytes = writefile(zerosch, overflowbatches)
+    edgelimits = Limits(max_array_length=typemax(Int64))
+    limitedsources(bytes) =
+        (copy(bytes), SourceFile(BytesSource(copy(bytes)); limits=edgelimits, tailbytes=32))
+    for src in limitedsources(edgebytes)
+        got = Arrow.Table(src; limits=edgelimits, scan=Tables.Scan())
+        @assert Tables.rowcount(got) == typemax(Int)
+    end
+    for src in limitedsources(overflowbytes),
+        scan in (
+            nothing,
+            Tables.Scan(),
+            Tables.Scan(limit=0),
+            Tables.Scan(offset=1),
+            Tables.Scan(filter=Tables.AlwaysTrue()),
+        )
+
+        @assert _rejects(() -> Arrow.Table(src; limits=edgelimits, scan=scan))
+    end
+    println("unaddressable cumulative row counts fail closed ✓")
+
+    println()
+    println("Tables.Scan pushdown checks passed.")
+    return filebytes, full
+end
+
+function _ranged_main(filebytes::Vector{UInt8}, full)
+    ranged(src; tailbytes=65536, gapbytes=262144) =
+        SourceFile(src; tailbytes=tailbytes, gapbytes=gapbytes)
+
+    # Empty projections keep their row count without requesting a record or
+    # dictionary body. A filtered empty projection requests only its filter
+    # column's buffers. A 32-byte tail and zero gap make every body request
+    # exact and observable in the log.
+    dictionaryblocks, recordblocks = _footerblocks(filebytes)
+    bodyranges = vcat(_bodyrange.(dictionaryblocks), _bodyrange.(recordblocks))
+    emptylog, emptysource = countingsource(filebytes)
+    emptygot = Arrow.Table(
+        ranged(emptysource; tailbytes=32, gapbytes=0);
+        scan=Tables.Scan(select=()),
+    )
+    @assert isempty(Tables.columnnames(emptygot))
+    @assert Tables.rowcount(emptygot) == Tables.rowcount(full)
+    @assert !any(span -> _requestintersects(emptylog, span), bodyranges)
+
+    filteredlog, filteredsource = countingsource(filebytes)
+    filteredscan = Tables.Scan(select=(), filter=Tables.col(:ints) > 2)
+    filteredgot =
+        Arrow.Table(ranged(filteredsource; tailbytes=32, gapbytes=0); scan=filteredscan)
+    @assert _tables_equal(filteredgot, Tables.scan(full, filteredscan))
+    for i = 1:length(recordblocks)
+        buffers = _recordbufferranges(filebytes, i)
+        @assert length(buffers) >= 2
+        @assert _requestintersects(filteredlog, buffers[2])
+        @assert !any(span -> _requestintersects(filteredlog, span), buffers[3:end])
+    end
+    @assert !any(
+        span -> _requestintersects(filteredlog, span),
+        _bodyrange.(dictionaryblocks),
+    )
+    println("empty projections request no output-column body ranges ✓")
+
+    # A Date membership filter keeps `in`'s semantics over a byte-range
+    # source and fetches less than half of the object.
+    dateio = IOBuffer()
+    dates = Arrow.Dates.Date(2024, 1, 1) .+ Arrow.Dates.Day.(0:9_999)
+    Arrow.write(dateio, (d=dates, fat=fill(repeat("x", 128), length(dates))); file=true)
+    datebytes = take!(dateio)
+    targetdate = Arrow.Dates.Date(2024, 3, 1)
+    datescan =
+        Tables.Scan(select=(:d,), filter=Tables.colin(Tables.col(:d), Set([targetdate])))
+    datefull = Arrow.Table(copy(datebytes))
+    datefield = getfield(datefull, :schema).fields[1]
+    datelog, datesource = countingsource(datebytes)
+    dategot = Arrow.Table(ranged(datesource; tailbytes=32, gapbytes=0); scan=datescan)
+    datewant = Tables.scan(datefull, datescan)
+    @assert _tables_equal(dategot, datewant)
+    @assert dategot.d == [targetdate]
+    @assert sum(last, datelog.ranges) < length(datebytes) ÷ 2
+
+    # Tuple membership uses `==`, while Set uses `isequal` plus hashing.
+    # Date and midnight DateTime compare equal; whether they are the same Set
+    # key depends on Julia's Dates hashing (distinct before Julia 1.14), so
+    # the expectation follows Julia's own `in`.
+    datetime = Arrow.Dates.DateTime(2024, 3, 1)
+    for values in (Set([datetime]), (datetime,))
+        expectedrows = targetdate in values ? 1 : 0
+        scan = Tables.Scan(select=(:d,), filter=Tables.colin(Tables.col(:d), values))
+        reference = Tables.scan(datefull, scan)
+        got = Arrow.Table(
+            SourceFile(BytesSource(copy(datebytes)); tailbytes=32, gapbytes=0);
+            scan=scan,
+        )
+        @assert _tables_equal(got, reference)
+        @assert got.d == (expectedrows == 0 ? Arrow.Dates.Date[] : [targetdate])
+    end
+
+    # A custom temporal membership object is not iterable. It must force the
+    # complete filter to the public plan without changing its `in` method.
+    domainscan = Tables.Scan(
+        select=(:d,),
+        filter=Tables.colin(Tables.col(:d), _DateScanDomain(targetdate)),
+    )
+    domainreference = Tables.scan(datefull, domainscan)
+    for source in (copy(datebytes), SourceFile(BytesSource(copy(datebytes)); tailbytes=32))
+        got = Arrow.Table(source; scan=domainscan)
+        @assert _tables_equal(got, domainreference)
+        @assert got.d == [targetdate]
+    end
+
+    # Missing inside a standard membership container also forces a public
+    # plan. Exercise it below negation and composition so three-valued
+    # membership cannot be simplified to plain false.
+    nullableio = IOBuffer()
+    nullable_dates = Union{Missing,Arrow.Dates.Date}[
+        Arrow.Dates.Date(2024, 1, 1),
+        missing,
+        Arrow.Dates.Date(2024, 1, 3),
+    ]
+    Arrow.write(nullableio, (id=Int64[1, 2, 3], d=nullable_dates); file=true)
+    nullablebytes = take!(nullableio)
+    nullablefull = Arrow.Table(copy(nullablebytes))
+    nullablefield = getfield(nullablefull, :schema).fields[2]
+    membership = Tables.colin(Tables.col(:d), (Arrow.Dates.Date(2024, 1, 1), missing))
+    arraymembership = Tables.colin(
+        Tables.col(:d),
+        Union{Missing,Arrow.Dates.Date}[Arrow.Dates.Date(2024, 1, 3), missing],
+    )
+    for (filter, expected) in (
+        (!membership | Tables.isnull(Tables.col(:d)), Int64[2]),
+        (arraymembership & !Tables.isnull(Tables.col(:d)), Int64[3]),
+    )
+        scan = Tables.Scan(select=(:id,), filter=filter)
+        reference = Tables.scan(nullablefull, scan)
+        @assert reference.id == expected
+        for source in (
+            copy(nullablebytes),
+            SourceFile(BytesSource(copy(nullablebytes)); tailbytes=32),
+        )
+            @assert Arrow.Table(source; scan=scan).id == expected
+        end
+    end
+    println("temporal membership preserves container semantics and safe range plans ✓")
+
+    # Dictionary wrappers recurse into their temporal value descriptor during
+    # planning. Exact Date and Timestamp membership lowers; fine-unit
+    # Duration membership stays in the public domain.
+    function temporaldictionary(t, pool, indices)
+        pooldata = Arrow.AC.ArrayData(
+            t,
+            length(pool),
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(pool)];
+            nullcount=0,
+        )
+        dicttype = Arrow.AC.DictionaryType(Arrow.AC.IntType(32, true), t, false)
+        field = Arrow.AC.Field("v", dicttype; nullable=false)
+        data = Arrow.AC.ArrayData(
+            dicttype,
+            length(indices),
+            [Arrow.AC.BufferSlice(), Arrow.AC._databuffer(Int32.(indices))];
+            dictionary=pooldata,
+            nullcount=0,
+        )
+        schema = Arrow.AC.Schema([field])
+        batch = Arrow.AC.RecordBatch(schema, [data], length(indices))
+        return field, Arrow.writefile(schema, [batch])
+    end
+    dictionarycases = (
+        (
+            Arrow.AC.DateType(Arrow.AC.DAY),
+            Int32[0, 1, 2],
+            Int32[0, 1, 2, 1],
+            (Arrow.Dates.Date(1970, 1, 2),),
+            true,
+            Arrow.Dates.Date[Arrow.Dates.Date(1970, 1, 2), Arrow.Dates.Date(1970, 1, 2)],
+        ),
+        (
+            # Timestamp{Second} is a bijection with its counts: the extreme
+            # pool entry does not alias the epoch, so the membership matches
+            # exactly the epoch-valued row.
+            Arrow.AC.TimestampType(Arrow.AC.SECOND, nothing),
+            Int64[0, Int64(1) << 61],
+            Int32[0, 1],
+            (Arrow.Dates.DateTime(1970, 1, 1),),
+            true,
+            [
+                Arrow.Durations.Timestamp{Arrow.Dates.Second}(
+                    Arrow.Dates.UTInstant(Arrow.Dates.Second(0)),
+                ),
+            ],
+        ),
+        (
+            Arrow.AC.DurationType(Arrow.AC.SECOND),
+            Int64[60],
+            Int32[0],
+            (Arrow.Dates.Millisecond(60_000),),
+            false,
+            Arrow.Dates.Second[Arrow.Dates.Second(60)],
+        ),
+    )
+    for (type, pool, indices, values, lowered, expected) in dictionarycases
+        field, bytes = temporaldictionary(type, pool, indices)
+        scan = Tables.Scan(select=(:v,), filter=Tables.colin(Tables.col(:v), values))
+        dictionaryfull = Arrow.Table(copy(bytes))
+        reference = Tables.scan(dictionaryfull, scan)
+        @assert reference.v == expected
+        for source in (copy(bytes), SourceFile(BytesSource(copy(bytes)); tailbytes=32))
+            @assert Arrow.Table(source; scan=scan).v == expected
+        end
+    end
+    println("temporal dictionary scans preserve pushdown and fallback semantics ✓")
+
+    # Byte accounting needs bodies that dwarf metadata: a two-column file
+    # where the fat column is ~7× the narrow one. Selecting the narrow
+    # column must fetch a small fraction of what the full scan fetches.
+    n = 20_000
+    fat(i) = string("padding-padding-padding-padding-padding-", i)
+    bigbytes = writefile(
+        readstream(
+            _fixture2x("wide-two-batches") do
+                bigio = IOBuffer()
+                Arrow.write(
+                    bigio,
+                    Tables.partitioner([
+                        (a=collect(Int64, 1:n), b=[fat(i) for i = 1:n]),
+                        (a=collect(Int64, (n + 1):(2n)), b=[fat(i) for i = (n + 1):(2n)]),
+                    ]);
+                    file=false,
+                )
+                take!(bigio)
+            end,
+        ),
+    )
+    logall, srcall = countingsource(bigbytes)
+    Arrow.Table(ranged(srcall; tailbytes=256, gapbytes=64); scan=Tables.Scan())
+    logone, srcone = countingsource(bigbytes)
+    Arrow.Table(ranged(srcone; tailbytes=256, gapbytes=64); scan=Tables.Scan(select=(:a,)))
+    @assert logone.bytes < logall.bytes ÷ 4 (logone.bytes, logall.bytes)
+    println(
+        "narrow selections fetch a fraction of the bytes " *
+        "($(logone.bytes) vs $(logall.bytes) of $(length(bigbytes))) ✓",
+    )
+
+    # Skipped-column range proof: corrupt an unselected column's buffer ON THE
+    # SOURCE. The scan plans no body range for it; under this fixture's small
+    # tail and zero coalescing gap, the request log also excludes that byte.
+    off, len = _bufferposition(filebytes, 2, 8)          # strs offsets, batch 2
+    corrupt = copy(filebytes)
+    corrupt[(off + 5):(off + 8)] .= reinterpret(UInt8, Int32[Int32(2) ^ 30])
+    logc, srcc = countingsource(corrupt)
+    got = Arrow.Table(
+        ranged(srcc; tailbytes=256, gapbytes=0);
+        scan=Tables.Scan(select=(:ints,)),
+    )
+    @assert isequal(collect(Any, got.ints), collect(Any, full.ints))
+    @assert !_fetched(logc, off + 5)
+    @assert _rejects(
+        () -> Arrow.Table(ranged(BytesSource(corrupt)); scan=Tables.Scan(select=(:strs,))),
+    )
+    println(
+        "skipped columns add no planned body range " *
+        "(fixture request log excludes the corruption) ✓",
+    )
+
+    # Window proof: a limit inside batch 1 plans no batch-2 body range. This
+    # fixture's request log also excludes sampled batch-2 body bytes.
+    block2 = recordblocks[2]
+    body2 = (block2[1] + block2[2], block2[3])
+    logw, srcw = countingsource(filebytes)
+    Arrow.Table(
+        ranged(srcw; tailbytes=256, gapbytes=0);
+        scan=Tables.Scan(select=(:strs,), limit=5),
+    )
+    @assert !any(_fetched(logw, body2[1] + k) for k = 0:8:(body2[2] - 1))
+    println("window-excluded batches add no planned body range ✓")
+
+    # A dictionary body gets a planned range only when its column is in the
+    # decode set. The zero-gap fixture also checks the observed request spans.
+    @assert length(dictionaryblocks) == 1
+    dictblock = dictionaryblocks[1]
+    dictblockbody = (dictblock[1] + dictblock[2], dictblock[3])
+    lognod, srcnod = countingsource(filebytes)
+    Arrow.Table(
+        ranged(srcnod; tailbytes=256, gapbytes=0);
+        scan=Tables.Scan(select=(:ints,)),
+    )
+    @assert !any(_fetched(lognod, dictblockbody[1] + k) for k = 0:8:(dictblockbody[2] - 1))
+    logd, srcd = countingsource(filebytes)
+    Arrow.Table(ranged(srcd; tailbytes=256, gapbytes=0); scan=Tables.Scan(select=(:dict,)))
+    @assert any(_fetched(logd, dictblockbody[1] + k) for k = 0:8:(dictblockbody[2] - 1))
+    logd0, srcd0 = countingsource(filebytes)
+    Arrow.Table(
+        ranged(srcd0; tailbytes=256, gapbytes=0);
+        scan=Tables.Scan(select=(:dict,), limit=0),
+    )
+    @assert !any(_fetched(logd0, dictblockbody[1] + k) for k = 0:8:(dictblockbody[2] - 1))
+    println("dictionary body ranges are planned only for decode-set ids ✓")
+
+    # A dictionary batch has its own variadic-count cursor. Keep that cursor
+    # when the dictionary values use a view layout, including the legal zero
+    # count for an all-inline pool. A following plain field pins record-batch
+    # alignment after the dictionary is installed.
+    scanviewentry(s) = _viewentry(ncodeunits(s), collect(codeunits(s)))
+    dvt = ViewType(true)
+    dvpool = ArrayData(
+        dvt,
+        2,
+        [BufferSlice(), AC._databuffer(vcat(scanviewentry("a"), scanviewentry("view")))];
+        nullcount=0,
+    )
+    dvtpe = DictionaryType(IntType(32, true), dvt, false)
+    dvf = Field("dictview", dvtpe; nullable=false)
+    dvd = ArrayData(
+        dvtpe,
+        3,
+        [BufferSlice(), AC._databuffer(Int32[0, 1, 0])];
+        dictionary=dvpool,
+        nullcount=0,
+    )
+    dvtailf, dvtaild = fromjulia("tail", Int64[7, 8, 9])
+    dvsch = Schema(Field[dvf, dvtailf])
+    dvbytes = writefile(dvsch, [AC.RecordBatch(dvsch, ArrayData[dvd, dvtaild], 3)])
+    dvgot = Arrow.Table(
+        ranged(BytesSource(copy(dvbytes)));
+        scan=Tables.Scan(select=(:dictview, :tail)),
+    )
+    @assert collect(Any, dvgot.dictview) == Any["a", "view", "a"]
+    @assert collect(Any, dvgot.tail) == Any[7, 8, 9]
+    println("ranged dictionary views consume their own variadic counts ✓")
+
+    # A selected dictionary id missing from the Footer is a metadata-only
+    # refusal. It must fail before any dedicated record-body request.
+    missingdict = copy(filebytes)
+    footerlen = Int64(reinterpret(Int32, missingdict[(end - 9):(end - 6)])[1])
+    footerstart = Int64(length(missingdict)) - 10 - footerlen
+    footerbytes = copy(missingdict[(footerstart + 1):(footerstart + footerlen)])
+    footertable = _vtable(footerbytes, Int64(_vu32(footerbytes, 0)))
+    _write_u32!(footerbytes, _vref(footertable, 2; required=true), UInt32(0))
+    copyto!(missingdict, footerstart + 1, footerbytes, 1, length(footerbytes))
+    missingrecords = verify_footer(footerbytes, Limits())[4]
+    missingscan = Tables.Scan(select=(:dict,))
+    @assert _rejects(() -> Arrow.Table(copy(missingdict); scan=missingscan))
+    logmissing, srcmissing = countingsource(missingdict)
+    @assert _rejects(
+        () -> Arrow.Table(ranged(srcmissing; tailbytes=32, gapbytes=0); scan=missingscan),
+    )
+    @assert !any(_fetched(logmissing, block[1] + block[2]) for block in missingrecords)
+    println("missing dictionary plans reject before dedicated record-body requests ✓")
+
+    # Coalescing: an infinite gap merges every body range into one request;
+    # a zero gap issues more, smaller requests; both agree with the truth.
+    # (A small tail window, so the ranges are planned rather than served
+    # from the cached tail.)
+    twoscan = Tables.Scan(select=(:ints, :strs))
+    logbig, srcbig = countingsource(filebytes)
+    gotbig =
+        Arrow.Table(ranged(srcbig; tailbytes=256, gapbytes=typemax(Int32)); scan=twoscan)
+    logzero, srczero = countingsource(filebytes)
+    gotzero = Arrow.Table(ranged(srczero; tailbytes=256, gapbytes=0); scan=twoscan)
+    want = Tables.scan(full, twoscan)
+    @assert _tables_equal(gotbig, want) && _tables_equal(gotzero, want)
+    @assert logbig.requests < logzero.requests
+    @assert logzero.bytes <= logbig.bytes
+    @assert _coalesce(NTuple{2,Int64}[(0, 8), (16, 8)], typemax(Int64)) ==
+            NTuple{2,Int64}[(0, 24)]
+    @assert try
+        _coalesce(NTuple{2,Int64}[(0, 8)], Int64(-1))
+        false
+    catch e
+        e isa ArgumentError
+    end
+    println(
+        "coalescing trades requests for bytes without changing results " *
+        "($(logbig.requests) reqs/$(logbig.bytes)B vs $(logzero.requests) reqs/$(logzero.bytes)B) ✓",
+    )
+
+    # A tail smaller than the footer forces the exact follow-up fetch.
+    logt, srct = countingsource(filebytes)
+    gott = Arrow.Table(ranged(srct; tailbytes=32); scan=Tables.Scan(select=(:ints,)))
+    @assert isequal(collect(Any, gott.ints), collect(Any, full.ints))
+    println("undersized tails recover with one exact footer fetch ✓")
+
+    # Retained tail/Footer payloads cost no new allocation on a later scan.
+    # The verifier's own expansion charges still apply on every parse.
+    cachelog, cachesource = countingsource(filebytes)
+    cachefile = SourceFile(cachesource; tailbytes=32)
+    cachecap = Limits().max_total_allocated_bytes
+    firstbudget = AllocationBudget(cachecap)
+    _readfooter(cachefile, cachefile.limits, firstbudget)
+    firstrequests = length(cachelog.ranges)
+    secondbudget = AllocationBudget(cachecap)
+    _readfooter(cachefile, cachefile.limits, secondbudget)
+    footerlen = Int64(reinterpret(Int32, filebytes[(end - 9):(end - 6)])[1])
+    footerstart = Int64(length(filebytes)) - 10 - footerlen
+    tailstart = Int64(length(filebytes)) - 32
+    cachedallocation = AC._materializedvectorbytes(UInt8, 32)
+    footerstart < tailstart &&
+        (cachedallocation += AC._materializedvectorbytes(UInt8, footerlen))
+    firstused = cachecap - _remaining(firstbudget)
+    secondused = cachecap - _remaining(secondbudget)
+    @assert firstused - secondused == cachedallocation
+    @assert length(cachelog.ranges) == firstrequests
+
+    # Compressed files range-read identically (per-buffer frames are
+    # self-contained behind their prefixes).
+    zsource = readstream(
+        _fixture2x("int64-strings-two-batches") do
+            io = IOBuffer()
+            Arrow.write(
+                io,
+                Tables.partitioner([
+                    (x=Int64[1, 2, 3], s=["a", "bb", "ccc"]),
+                    (x=Int64[4, 5, 6], s=["dd", "e", "ff"]),
+                ]);
+                file=false,
+            )
+            take!(io)
+        end,
+    )
+    zbytes = writefile(zsource; compress=:zstd)
+    zfull = Arrow.Table(copy(zbytes))
+    logz, srcz = countingsource(zbytes)
+    gotz =
+        Arrow.Table(ranged(srcz; tailbytes=256, gapbytes=0); scan=Tables.Scan(select=(:x,)))
+    @assert isequal(collect(Any, gotz.x), collect(Any, zfull.x))
+    @assert logz.bytes < length(zbytes)
+    println("compressed files range-read through self-contained buffers ✓")
+
+    # Every failure derivable from the selected metadata plan precedes its
+    # first body request. Skipped columns and window-excluded batches keep
+    # their intentional lazy boundary.
+    block1 = recordblocks[1]
+    badfixed = _setbufferlength!(copy(filebytes), block1, 2, Int64(1))
+    fixedoff, _ = _bufferposition(filebytes, 1, 2)
+    @assert _rejects(() -> Arrow.Table(copy(badfixed); scan=Tables.Scan(select=(:ints,))))
+    logfixed, srcfixed = countingsource(badfixed)
+    @assert _rejects(
+        () -> Arrow.Table(
+            ranged(srcfixed; tailbytes=32, gapbytes=0);
+            scan=Tables.Scan(select=(:ints,)),
+        ),
+    )
+    @assert !_fetched(logfixed, fixedoff)
+    skipped = Arrow.Table(
+        ranged(BytesSource(copy(badfixed)); tailbytes=32, gapbytes=0);
+        scan=Tables.Scan(select=(:floats,)),
+    )
+    @assert isequal(collect(Any, skipped.floats), collect(Any, full.floats))
+
+    validbytes = writefile(
+        readstream(_fixture2x("nullable-int64-sixteen") do
+            validio = IOBuffer()
+            validdata = Union{Missing,Int64}[missing; collect(Int64, 2:16)]
+            Arrow.write(validio, (x=validdata,); file=false)
+            take!(validio)
+        end),
+    )
+    validfile = readfile(copy(validbytes))
+    badvalid = _setbufferlength!(copy(validbytes), validfile.recordblocks[1], 1, Int64(1))
+    validpos, _ = _bufferposition(validbytes, 1, 1)
+    logvalid, srcvalid = countingsource(badvalid)
+    @assert _rejects(
+        () -> Arrow.Table(
+            ranged(srcvalid; tailbytes=32, gapbytes=0);
+            scan=Tables.Scan(select=(:x,)),
+        ),
+    )
+    @assert !_fetched(logvalid, validpos)
+    validbudget = AllocationBudget(validfile.limits.max_total_allocated_bytes)
+    validmsg = _blockmessage(
+        validfile.region,
+        validfile.recordblocks[1],
+        validfile.dataend,
+        validfile.limits,
+        validbudget,
+    )
+    validfield = validfile.fields[1]
+    strictfield = Field(
+        validfield.name,
+        validfield.type,
+        false,
+        validfield.metadata,
+        validfield.children,
+    )
+    validheader = validmsg.msg.header::Meta.RecordBatch
+    validcodec = _batchcodec(validheader.compression, validmsg.version)
+    # Field.nullable is advisory: the planned path accepts the strict
+    # declaration over data with nulls, exactly as the whole-file path does
+    # (validate_full is where the declaration is enforced).
+    @assert _validatebodyplan(
+        validheader,
+        (strictfield,),
+        validfile.limits,
+        validcodec,
+        Bool[true],
+    ) == 2
+
+    structbytes = writefile(
+        readstream(
+            _fixture2x("nullable-struct-child") do
+                structio = IOBuffer()
+                structdata = NamedTuple{(:n,),Tuple{Union{Missing,Int64}}}[
+                    (n=missing,),
+                    (n=Int64(2),),
+                ]
+                Arrow.write(structio, (x=structdata,); file=false)
+                take!(structio)
+            end,
+        ),
+    )
+    structfile = readfile(copy(structbytes))
+    structbudget = AllocationBudget(structfile.limits.max_total_allocated_bytes)
+    structmsg = _blockmessage(
+        structfile.region,
+        structfile.recordblocks[1],
+        structfile.dataend,
+        structfile.limits,
+        structbudget,
+    )
+    parentfield = structfile.fields[1]
+    childfield = parentfield.children[1]
+    strictchild = Field(
+        childfield.name,
+        childfield.type,
+        false,
+        childfield.metadata,
+        childfield.children,
+    )
+    strictparent = Field(
+        parentfield.name,
+        parentfield.type,
+        parentfield.nullable,
+        parentfield.metadata,
+        [strictchild],
+    )
+    structheader = structmsg.msg.header::Meta.RecordBatch
+    structcodec = _batchcodec(structheader.compression, structmsg.version)
+    @assert _validatebodyplan(
+        structheader,
+        (strictparent,),
+        structfile.limits,
+        structcodec,
+        Bool[true],
+    ) == 2
+
+    emptylistbytes = writefile(readstream(_fixture2x("empty-string-list") do
+        emptylistio = IOBuffer()
+        Arrow.write(emptylistio, (x=[String[]],); file=false)
+        take!(emptylistio)
+    end))
+    emptylistfile = readfile(copy(emptylistbytes))
+    emptylistblock = emptylistfile.recordblocks[1]
+    bademptyoffset = _setbufferlength!(copy(emptylistbytes), emptylistblock, 4, Int64(0))
+    parentoffsetpos, _ = _bufferposition(emptylistbytes, 1, 2)
+    logemptyoffset, srcemptyoffset = countingsource(bademptyoffset)
+    @assert _rejects(
+        () -> Arrow.Table(
+            ranged(srcemptyoffset; tailbytes=32, gapbytes=0);
+            scan=Tables.Scan(select=(:x,)),
+        ),
+    )
+    @assert !_fetched(logemptyoffset, parentoffsetpos)
+
+    badoffsets = _setbufferlength!(copy(filebytes), block1, 8, Int64(4))
+    offsetpos, _ = _bufferposition(filebytes, 1, 8)
+    logoffsets, srcoffsets = countingsource(badoffsets)
+    @assert _rejects(
+        () -> Arrow.Table(
+            ranged(srcoffsets; tailbytes=32, gapbytes=0);
+            scan=Tables.Scan(select=(:strs,)),
+        ),
+    )
+    @assert !_fetched(logoffsets, offsetpos)
+
+    badstruct = _setnodelength!(copy(filebytes), block1, 8, Int64(4))
+    structpos, _ = _bufferposition(filebytes, 1, 16)
+    logstruct, srcstruct = countingsource(badstruct)
+    @assert _rejects(
+        () -> Arrow.Table(
+            ranged(srcstruct; tailbytes=32, gapbytes=0);
+            scan=Tables.Scan(select=(:structs,)),
+        ),
+    )
+    @assert !_fetched(logstruct, structpos)
+
+    nullfield = Field("n", NullType())
+    sparsetype = UnionType(AC.SparseMode, Int8[0])
+    sparsefield = Field("u", sparsetype; children=[nullfield])
+    nulldata = ArrayData(NullType(), 1, BufferSlice[]; nullcount=1)
+    sparsedata = ArrayData(
+        sparsetype,
+        1,
+        [AC._databuffer(Int8[0])];
+        children=[nulldata],
+        nullcount=0,
+    )
+    sparseschema = Schema([sparsefield])
+    sparsebytes = writefile(sparseschema, [AC.RecordBatch(sparseschema, [sparsedata], 1)])
+    sparsefile = readfile(copy(sparsebytes))
+    sparseblock = sparsefile.recordblocks[1]
+    sparsepos, _ = _bufferposition(sparsebytes, 1, 1)
+    sparsefailures = (
+        _setnodenullcount!(
+            _setnodelength!(copy(sparsebytes), sparseblock, 2, Int64(2)),
+            sparseblock,
+            2,
+            Int64(2),
+        ),
+        _setnodenullcount!(copy(sparsebytes), sparseblock, 1, Int64(1)),
+        _setnodenullcount!(copy(sparsebytes), sparseblock, 2, Int64(0)),
+    )
+    for broken in sparsefailures
+        logsparse, srcsparse = countingsource(broken)
+        @assert _rejects(
+            () -> Arrow.Table(
+                ranged(srcsparse; tailbytes=32, gapbytes=0);
+                scan=Tables.Scan(select=(:u,)),
+            ),
+        )
+        @assert !_fetched(logsparse, sparsepos)
+    end
+
+    zfile = readfile(copy(zbytes))
+    zblock = zfile.recordblocks[1]
+    compressedpos, _ = _bufferposition(zbytes, 1, 2)
+    for badlen in (Int64(1), Int64(8))
+        badcompressed = _setbufferlength!(copy(zbytes), zblock, 2, badlen)
+        logcompressed, srccompressed = countingsource(badcompressed)
+        @assert _rejects(
+            () -> Arrow.Table(
+                ranged(srccompressed; tailbytes=32, gapbytes=0);
+                scan=Tables.Scan(select=(:x,)),
+            ),
+        )
+        @assert !_fetched(logcompressed, compressedpos)
+    end
+
+    baddict = _setbufferlength!(copy(filebytes), dictblock, 2, Int64(1))
+    logbaddict, srcbaddict = countingsource(baddict)
+    @assert _rejects(
+        () -> Arrow.Table(
+            ranged(srcbaddict; tailbytes=32, gapbytes=0);
+            scan=Tables.Scan(select=(:dict,)),
+        ),
+    )
+    @assert !any(
+        _fetched(logbaddict, dictblockbody[1] + k) for k = 0:8:(dictblockbody[2] - 1)
+    )
+    skippeddict = Arrow.Table(
+        ranged(BytesSource(copy(baddict)); tailbytes=32, gapbytes=0);
+        scan=Tables.Scan(select=(:ints,)),
+    )
+    @assert isequal(collect(Any, skippeddict.ints), collect(Any, full.ints))
+
+    badwindow = _setbufferlength!(copy(filebytes), recordblocks[2], 2, Int64(1))
+    windowpos, _ = _bufferposition(filebytes, 2, 2)
+    logwindow, srcwindow = countingsource(badwindow)
+    windowed = Arrow.Table(
+        ranged(srcwindow; tailbytes=32, gapbytes=0);
+        scan=Tables.Scan(select=(:ints,), limit=5),
+    )
+    @assert isequal(collect(Any, windowed.ints), collect(Any, full.ints[1:5]))
+    @assert !_fetched(logwindow, windowpos)
+    println("planned metadata failures reject before dedicated body requests ✓")
+
+    # Legacy V4 message-level compression is rejected from metadata even when
+    # limit=0 leaves no body to decode.
+    legacyv4, legacyblock = _legacyv4file()
+    legacyscan = Tables.Scan(select=(:x,), limit=0)
+    @assert _rejects(() -> Arrow.Table(copy(legacyv4); scan=legacyscan))
+    loglegacy, srclegacy = countingsource(legacyv4)
+    @assert _rejects(
+        () -> Arrow.Table(ranged(srclegacy; tailbytes=32, gapbytes=0); scan=legacyscan),
+    )
+    @assert !_fetched(loglegacy, legacyblock[1] + legacyblock[2])
+    println("legacy compression rejects before dedicated record-body requests ✓")
+
+    # Hostile inputs fail closed: forged footer length, overlapping Blocks,
+    # out-of-body zero-length buffers, and truncated objects.
+    badlen = copy(filebytes)
+    lenpos = length(badlen) - 9
+    badlen[lenpos:(lenpos + 3)] .= reinterpret(UInt8, Int32[Int32(2) ^ 30])
+    @assert _rejects(() -> Arrow.Table(ranged(BytesSource(badlen)); scan=Tables.Scan()))
+    @assert _rejects(
+        () -> Arrow.Table(ranged(BytesSource(filebytes[1:20])); scan=Tables.Scan()),
+    )
+
+    overlap = copy(filebytes)
+    footerlen = Int64(reinterpret(Int32, overlap[(end - 9):(end - 6)])[1])
+    footerstart = Int64(length(overlap)) - 10 - footerlen
+    footerbytes = copy(overlap[(footerstart + 1):(footerstart + footerlen)])
+    footertable = _vtable(footerbytes, Int64(_vu32(footerbytes, 0)))
+    recordstart, nrecords = _vvector(footertable, 3, 24; required=true)
+    @assert nrecords >= 2
+    firstblock = verify_footer(footerbytes, Limits())[4][1]
+    _write_i64!(footerbytes, recordstart + 24, firstblock[1])
+    _write_i32!(footerbytes, recordstart + 32, Int32(firstblock[2]))
+    _write_i64!(footerbytes, recordstart + 40, firstblock[3])
+    copyto!(overlap, footerstart + 1, footerbytes, 1, length(footerbytes))
+    @assert _rejects(() -> readfile(copy(overlap)))
+    @assert _rejects(() -> Arrow.Table(ranged(BytesSource(overlap)); scan=Tables.Scan()))
+
+    zerobuffer = copy(filebytes)
+    block = recordblocks[1]
+    meta = copy(zerobuffer[(block[1] + 9):(block[1] + block[2])])
+    msg = _vtable(meta, Int64(_vu32(meta, 0)))
+    rb = _headertable(meta, msg)
+    bufferstart, _ = _vvector(rb, 2, 16; required=true)
+    _write_i64!(meta, bufferstart, block[3] + 8)
+    copyto!(zerobuffer, block[1] + 9, meta, 1, length(meta))
+    @assert _rejects(() -> readfile(copy(zerobuffer))[1])
+    @assert _rejects(() -> Arrow.Table(copy(zerobuffer); scan=Tables.Scan(select=(:ints,))))
+    @assert _rejects(
+        () ->
+            Arrow.Table(ranged(BytesSource(zerobuffer)); scan=Tables.Scan(select=(:ints,))),
+    )
+    println("forged footers and truncated objects fail closed ✓")
+
+    # Ranged limits are checked before dedicated body requests. One whole-file
+    # Scan also keeps one aggregate budget across every batch it decompresses.
+    @assert _rejects(
+        () -> Arrow.Table(
+            SourceFile(BytesSource(filebytes); limits=Limits(max_body_bytes=32));
+            scan=Tables.Scan(select=(:ints,)),
+        ),
+    )
+    @assert _rejects(
+        () -> Arrow.Table(
+            SourceFile(BytesSource(filebytes); limits=Limits(max_messages=1));
+            scan=Tables.Scan(),
+        ),
+    )
+    loglimit, srclimit = countingsource(filebytes)
+    intoff, _ = _bufferposition(filebytes, 1, 2)
+    @assert _rejects(
+        () -> Arrow.Table(
+            SourceFile(
+                srclimit;
+                limits=Limits(max_buffer_bytes=8),
+                tailbytes=256,
+                gapbytes=0,
+            );
+            scan=Tables.Scan(select=(:ints,)),
+        ),
+    )
+    @assert !_fetched(loglimit, intoff)
+
+    largebytes = writefile(
+        readstream(
+            _fixture2x("large-zeros-two-partitions") do
+                large = (x=zeros(Int64, 10_000),)
+                largeio = IOBuffer()
+                Arrow.write(largeio, Tables.partitioner([large, large]); file=false)
+                take!(largeio)
+            end,
+        );
+        compress=:zstd,
+    )
+    tight = Limits(max_total_allocated_bytes=100_000)
+    @assert _rejects(
+        () -> Arrow.Table(copy(largebytes); limits=tight, scan=Tables.Scan(select=(:x,))),
+    )
+    @assert _rejects(
+        () -> Arrow.Table(
+            SourceFile(BytesSource(largebytes); limits=tight);
+            scan=Tables.Scan(select=(:x,)),
+        ),
+    )
+
+    # The first scan owns a newly fetched tail too. A large tail must not sit
+    # outside the cumulative budget, even when an empty projection needs no
+    # record body.
+    tailio = IOBuffer()
+    Arrow.write(tailio, (x=collect(Int64, 1:5_000),); file=true)
+    tailfilebytes = take!(tailio)
+    taillog, tailsource = countingsource(tailfilebytes)
+    tailtight = Limits(max_total_allocated_bytes=32_000)
+    tailerror = try
+        Arrow.Table(
+            SourceFile(tailsource; limits=tailtight, tailbytes=length(tailfilebytes));
+            scan=Tables.Scan(select=()),
+        )
+        nothing
+    catch e
+        e
+    end
+    @assert tailerror isa AllocationLimitError
+    @assert occursin("tail range fetch", sprint(showerror, tailerror))
+    @assert isempty(taillog.ranges)
+
+    println("range limits and scan-wide allocation budgets fail before overuse ✓")
+
+    println()
+    println("Byte-range scan checks passed.")
+end
diff --git a/test/sharedvalues.jl b/test/sharedvalues.jl
new file mode 100644
index 00000000..c492d2ea
--- /dev/null
+++ b/test/sharedvalues.jl
@@ -0,0 +1,147 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+using Test, Arrow, DataDecimals, Durations, DataStrings, Tables
+@testset "Registered shared values" begin
+    for D in (
+        DataDecimals.Decimal32{2},
+        DataDecimals.Decimal64{2},
+        DataDecimals.Decimal128{2},
+        DataDecimals.Decimal256{2},
+    )
+        values = Union{Missing,D}[D("12.34"), missing, D("-0.01")]
+        io = IOBuffer()
+        Arrow.write(io, (; x=values))
+        bytes = take!(io)
+        table = Arrow.Table(bytes)
+        @test isequal(table.x, values)
+        # Written as decimal128 (precision <= 38) or decimal256, whatever the
+        # storage type, as pyarrow, Polars, and DuckDB write decimals.
+        P = D.parameters[1]
+        W = P <= 38 ? Int128 : DataDecimals.Int256
+        @test getfield(table, :schema).fields[1].type.bits == 8sizeof(W)
+        @test eltype(table.x) == Union{Missing,DataDecimals.Decimal{P,2,W}}
+        selected = Arrow.Table(
+            bytes;
+            scan=Tables.Scan(filter=Tables.colcmp(>, Tables.col(:x), 20)),
+        )
+        @test isempty(selected.x)
+        for sparse in (D[], Union{Missing,D}[missing, missing])
+            buffer = IOBuffer()
+            Arrow.write(buffer, (; x=sparse))
+            @test isequal(Arrow.Table(take!(buffer)).x, sparse)
+        end
+        io = IOBuffer()
+        Arrow.write(io, table)
+        @test isequal(Arrow.Table(take!(io)).x, values)
+    end
+    values = Union{Missing,Durations.Duration}[
+        Durations.Duration(2, -3, 4),
+        missing,
+        Durations.Duration(0, 0, -1),
+    ]
+    io = IOBuffer()
+    Arrow.write(io, (; x=values))
+    table = Arrow.Table(take!(io))
+    @test isequal(table.x, values)
+    io = IOBuffer()
+    Arrow.write(io, table)
+    @test isequal(Arrow.Table(take!(io)).x, values)
+end
+
+@testset "decimal columns write their storage directly" begin
+    AC = Arrow.ArrowCore
+    D = DataDecimals.Decimal128{2}
+    n = 100_000
+    plain = [reinterpret(D, Int128(i)) for i = 1:n]
+    nullable = Union{Missing,D}[isodd(i) ? plain[i] : missing for i = 1:n]
+    for x in (plain, nullable, view(plain, 2:n), Tables.partitioner([plain, plain]))
+        tbl = x isa AbstractVector ? (; x=x) : Tables.partitioner([(; x=p) for p in x.x])
+        io = IOBuffer()
+        Arrow.write(io, tbl)
+        expected = x isa AbstractVector ? x : vcat(plain, plain)
+        @test isequal(Arrow.Table(take!(io)).x, expected)
+    end
+    # One allocation per row before: a coefficient byte vector per value.
+    Arrow.write(IOBuffer(), (; x=nullable))
+    @test @allocations(Arrow.write(IOBuffer(), (; x=nullable))) < 1_000
+    @test @allocations(Arrow.write(IOBuffer(), (; x=plain))) < 1_000
+    # Narrower storage widens to decimal128 in one pass, not per value.
+    small = [reinterpret(DataDecimals.Decimal32{2}, Int32(i)) for i = 1:n]
+    Arrow.write(IOBuffer(), (; x=small))
+    @test @allocations(Arrow.write(IOBuffer(), (; x=small))) < 1_000
+    io = IOBuffer()
+    Arrow.write(io, (; x=small))
+    @test Arrow.Table(take!(io)).x == small
+    # Precision is advisory, as in Arrow C++: an out-of-precision coefficient
+    # (only reachable through `reinterpret`) writes as stored.
+    io = IOBuffer()
+    Arrow.write(
+        io,
+        (; x=[reinterpret(DataDecimals.Decimal32{2}, Int32(1_000_000_000))]);
+        file=true,
+    )
+    data = AC.rolebuffer(Arrow.readfile(take!(io))[1].columns[1], AC.DATA)
+    @test AC.loadat(data, Int128, 0) == 1_000_000_000
+end
+
+@testset "decimals past their precision rewrite as stored" begin
+    # Arrow C++ (pyarrow) writes such coefficients as stored, and so does a
+    # read-then-rewrite, from the table or from plain values.
+    AC = Arrow.ArrowCore
+    for (bits, T) in ((32, Int32), (128, Int128))
+        t = AC.DecimalType(3, 2, bits)
+        stored = T[100_000, -7]   # 1000.00 has more digits than precision 3
+        d = AC.ArrayData(t, 2, [AC.BufferSlice(), AC._databuffer(stored)])
+        sch = AC.Schema([AC.Field("x", t; nullable=false)])
+        src = Arrow.Table(Arrow.writefile(sch, [AC.RecordBatch(sch, [d], 2)]))
+        @test DataDecimals.unscaled.(src.x) == stored
+        for back in (src, (; x=collect(src.x)))
+            again = Arrow.Table(Arrow.tobuffer(back))
+            @test DataDecimals.unscaled.(again.x) == stored
+        end
+    end
+end
+
+@testset "mixed decimal precisions name the column" begin
+    mixed = Any[Decimal{5,2}("1.25"), Decimal{7,3}("1.255")]
+    err = @test_throws ArgumentError Arrow.write(IOBuffer(), (t=mixed,))
+    @test occursin("column t mixes decimal types", err.value.msg)
+    err = @test_throws ArgumentError Arrow.write(IOBuffer(), (t=DataDecimals.Decimal[],))
+    @test occursin("column t is an empty decimal column", err.value.msg)
+end
+
+@testset "small-precision decimals write as decimal128" begin
+    # Arrow 2.x reads only decimal128/256 (it read decimal32/64 data as
+    # garbage); pyarrow, Polars, and DuckDB write decimal128 here too.
+    io = IOBuffer()
+    Arrow.write(io, (price=[dec"1.25", dec"-3.10"], qty=Decimal{10,2}.(["1.50", "2.00"])))
+    t = Arrow.Table(take!(io))
+    @test [f.type.bits for f in getfield(t, :schema).fields] == [128, 128]
+    @test t.price == [dec"1.25", dec"-3.10"]
+    @test t.qty == Decimal{10,2}.(["1.50", "2.00"])
+    # A rewrite keeps a retained decimal32 column's width.
+    AC = Arrow.ArrowCore
+    t32 = AC.DecimalType(9, 2, 32)
+    d = AC.ArrayData(t32, 2, [AC.BufferSlice(), AC._databuffer(Int32[125, -310])])
+    sch = AC.Schema([AC.Field("x", t32; nullable=false)])
+    src = Arrow.Table(Arrow.writestream(sch, [AC.RecordBatch(sch, [d], 2)]))
+    io = IOBuffer()
+    Arrow.write(io, src)
+    back = Arrow.Table(take!(io))
+    @test getfield(back, :schema).fields[1].type.bits == 32
+    @test back.x == [dec"1.25", dec"-3.10"]
+end
diff --git a/test/stream_lifetime_tests.jl b/test/stream_lifetime_tests.jl
new file mode 100644
index 00000000..f6a30e4a
--- /dev/null
+++ b/test/stream_lifetime_tests.jl
@@ -0,0 +1,56 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module StreamLifetimeTests
+
+using Test, Arrow, Tables
+
+function poolref(stream)
+    table, state = iterate(stream)
+    @test collect(table.category) == ["first"]
+    pool = only(keys(getfield(stream, :views).pools))
+    return WeakRef(pool), state
+end
+
+@testset "streams release obsolete dictionary caches" begin
+    io = IOBuffer()
+    Arrow.Writer(io; dictreplacement=true) do writer
+        Arrow.write(writer, (category=Arrow.DictEncode(["first"]),))
+        Arrow.write(writer, (category=Arrow.DictEncode(["second"]),))
+        Arrow.write(writer, (category=Arrow.DictEncode(["second"]),))
+    end
+    bytes = take!(io)
+    for scan in (nothing, Tables.Scan(select=(:category,)))
+        stream = Arrow.Stream(IOBuffer(bytes); scan)
+        oldpool, state = poolref(stream)
+        second, state = iterate(stream, state)
+        third, state = iterate(stream, state)
+        @test collect(second.category) == collect(third.category) == ["second"]
+        GC.gc(true)
+        GC.gc(true)
+        @test oldpool.value === nothing
+        @test iterate(stream, state) === nothing
+    end
+
+    stream = Arrow.Stream(IOBuffer(bytes))
+    first, state = iterate(stream)
+    second, _ = iterate(stream, state)
+    GC.gc(true)
+    @test collect(first.category) == ["first"]
+    @test collect(second.category) == ["second"]
+end
+
+end
diff --git a/test/support/AcceptanceSupport.jl b/test/support/AcceptanceSupport.jl
new file mode 100644
index 00000000..0fbaf02d
--- /dev/null
+++ b/test/support/AcceptanceSupport.jl
@@ -0,0 +1,171 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+
+module AcceptanceSupport
+
+import Arrow
+using PooledArrays
+using Tables
+import Dates
+
+const AC = Arrow.AC
+
+# The acceptance implementation deliberately exercises private adapter and
+# Core seams. Keep that dependency explicit: adding or removing one of these
+# names is a reviewable test-interface change, not an automatic consequence of
+# an unrelated package binding.
+import Arrow:
+    ARROW_FLAG_DICTIONARY_ORDERED,
+    ARROW_FLAG_MAP_KEYS_SORTED,
+    AllocationBudget,
+    AllocationLimitError,
+    ArrayData,
+    ArrowFile,
+    ArrowType,
+    BinaryType,
+    BoolType,
+    BufferSlice,
+    CArrowArray,
+    CArrowArrayStream,
+    CArrowSchema,
+    CODEC_LZ4_FRAME,
+    CODEC_ZSTD,
+    CONTINUATION,
+    DateType,
+    DecimalType,
+    DecodeCursor,
+    DecodeState,
+    DictionaryType,
+    DurationType,
+    EINVAL,
+    EXPORTS,
+    EXPERIMENTAL_COMPRESSION_KEY,
+    FB,
+    FILE_MAGIC,
+    Field,
+    FixedSizeBinaryType,
+    FixedSizeListType,
+    ForeignOwner,
+    ImportedStream,
+    IPCStream,
+    IntType,
+    IntervalType,
+    Limits,
+    ListType,
+    ListViewType,
+    MapType,
+    Meta,
+    NullType,
+    OwnerRegion,
+    REGISTRY_LOCK,
+    RecordBatch,
+    ReleaseCounter,
+    RunEndEncodedType,
+    Schema,
+    SourceFile,
+    StreamOwner,
+    StructType,
+    TimeType,
+    TimestampType,
+    UnionType,
+    Utf8Type,
+    ValidationError,
+    ViewType,
+    _ArrowTypesRoutedUnion,
+    _VTable,
+    _batchcodec,
+    _batchfield,
+    _blockmessage,
+    _coalesce,
+    _coremetatype,
+    _decompressbuffer!,
+    _framemessages,
+    _metaschema!,
+    _moveowner,
+    _readfooter,
+    _reap!,
+    _RETIRED,
+    _recordbatchmeta,
+    _release_c!,
+    _remaining,
+    _requirelittleendian,
+    _store_field!,
+    _structarray,
+    _validateblockindex,
+    _validatebodyplan,
+    _vfield,
+    _vi32,
+    _vi64,
+    _vrange,
+    _vref,
+    _vtable,
+    _vu32,
+    _vu8,
+    _vvector,
+    assigndictids,
+    batch,
+    export_stream!,
+    formatstring,
+    framemessages,
+    from_c_data,
+    from_c_stream,
+    fromjulia,
+    getvalue,
+    heapregion,
+    increment!,
+    layoutspec,
+    materialize,
+    mmapregion,
+    nextbatch!,
+    nullcount,
+    parseformat,
+    readfile,
+    readstream,
+    release!,
+    to_c_data,
+    validate_full,
+    validate_semantic,
+    validatedictionaryids,
+    validaterecordcolumns,
+    variadiccounts,
+    verify_footer,
+    verify_ipc_metadata,
+    writefile,
+    writestream
+
+include(joinpath(@__DIR__, "cdata_stress.jl"))
+include(joinpath(@__DIR__, "..", "battery_helpers.jl"))
+include(joinpath(@__DIR__, "..", "ipc_read_battery.jl"))
+include(joinpath(@__DIR__, "..", "ipc_write_battery.jl"))
+include(joinpath(@__DIR__, "..", "cdata_battery.jl"))
+include(joinpath(@__DIR__, "..", "scan_battery.jl"))
+
+function _run_scan_acceptance()
+    filebytes, full = _scan_main()
+    _ranged_main(filebytes, full)
+    return nothing
+end
+
+"The stable acceptance names and their throwing runners, in execution order."
+acceptance_suites() = (
+    "IPC read acceptance" => ipc_read_battery,
+    "IPC write acceptance" => ipc_write_battery,
+    "C data acceptance" => cdata_battery,
+    "Scan acceptance" => _run_scan_acceptance,
+)
+
+end # module AcceptanceSupport
diff --git a/test/support/CDataStressSupport.jl b/test/support/CDataStressSupport.jl
new file mode 100644
index 00000000..189ddd56
--- /dev/null
+++ b/test/support/CDataStressSupport.jl
@@ -0,0 +1,40 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module CDataStressSupport
+
+import Arrow:
+    CArrowArray,
+    CArrowSchema,
+    EXPORTS,
+    ForeignOwner,
+    REGISTRY_LOCK,
+    ReleaseCounter,
+    Table,
+    _moveowner,
+    _reap!,
+    _release_c!,
+    _store_field!,
+    fromjulia,
+    increment!,
+    release!,
+    to_c_data
+
+include("cdata_stress.jl")
+
+run() = _threaded_cdata_stress()
+
+end # module CDataStressSupport
diff --git a/test/support/SeededFuzz.jl b/test/support/SeededFuzz.jl
new file mode 100644
index 00000000..8560f3dd
--- /dev/null
+++ b/test/support/SeededFuzz.jl
@@ -0,0 +1,2203 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module SeededFuzz
+
+using Arrow
+using DataStrings
+using DataStrings: StringVector, StringPayload, BytesVector, DataBytes
+using ArrowTypes
+import Durations
+using Dates
+using Tables
+
+const DEFAULT_SEED = UInt64(0x9f5a_37c2_41de_880b)
+const PR_CASES = 16
+const PR_MUTATIONS = 64
+const EXTENDED_CASES = 512
+const EXTENDED_MUTATIONS = 20_000
+
+function _parseseed(value::AbstractString)
+    cleaned = replace(strip(value), "_" => "")
+    isempty(cleaned) && throw(ArgumentError("empty seed"))
+    if startswith(lowercase(cleaned), "0x")
+        length(cleaned) > 2 || throw(ArgumentError("empty hexadecimal seed"))
+        return parse(UInt64, cleaned[3:end]; base=16)
+    end
+    return parse(UInt64, cleaned)
+end
+
+function _parsecount(flag::AbstractString, value::AbstractString)
+    count = parse(Int, value)
+    count >= 0 || throw(ArgumentError("$flag must be nonnegative"))
+    return count
+end
+
+function _takevalue(args, index::Int, flag::AbstractString)
+    index < length(args) || throw(ArgumentError("$flag requires a value"))
+    return args[index + 1], index + 1
+end
+
+"Parse one fuzz command and isolate every exact-replay mode from other lanes."
+function parse_options(args)
+    seed = DEFAULT_SEED
+    cases = EXTENDED_CASES
+    mutations = EXTENDED_MUTATIONS
+    case_index = nothing
+    mutation_index = nothing
+    mutation_file = nothing
+    mutation_lane = nothing
+    layouts_only = false
+    include_layouts = true
+    verify_determinism = false
+    determinism_every = 0
+    reproduction_dir = nothing
+    index = 1
+    while index <= length(args)
+        arg = args[index]
+        if arg == "--help" || arg == "-h"
+            return (;
+                help=true,
+                seed,
+                cases,
+                mutations,
+                case_index,
+                mutation_index,
+                mutation_file,
+                mutation_lane,
+                layouts_only,
+                include_layouts,
+                verify_determinism,
+                determinism_every,
+                reproduction_dir,
+            )
+        elseif arg == "--seed"
+            value, index = _takevalue(args, index, arg)
+            seed = _parseseed(value)
+        elseif startswith(arg, "--seed=")
+            seed = _parseseed(arg[(length("--seed=") + 1):end])
+        elseif arg == "--cases"
+            value, index = _takevalue(args, index, arg)
+            cases = _parsecount(arg, value)
+        elseif startswith(arg, "--cases=")
+            cases = _parsecount("--cases", arg[(length("--cases=") + 1):end])
+        elseif arg == "--mutations"
+            value, index = _takevalue(args, index, arg)
+            mutations = _parsecount(arg, value)
+        elseif startswith(arg, "--mutations=")
+            mutations = _parsecount("--mutations", arg[(length("--mutations=") + 1):end])
+        elseif arg == "--case-index"
+            value, index = _takevalue(args, index, arg)
+            case_index = _parsecount(arg, value)
+            case_index >= 1 || throw(ArgumentError("--case-index must be positive"))
+        elseif startswith(arg, "--case-index=")
+            case_index = _parsecount(arg, arg[(length("--case-index=") + 1):end])
+            case_index >= 1 || throw(ArgumentError("--case-index must be positive"))
+        elseif arg == "--mutation-index"
+            value, index = _takevalue(args, index, arg)
+            mutation_index = _parsecount(arg, value)
+            mutation_index >= 1 || throw(ArgumentError("--mutation-index must be positive"))
+        elseif startswith(arg, "--mutation-index=")
+            mutation_index = _parsecount(arg, arg[(length("--mutation-index=") + 1):end])
+            mutation_index >= 1 || throw(ArgumentError("--mutation-index must be positive"))
+        elseif arg == "--mutation-file"
+            value, index = _takevalue(args, index, arg)
+            isempty(value) && throw(ArgumentError("--mutation-file must not be empty"))
+            mutation_file = value
+        elseif startswith(arg, "--mutation-file=")
+            mutation_file = arg[(length("--mutation-file=") + 1):end]
+            isempty(mutation_file) &&
+                throw(ArgumentError("--mutation-file must not be empty"))
+        elseif arg == "--mutation-lane"
+            value, index = _takevalue(args, index, arg)
+            mutation_lane = Symbol(value)
+        elseif startswith(arg, "--mutation-lane=")
+            mutation_lane = Symbol(arg[(length("--mutation-lane=") + 1):end])
+        elseif arg == "--layouts-only"
+            layouts_only = true
+        elseif arg == "--skip-layouts"
+            include_layouts = false
+        elseif arg == "--determinism-every"
+            value, index = _takevalue(args, index, arg)
+            determinism_every = _parsecount(arg, value)
+        elseif startswith(arg, "--determinism-every=")
+            determinism_every = _parsecount(
+                "--determinism-every",
+                arg[(length("--determinism-every=") + 1):end],
+            )
+        elseif arg == "--repro-dir"
+            value, index = _takevalue(args, index, arg)
+            isempty(value) && throw(ArgumentError("--repro-dir must not be empty"))
+            reproduction_dir = value
+        elseif startswith(arg, "--repro-dir=")
+            value = arg[(length("--repro-dir=") + 1):end]
+            isempty(value) && throw(ArgumentError("--repro-dir must not be empty"))
+            reproduction_dir = value
+        else
+            throw(ArgumentError("unknown option $arg"))
+        end
+        index += 1
+    end
+    mutation_file === nothing &&
+        mutation_lane !== nothing &&
+        throw(ArgumentError("--mutation-lane requires --mutation-file"))
+    mutation_file !== nothing &&
+        mutation_lane === nothing &&
+        throw(ArgumentError("--mutation-file requires --mutation-lane"))
+    mutation_lane === nothing ||
+        mutation_lane in (:stream_full, :file_full, :file_ranged, :auto_full) ||
+        throw(ArgumentError("invalid --mutation-lane $mutation_lane"))
+    layouts_only &&
+        !include_layouts &&
+        throw(ArgumentError("--layouts-only and --skip-layouts are incompatible"))
+    layouts_only &&
+        (
+            case_index !== nothing ||
+            mutation_index !== nothing ||
+            mutation_file !== nothing
+        ) &&
+        throw(ArgumentError("--layouts-only cannot be combined with a replay option"))
+    case_index !== nothing &&
+        mutation_index !== nothing &&
+        throw(ArgumentError("use one exact generated replay option at a time"))
+    mutation_file !== nothing &&
+        (case_index !== nothing || mutation_index !== nothing) &&
+        throw(ArgumentError("saved-byte replay cannot be combined with generated replay"))
+
+    # An exact generated replay must not fail in an unrelated generated or
+    # deterministic-layout lane. The selected index still runs when its count
+    # is zero because the index replaces the lane range.
+    if case_index !== nothing || mutation_index !== nothing
+        cases = 0
+        mutations = 0
+        include_layouts = false
+        verify_determinism = mutation_index !== nothing
+    end
+    return (;
+        help=false,
+        seed,
+        cases,
+        mutations,
+        case_index,
+        mutation_index,
+        mutation_file,
+        mutation_lane,
+        layouts_only,
+        include_layouts,
+        verify_determinism,
+        determinism_every,
+        reproduction_dir,
+    )
+end
+
+const _SPLITMIX_GAMMA = UInt64(0x9e37_79b9_7f4a_7c15)
+const _SPLITMIX_MUL1 = UInt64(0xbf58_476d_1ce4_e5b9)
+const _SPLITMIX_MUL2 = UInt64(0x94d0_49bb_1331_11eb)
+const _DIFFERENTIAL_LANE = UInt64(0x4449_4646_4552_454e)
+const _SCAN_LANE = UInt64(0x5343_414e_5f4c_414e)
+const _MUTATION_LANE = UInt64(0x4d55_5441_5449_4f4e)
+
+const TEXT =
+    ["", "a", "\0", "alpha", "\u03bb", "\u03b1\u03b2\u2200", "\U0001f9ea", "line\nbreak"]
+
+# Every mutated read is constrained before metadata-directed allocation. These
+# limits are intentionally far above the tiny valid seed corpus, but far below
+# the package defaults. A mutation cannot turn this test into an OOM probe.
+const STRICT_LIMITS = Arrow.Limits(
+    max_metadata_bytes=Int64(256 * 1024),
+    max_body_bytes=Int64(2 * 1024 * 1024),
+    max_buffer_bytes=Int64(512 * 1024),
+    max_total_allocated_bytes=Int64(8 * 1024 * 1024),
+    max_messages=256,
+    max_metadata_objects=100_000,
+    max_nesting_depth=32,
+    max_array_length=Int64(100_000),
+)
+
+"A reproducible fuzz failure with both its master and independently derived seed."
+struct FuzzFailure <: Exception
+    lane::Symbol
+    index::Int
+    master_seed::UInt64
+    case_seed::UInt64
+    message::String
+end
+function Base.showerror(io::IO, err::FuzzFailure)
+    print(
+        io,
+        "$(err.lane) fuzz case $(err.index) " *
+        "(master_seed=0x$(string(err.master_seed; base=16)), " *
+        "case_seed=0x$(string(err.case_seed; base=16))) failed: ",
+        err.message,
+    )
+end
+
+struct DifferentialCase{I,P,E}
+    seed::UInt64
+    inputs::I
+    expectedparts::P
+    expected::E
+end
+
+struct DifferentialSummary
+    seed::UInt64
+    cases::Int
+    variants::Int
+    rewrites::Int
+    scanchecks::Int
+    layoutchecks::Int
+    coverage::Set{Symbol}
+end
+
+struct MutationSummary
+    seed::UInt64
+    mutations::Int
+    counts::Dict{Symbol,Int}
+    routecounts::Dict{Tuple{Symbol,Symbol},Int}
+    operationcounts::Dict{Symbol,Int}
+    determinismchecks::Int
+end
+
+struct FuzzSummary
+    differential::DifferentialSummary
+    mutations::MutationSummary
+end
+
+mutable struct FuzzBytesSource <: Arrow.AbstractArrowSource
+    data::Vector{UInt8}
+    requests::Vector{NTuple{2,Int64}}
+end
+FuzzBytesSource(data::Vector{UInt8}) = FuzzBytesSource(data, NTuple{2,Int64}[])
+Arrow.sourcelength(source::FuzzBytesSource) = length(source.data)
+function Arrow.readrange(source::FuzzBytesSource, offset, len)
+    n = length(source.data)
+    (offset isa Integer && len isa Integer && offset >= 0 && len >= 0) ||
+        throw(BoundsError(source.data, (offset, len)))
+    (len <= n && offset <= n - len) || throw(BoundsError(source.data, (offset, len)))
+    push!(source.requests, (Int64(offset), Int64(len)))
+    return copy(@view source.data[(offset + 1):(offset + len)])
+end
+
+_rangesintersect(a::NTuple{2,Int64}, b::NTuple{2,Int64}) =
+    a[2] > 0 && b[2] > 0 && a[1] < b[1] + b[2] && b[1] < a[1] + a[2]
+
+"One SplitMix64 output. This is independent of Random's global state."
+@inline function _splitmix64(x::UInt64)
+    z = x + _SPLITMIX_GAMMA
+    z = xor(z, z >> 30) * _SPLITMIX_MUL1
+    z = xor(z, z >> 27) * _SPLITMIX_MUL2
+    return xor(z, z >> 31)
+end
+
+"Derive an independent seed for one numbered lane case."
+function case_seed(master::UInt64, index::Integer; lane::UInt64=_DIFFERENTIAL_LANE)
+    index >= 1 || throw(ArgumentError("fuzz case indices start at 1"))
+    return _splitmix64(xor(master, _splitmix64(UInt64(index)), lane))
+end
+
+"A fixed SplitMix64 stream. Its output is independent of Julia and Random versions."
+mutable struct StableRNG
+    state::UInt64
+end
+
+@inline function _next!(rng::StableRNG)
+    rng.state += _SPLITMIX_GAMMA
+    z = rng.state
+    z = xor(z, z >> 30) * _SPLITMIX_MUL1
+    z = xor(z, z >> 27) * _SPLITMIX_MUL2
+    return xor(z, z >> 31)
+end
+
+function _below(rng::StableRNG, bound::Integer)
+    bound > 0 || throw(ArgumentError("random bound must be positive"))
+    n = UInt64(bound)
+    threshold = mod(-n, n)
+    while true
+        value = _next!(rng)
+        value >= threshold && return Int(mod(value, n))
+    end
+end
+
+_index(rng::StableRNG, n::Integer) = _below(rng, n) + 1
+_range(rng::StableRNG, first::Integer, last::Integer) =
+    Int(first) + _below(rng, Int(last) - Int(first) + 1)
+_choice(rng::StableRNG, values) = values[_index(rng, length(values))]
+_random(::Type{UInt64}, rng::StableRNG) = _next!(rng)
+_random(::Type{Int64}, rng::StableRNG) = reinterpret(Int64, _next!(rng))
+_random(::Type{UInt32}, rng::StableRNG) = UInt32(_next!(rng) & typemax(UInt32))
+_random(::Type{Int32}, rng::StableRNG) = reinterpret(Int32, _random(UInt32, rng))
+_random(::Type{UInt16}, rng::StableRNG) = UInt16(_next!(rng) & typemax(UInt16))
+_random(::Type{Int16}, rng::StableRNG) = reinterpret(Int16, _random(UInt16, rng))
+_random(::Type{UInt8}, rng::StableRNG) = UInt8(_next!(rng) & typemax(UInt8))
+_random(::Type{Bool}, rng::StableRNG) = isodd(_next!(rng))
+
+_maybe(rng, value) = _range(rng, 1, 5) == 1 ? missing : value
+
+function _randomfloat(rng)
+    specials = (0.0, -0.0, Inf, -Inf, NaN)
+    pick = _range(rng, 1, 8)
+    pick <= length(specials) && return specials[pick]
+    # A stable finite IEEE-754 value in [-1, 1). This uses no libm path.
+    bits = (_next!(rng) & UInt64(0x000f_ffff_ffff_ffff)) | UInt64(0x3ff0_0000_0000_0000)
+    value = reinterpret(Float64, bits) - 1.0
+    return isodd(_next!(rng)) ? -value : value
+end
+
+function _makepart(rng, n::Int)
+    ints = Union{Missing,Int64}[_maybe(rng, _random(Int64, rng)) for _ = 1:n]
+    uints = Union{Missing,UInt64}[_maybe(rng, _random(UInt64, rng)) for _ = 1:n]
+    floats = Union{Missing,Float64}[_maybe(rng, _randomfloat(rng)) for _ = 1:n]
+    bools = Union{Missing,Bool}[_maybe(rng, _random(Bool, rng)) for _ = 1:n]
+    strings = Union{Missing,String}[_maybe(rng, _choice(rng, TEXT)) for _ = 1:n]
+    dates = Union{Missing,Date}[
+        _maybe(rng, Date(1970, 1, 1) + Day(_range(rng, -100_000, 100_000))) for _ = 1:n
+    ]
+    lists = Vector{Union{Missing,Vector{Union{Missing,Int32}}}}(undef, n)
+    StructRow = @NamedTuple{x::Union{Missing,Int16}, label::Union{Missing,String}}
+    structs = Vector{Union{Missing,StructRow}}(undef, n)
+    dictionary = Union{Missing,String}[_maybe(rng, _choice(rng, TEXT)) for _ = 1:n]
+    for i = 1:n
+        lists[i] =
+            _range(rng, 1, 5) == 1 ? missing :
+            Union{Missing,Int32}[
+                _maybe(rng, _random(Int32, rng)) for _ = 1:_range(rng, 0, 6)
+            ]
+        structs[i] =
+            _range(rng, 1, 5) == 1 ? missing :
+            (x=_maybe(rng, _random(Int16, rng)), label=_maybe(rng, _choice(rng, TEXT)))
+    end
+    input = (
+        ints=ints,
+        uints=uints,
+        floats=floats,
+        bools=bools,
+        strings=strings,
+        dates=dates,
+        lists=lists,
+        structs=structs,
+        dictionary=Arrow.DictEncode(dictionary),
+    )
+    return input, merge(input, (dictionary=dictionary,))
+end
+
+function _concatparts(parts)
+    names = keys(first(parts))
+    return NamedTuple{names}(
+        map(names) do name
+            reduce(vcat, (getproperty(part, name) for part in parts); init=Any[])
+        end,
+    )
+end
+
+function make_case(master::UInt64, index::Integer)
+    seed = case_seed(master, index)
+    rng = StableRNG(seed)
+    nparts = _range(rng, 1, 4)
+    made = [_makepart(rng, _range(rng, 0, 20)) for _ = 1:nparts]
+    inputs = first.(made)
+    expectedparts = last.(made)
+    return DifferentialCase(seed, inputs, expectedparts, _concatparts(expectedparts))
+end
+
+function ipcbytes(table; file::Bool, compress::Symbol)
+    io = IOBuffer()
+    Arrow.write(io, table; file=file, compress=compress)
+    return take!(io)
+end
+
+_expectedstructs(values) = values
+
+const _GENERATED_PUBLIC_ELTYPES = (
+    ints=Union{Missing,Int64},
+    uints=Union{Missing,UInt64},
+    floats=Union{Missing,Float64},
+    bools=Union{Missing,Bool},
+    strings=Union{Missing,DataString},
+    dates=Union{Missing,Date},
+    lists=Union{Missing,Arrow.ListValue{Union{Missing,Int32}}},
+    structs=Union{
+        Missing,
+        @NamedTuple{x::Union{Missing,Int16},label::Union{Missing,DataString}},
+    },
+    dictionary=Union{Missing,DataString},
+)
+
+_fail(message) = throw(ErrorException(message))
+_require(ok::Bool, message) = ok || _fail(message)
+
+"Check the generated native table against Arrow's documented facade shapes."
+function check_expected_table(actual, expected; label::AbstractString="table")
+    _require(
+        collect(Tables.columnnames(actual)) == collect(keys(expected)),
+        "$label column names differ",
+    )
+    for name in keys(_GENERATED_PUBLIC_ELTYPES)
+        column = Tables.getcolumn(actual, name)
+        expectedeltype = getproperty(_GENERATED_PUBLIC_ELTYPES, name)
+        _require(
+            eltype(column) === expectedeltype,
+            "$label column $name has $(eltype(column)); expected $expectedeltype",
+        )
+        got = collect(column)
+        want =
+            name === :structs ? _expectedstructs(expected.structs) :
+            getproperty(expected, name)
+        _require(isequal(got, want), "$label column $name differs")
+    end
+    return nothing
+end
+
+"Check exact public Tables.scan parity, including empty-projection row counts."
+function _check_same_table(actual, expected; label::AbstractString)
+    actualnames = collect(Tables.columnnames(actual))
+    expectednames = collect(Tables.columnnames(expected))
+    _require(actualnames == expectednames, "$label column names differ")
+    _require(
+        Tables.rowcount(actual) == Tables.rowcount(expected),
+        "$label row counts differ",
+    )
+    for i in eachindex(expectednames)
+        got = Tables.getcolumn(actual, i)
+        want = Tables.getcolumn(expected, i)
+        _require(
+            isequal(collect(got), collect(want)),
+            "$label column $(expectednames[i]) differs",
+        )
+        _require(
+            eltype(got) === eltype(want),
+            "$label column $(expectednames[i]) has $(eltype(got)); expected $(eltype(want))",
+        )
+    end
+    return nothing
+end
+
+"Check a layout against values constructed without the Arrow writer or reader."
+# List or map rows as a typed read gives them: views of one vector of
+# `E` values, `missing` for a null row.
+function _rowviews(::Type{E}, rows; nullable::Bool=false) where {E}
+    values = E[]
+    spans = UnitRange{Int}[]
+    for row in rows
+        start = length(values) + 1
+        row === missing || append!(values, row)
+        push!(spans, start:length(values))
+    end
+    V = Arrow.ListValue{E}
+    T = nullable ? Union{Missing,V} : V
+    return T[
+        row === missing ? missing : V(values, first(span) - 1, length(span)) for
+        (row, span) in zip(rows, spans)
+    ]
+end
+
+# `Pair{K,V}` entries as `Arrow.MapValue`s, `missing` for a null row.
+function _maprowviews(::Type{K}, ::Type{V}, rows; nullable::Bool=false) where {K,V}
+    keys, values = K[], V[]
+    spans = UnitRange{Int}[]
+    for row in rows
+        start = length(keys) + 1
+        if row !== missing
+            for (k, v) in row
+                push!(keys, k)
+                push!(values, v)
+            end
+        end
+        push!(spans, start:length(keys))
+    end
+    # Rows read their keys and values back as the reader stores them.
+    function store(::Type{E}, xs) where {E}
+        C = Arrow._columntype(E)
+        return xs isa C ? xs : Arrow._storeas(C, xs, nothing)
+    end
+    kcol, vcol = store(K, keys), store(V, values)
+    M = Arrow.MapValue{K,V}
+    T = nullable ? Union{Missing,M} : M
+    return T[
+        row === missing ? missing : M(kcol, vcol, first(span) - 1, length(span)) for
+        (row, span) in zip(rows, spans)
+    ]
+end
+
+function _check_expected_layout(actual, expected; label::AbstractString)
+    actualnames = collect(Tables.columnnames(actual))
+    expectednames = collect(keys(expected))
+    _require(actualnames == expectednames, "$label column names differ")
+    nrows = Tables.rowcount(actual)
+    for name in expectednames
+        actualcolumn = Tables.getcolumn(actual, name)
+        want = getproperty(expected, name)
+        _require(
+            eltype(actualcolumn) === eltype(want),
+            "$label column $name has $(eltype(actualcolumn)); expected $(eltype(want))",
+        )
+        got = collect(actualcolumn)
+        _require(length(got) == nrows, "$label column $name has the wrong length")
+        _require(isequal(got, want), "$label column $name differs from its native oracle")
+    end
+    return nothing
+end
+
+_metadataentries(metadata) =
+    metadata === nothing ? Pair{String,String}[] : collect(Pair{String,String}, metadata)
+
+function _check_same_field(actual, expected, path::String)
+    _require(actual.name == expected.name, "$path name differs")
+    _require(Arrow.AC.typeequal(actual.type, expected.type), "$path descriptor differs")
+    _require(actual.nullable == expected.nullable, "$path nullability differs")
+    _require(
+        _metadataentries(actual.metadata) == _metadataentries(expected.metadata),
+        "$path metadata differs",
+    )
+    _require(
+        length(actual.children) == length(expected.children),
+        "$path child count differs",
+    )
+    for i in eachindex(expected.children)
+        _check_same_field(actual.children[i], expected.children[i], "$path.$i")
+    end
+    return nothing
+end
+
+function _check_schema(actualschema, expectedschema; label::AbstractString)
+    _require(
+        actualschema !== nothing && expectedschema !== nothing,
+        "$label lost its schema",
+    )
+    _require(
+        actualschema.endianness == expectedschema.endianness,
+        "$label schema endianness differs",
+    )
+    _require(
+        _metadataentries(actualschema.metadata) ==
+        _metadataentries(expectedschema.metadata),
+        "$label schema metadata differs",
+    )
+    _require(
+        length(actualschema.fields) == length(expectedschema.fields),
+        "$label field count differs",
+    )
+    for i in eachindex(expectedschema.fields)
+        _check_same_field(
+            actualschema.fields[i],
+            expectedschema.fields[i],
+            "$label field $i",
+        )
+    end
+    return nothing
+end
+
+function _check_same_schema(actual, expected; label::AbstractString)
+    return _check_schema(getfield(actual, :schema), getfield(expected, :schema); label)
+end
+
+function _check_original_schema(actual, expected; label::AbstractString)
+    return _check_schema(getfield(actual, :schema), expected; label)
+end
+
+function _dateneedle(values)
+    for value in values
+        ismissing(value) || return value
+    end
+    return Date(1970, 1, 1)
+end
+
+function _temporalscan(index::Int, dates)
+    needle = _dateneedle(dates)
+    noon = DateTime(needle) + Hour(12)
+    mode = mod1(index, 6)
+    filter, label = if mode == 1
+        (Tables.colcmp(==, Tables.col(:dates), needle), :date_scalar)
+    elseif mode == 2
+        (Tables.colin(Tables.col(:dates), (needle,)), :date_tuple)
+    elseif mode == 3
+        (Tables.colin(Tables.col(:dates), Date[needle]), :date_array)
+    elseif mode == 4
+        (Tables.colin(Tables.col(:dates), Set([needle])), :date_set)
+    elseif mode == 5
+        (Tables.colcmp(!=, Tables.col(:dates), noon), :date_datetime)
+    else
+        (Tables.colin(Tables.col(:dates), (noon, needle)), :date_datetime_tuple)
+    end
+    scan = Tables.Scan(select=(:strings => :text, :dates), filter=filter)
+    return (; scan, label)
+end
+
+function _scans(master::UInt64, index::Int, dates)
+    rng = StableRNG(case_seed(master, index; lane=_SCAN_LANE))
+    offset = _range(rng, 0, 8)
+    limit = _range(rng, 0, 8)
+    threshold = Int64(_range(rng, -8, 8))
+    needle = _choice(rng, TEXT)
+    return (
+        (scan=Tables.Scan(), label=:identity),
+        (scan=Tables.Scan(select=(:ints, :strings, :dictionary)), label=:projection),
+        _temporalscan(index, dates),
+        (
+            scan=Tables.Scan(select=(), filter=Tables.isnull(Tables.col(:ints))),
+            label=:null_filter,
+        ),
+        (
+            scan=Tables.Scan(
+                select=(:ints => Float64 => :as_float, :floats),
+                filter=Tables.colcmp(>, Tables.col(:ints), threshold),
+                limit=limit,
+            ),
+            label=:comparison,
+        ),
+        (
+            scan=Tables.Scan(
+                select=(:strings,),
+                filter=Tables.colin(Tables.col(:strings), (needle, missing)),
+                offset=offset,
+            ),
+            label=:string_membership,
+        ),
+    )
+end
+
+_rewritecodec(codec::Symbol) = codec === :none ? :zstd : codec === :zstd ? :lz4 : :none
+
+struct FuzzExtensionID
+    value::Int64
+end
+Base.:(==)(a::FuzzExtensionID, b::FuzzExtensionID) = a.value == b.value
+Base.isequal(a::FuzzExtensionID, b::FuzzExtensionID) = isequal(a.value, b.value)
+const _FUZZ_EXTENSION_NAME = Symbol("JuliaLang.Arrow.FuzzExtensionID")
+ArrowTypes.ArrowType(::Type{FuzzExtensionID}) = Int64
+ArrowTypes.toarrow(value::FuzzExtensionID) = value.value
+ArrowTypes.arrowname(::Type{FuzzExtensionID}) = _FUZZ_EXTENSION_NAME
+ArrowTypes.JuliaType(::Val{_FUZZ_EXTENSION_NAME}, ::Type{Int64}, metadata) = FuzzExtensionID
+ArrowTypes.fromarrow(::Type{FuzzExtensionID}, value::Int64) = FuzzExtensionID(value)
+
+struct FuzzExtensionPoint
+    x::Int32
+    y::Int32
+end
+Base.:(==)(a::FuzzExtensionPoint, b::FuzzExtensionPoint) = a.x == b.x && a.y == b.y
+Base.isequal(a::FuzzExtensionPoint, b::FuzzExtensionPoint) =
+    isequal(a.x, b.x) && isequal(a.y, b.y)
+const _FUZZ_POINT_NAME = Symbol("JuliaLang.Arrow.FuzzExtensionPoint")
+const _FuzzPointStorage = @NamedTuple{y::Int32, x::Int32}
+ArrowTypes.ArrowType(::Type{FuzzExtensionPoint}) = _FuzzPointStorage
+ArrowTypes.toarrow(value::FuzzExtensionPoint) = (y=value.y, x=value.x)
+ArrowTypes.arrowname(::Type{FuzzExtensionPoint}) = _FUZZ_POINT_NAME
+ArrowTypes.arrowmetadata(::Type{FuzzExtensionPoint}) = "seeded-fuzz"
+ArrowTypes.JuliaType(::Val{_FUZZ_POINT_NAME}, S, metadata) = FuzzExtensionPoint
+function ArrowTypes.fromarrowstruct(
+    ::Type{FuzzExtensionPoint},
+    ::Val{names},
+    values...,
+) where {names}
+    row = NamedTuple{names}(values)
+    return FuzzExtensionPoint(row.x, row.y)
+end
+
+struct LayoutCase{E}
+    label::Symbol
+    schema::Arrow.AC.Schema
+    batches::Vector{Arrow.AC.RecordBatch}
+    expected::E
+    retained::Bool
+    coverage::Set{Symbol}
+end
+
+function _logical_layout_case()
+    raw = collect(codeunits("tiny-a-view-value-longer-than-twelve-bytes"))
+    longstart = findfirst(==(UInt8('a')), raw)
+    longlength = length(raw) - longstart + 1
+    payloads = DataStrings.StringPayload[
+        DataStrings.inline_payload(raw, 1, 4),
+        DataStrings.view_payload(raw, longstart, longlength, 0, longstart - 1),
+        DataStrings.PAYLOAD_MISSING,
+        DataStrings.inline_payload(raw, 1, 0),
+    ]
+    views = DataStrings.StringVector{Union{Missing,DataStrings.DataString}}(
+        payloads,
+        Vector{UInt8}[raw],
+    )
+    maps = Union{Missing,Dict{String,Union{Missing,Int32}}}[
+        Dict("a" => Int32(1), "b" => missing),
+        Dict{String,Union{Missing,Int32}}(),
+        missing,
+        Dict("c" => Int32(3)),
+    ]
+    fixed = NTuple{2,Int16}[
+        (Int16(1), Int16(2)),
+        (Int16(3), Int16(4)),
+        (Int16(5), Int16(6)),
+        (Int16(7), Int16(8)),
+    ]
+    table = (
+        extension=FuzzExtensionID.(Int64[1, -2, 3, 4]),
+        extension_struct=Union{Missing,FuzzExtensionPoint}[
+            FuzzExtensionPoint(Int32(1), Int32(2)),
+            missing,
+            FuzzExtensionPoint(Int32(3), Int32(4)),
+            FuzzExtensionPoint(Int32(-5), Int32(6)),
+        ],
+        maps=maps,
+        fixed=fixed,
+        views=views,
+        dates=Date[
+            Date(1969, 12, 31),
+            Date(1970, 1, 1),
+            Date(2038, 1, 19),
+            Date(2100, 1, 1),
+        ],
+        datetimes=DateTime[
+            DateTime(1969, 12, 31, 23, 59, 59),
+            DateTime(1970, 1, 1),
+            DateTime(2038, 1, 19, 3, 14, 7),
+            DateTime(2100, 1, 1),
+        ],
+        times=Time[Time(0), Time(12), Time(23, 59, 59, 999), Time(1, 2, 3, 4)],
+        durations=Nanosecond[
+            Nanosecond(-1),
+            Nanosecond(0),
+            Nanosecond(1_000_001),
+            Nanosecond(86_400_000_000_000),
+        ],
+    )
+    expected = (
+        extension=table.extension,
+        extension_struct=table.extension_struct,
+        maps=_maprowviews(
+            DataStrings.DataString,
+            Union{Missing,Int32},
+            [ismissing(value) ? missing : collect(pairs(value)) for value in table.maps];
+            nullable=true,
+        ),
+        fixed=table.fixed,
+        views=Union{Missing,DataStrings.DataString}[
+            DataStrings.DataString("tiny"),
+            DataStrings.DataString(String(copy(@view raw[longstart:end]))),
+            missing,
+            DataStrings.DataString(""),
+        ],
+        dates=table.dates,
+        # a written DateTime column reads back as Timestamp{Millisecond}
+        datetimes=Durations.Timestamp{Millisecond}.(table.datetimes),
+        times=table.times,
+        durations=table.durations,
+    )
+    decoded = Arrow.readstream(ipcbytes(table; file=false, compress=:none))
+    return LayoutCase(
+        :logical,
+        decoded.schema,
+        collect(Arrow.AC.RecordBatch, decoded.batches),
+        expected,
+        true,
+        Set([
+            :arrowtypes_extension,
+            :arrowtypes_struct_extension,
+            :map,
+            :fixed_size_list,
+            :utf8_view,
+            :date,
+            :timestamp,
+            :time,
+            :duration,
+        ]),
+    )
+end
+
+function _fixeddata(t, values; present=trues(length(values)))
+    nullcount = count(!, present)
+    return Arrow.AC.ArrayData(
+        t,
+        length(values),
+        [Arrow.AC._bitmapbuffer(present), Arrow.AC._databuffer(values)];
+        nullcount,
+    )
+end
+
+function _physical_layout_case()
+    AC = Arrow.AC
+    fields = AC.Field[]
+    columns = AC.ArrayData[]
+
+    binarytype = AC.BinaryType(false)
+    push!(fields, AC.Field("binary", binarytype; nullable=false))
+    push!(
+        columns,
+        AC.ArrayData(
+            binarytype,
+            3,
+            [
+                AC.BufferSlice(),
+                AC._databuffer(Int32[0, 2, 2, 5]),
+                AC._databuffer(UInt8[0x00, 0xff, 0x01, 0x02, 0x03]),
+            ];
+            nullcount=0,
+        ),
+    )
+
+    largebinarytype = AC.BinaryType(true)
+    push!(fields, AC.Field("large_binary", largebinarytype; nullable=false))
+    push!(
+        columns,
+        AC.ArrayData(
+            largebinarytype,
+            3,
+            [
+                AC.BufferSlice(),
+                AC._databuffer(Int64[0, 2, 2, 5]),
+                AC._databuffer(UInt8[0x10, 0x11, 0x12, 0x13, 0x14]),
+            ];
+            nullcount=0,
+        ),
+    )
+
+    fixedbinarytype = AC.FixedSizeBinaryType(3)
+    push!(fields, AC.Field("fixed_binary", fixedbinarytype; nullable=false))
+    push!(
+        columns,
+        AC.ArrayData(
+            fixedbinarytype,
+            3,
+            [AC.BufferSlice(), AC._databuffer(UInt8[1, 2, 3, 4, 5, 6, 7, 8, 9])];
+            nullcount=0,
+        ),
+    )
+
+    longbinary = collect(UInt8, 0x10:0x20)
+    binarypayloads = DataStrings.StringPayload[
+        DataStrings.inline_payload(UInt8[0x01, 0x02], 1, 2),
+        DataStrings.view_payload(longbinary, 1, length(longbinary), 0, 0),
+        DataStrings.PAYLOAD_MISSING,
+    ]
+    binaryviewtype = AC.ViewType(false)
+    push!(fields, AC.Field("binary_view", binaryviewtype; nullable=true))
+    push!(
+        columns,
+        AC.ArrayData(
+            binaryviewtype,
+            3,
+            [
+                AC._bitmapbuffer(Bool[true, true, false]),
+                AC._databuffer(binarypayloads),
+                AC._databuffer(longbinary),
+            ];
+            nullcount=1,
+        ),
+    )
+
+    mapkeyfield, mapkeydata = AC.fromjulia("key", ["a", "b", "c"])
+    mapvaluefield, mapvaluedata =
+        AC.fromjulia("value", Union{Missing,Int32}[Int32(1), missing, Int32(3)])
+    entriesfield = AC.Field(
+        "entries",
+        AC.StructType();
+        nullable=false,
+        children=[mapkeyfield, mapvaluefield],
+    )
+    entriesdata = AC.ArrayData(
+        AC.StructType(),
+        3,
+        [AC.BufferSlice()];
+        children=[mapkeydata, mapvaluedata],
+        nullcount=0,
+    )
+    maptype = AC.MapType(true)
+    push!(fields, AC.Field("sorted_map", maptype; nullable=false, children=[entriesfield]))
+    push!(
+        columns,
+        AC.ArrayData(
+            maptype,
+            3,
+            [AC.BufferSlice(), AC._databuffer(Int32[0, 2, 2, 3])];
+            children=[entriesdata],
+            nullcount=0,
+        ),
+    )
+
+    temporal = (
+        ("date32", AC.DateType(AC.DAY), Int32[-1, 0, 1], :date_units),
+        (
+            "date64",
+            AC.DateType(AC.MILLISECOND_DATE),
+            Int64[-86_400_000, 0, 86_400_000],
+            :date_units,
+        ),
+        ("time_s", AC.TimeType(AC.SECOND, 32), Int32[0, 43_200, 86_399], :time_units),
+        (
+            "time_ms",
+            AC.TimeType(AC.MILLISECOND, 32),
+            Int32[0, 43_200_000, 86_399_999],
+            :time_units,
+        ),
+        (
+            "time_us",
+            AC.TimeType(AC.MICROSECOND, 64),
+            Int64[0, 43_200_000_000, 86_399_999_999],
+            :time_units,
+        ),
+        (
+            "time_ns",
+            AC.TimeType(AC.NANOSECOND, 64),
+            Int64[0, 43_200_000_000_000, 86_399_999_999_999],
+            :time_units,
+        ),
+        (
+            "timestamp_s",
+            AC.TimestampType(AC.SECOND, nothing),
+            Int64[-1, 0, 1_000_001],
+            :timestamp_units,
+        ),
+        (
+            "timestamp_ms",
+            AC.TimestampType(AC.MILLISECOND, nothing),
+            Int64[-1, 0, 1_000_001],
+            :timestamp_units,
+        ),
+        (
+            "timestamp_us",
+            AC.TimestampType(AC.MICROSECOND, "UTC"),
+            Int64[-1, 0, 1_000_001],
+            :timestamp_units,
+        ),
+        (
+            "timestamp_ns",
+            AC.TimestampType(AC.NANOSECOND, "+00:00"),
+            Int64[-1, 0, 1_000_001],
+            :timestamp_units,
+        ),
+        (
+            "duration_s",
+            AC.DurationType(AC.SECOND),
+            Int64[-1, 0, 1_000_001],
+            :duration_units,
+        ),
+        (
+            "duration_ms",
+            AC.DurationType(AC.MILLISECOND),
+            Int64[-1, 0, 1_000_001],
+            :duration_units,
+        ),
+        (
+            "duration_us",
+            AC.DurationType(AC.MICROSECOND),
+            Int64[-1, 0, 1_000_001],
+            :duration_units,
+        ),
+        (
+            "duration_ns",
+            AC.DurationType(AC.NANOSECOND),
+            Int64[-1, 0, 1_000_001],
+            :duration_units,
+        ),
+    )
+    for (name, type, values, _) in temporal
+        push!(fields, AC.Field(name, type; nullable=false))
+        push!(columns, _fixeddata(type, values))
+    end
+
+    childfield, childdata = AC.fromjulia("item", Int16[1, 2, 3, 4, 5, 6])
+    fixedlisttype = AC.FixedSizeListType(2)
+    push!(
+        fields,
+        AC.Field("fixed_list", fixedlisttype; nullable=false, children=[childfield]),
+    )
+    push!(
+        columns,
+        AC.ArrayData(
+            fixedlisttype,
+            3,
+            [AC.BufferSlice()];
+            children=[childdata],
+            nullcount=0,
+        ),
+    )
+
+    runfield, rundata = AC.fromjulia("run_ends", Int16[2, 3])
+    valuefield, valuedata = AC.fromjulia("values", Union{Missing,String}["run", missing])
+    reetype = AC.RunEndEncodedType()
+    push!(fields, AC.Field("ree", reetype; nullable=true, children=[runfield, valuefield]))
+    push!(
+        columns,
+        AC.ArrayData(
+            reetype,
+            3,
+            AC.BufferSlice[];
+            children=[rundata, valuedata],
+            nullcount=0,
+        ),
+    )
+
+    xfield, xdata = AC.fromjulia("x", Int32[1, 0, 3])
+    yfield, ydata = AC.fromjulia("y", Union{Missing,String}["a", missing, "c"])
+    structtype = AC.StructType()
+    push!(
+        fields,
+        AC.Field("nullable_struct", structtype; nullable=true, children=[xfield, yfield]),
+    )
+    push!(
+        columns,
+        AC.ArrayData(
+            structtype,
+            3,
+            [AC._bitmapbuffer(Bool[true, false, true])];
+            children=[xdata, ydata],
+            nullcount=1,
+        ),
+    )
+
+    schema = AC.Schema(fields)
+    batch = AC.RecordBatch(schema, columns, 3)
+    epoch = DateTime(1970, 1, 1)
+    expected = (
+        binary=DataBytes.([UInt8[0x00, 0xff], UInt8[], UInt8[0x01, 0x02, 0x03]]),
+        large_binary=DataBytes.([UInt8[0x10, 0x11], UInt8[], UInt8[0x12, 0x13, 0x14]]),
+        fixed_binary=NTuple{3,UInt8}[(1, 2, 3), (4, 5, 6), (7, 8, 9)],
+        binary_view=Union{Missing,DataBytes}[
+            DataBytes(UInt8[0x01, 0x02]),
+            DataBytes(longbinary),
+            missing,
+        ],
+        sorted_map=_maprowviews(
+            DataString,
+            Union{Missing,Int32},
+            [["a" => Int32(1), "b" => missing], Pair[], ["c" => Int32(3)]],
+        ),
+        date32=Date[Date(1969, 12, 31), Date(1970, 1, 1), Date(1970, 1, 2)],
+        date64=DateTime[epoch - Day(1), epoch, epoch + Day(1)],
+        time_s=Time[Time(0), Time(12), Time(23, 59, 59)],
+        time_ms=Time[Time(0), Time(12), Time(23, 59, 59, 999)],
+        time_us=Time[
+            Time(Nanosecond(0)),
+            Time(Nanosecond(43_200_000_000_000)),
+            Time(Nanosecond(86_399_999_999_000)),
+        ],
+        time_ns=Time[
+            Time(Nanosecond(0)),
+            Time(Nanosecond(43_200_000_000_000)),
+            Time(Nanosecond(86_399_999_999_999)),
+        ],
+        timestamp_s=collect(
+            reinterpret(Durations.Timestamp{Second}, Int64[-1, 0, 1_000_001]),
+        ),
+        timestamp_ms=collect(
+            reinterpret(Durations.Timestamp{Millisecond}, Int64[-1, 0, 1_000_001]),
+        ),
+        timestamp_us=collect(
+            reinterpret(
+                Durations.ZonedTimestamp{Microsecond,:UTC},
+                Int64[-1, 0, 1_000_001],
+            ),
+        ),
+        timestamp_ns=collect(
+            reinterpret(
+                Durations.ZonedTimestamp{Nanosecond,Symbol("+00:00")},
+                Int64[-1, 0, 1_000_001],
+            ),
+        ),
+        duration_s=Second[Second(-1), Second(0), Second(1_000_001)],
+        duration_ms=Millisecond[Millisecond(-1), Millisecond(0), Millisecond(1_000_001)],
+        duration_us=Microsecond[Microsecond(-1), Microsecond(0), Microsecond(1_000_001)],
+        duration_ns=Nanosecond[Nanosecond(-1), Nanosecond(0), Nanosecond(1_000_001)],
+        fixed_list=NTuple{2,Int16}[(1, 2), (3, 4), (5, 6)],
+        ree=Union{Missing,DataString}[DataString("run"), DataString("run"), missing],
+        nullable_struct=Union{Missing,@NamedTuple{x::Int32,y::Union{Missing,DataString}}}[
+            (x=Int32(1), y="a"),
+            missing,
+            (x=Int32(3), y="c"),
+        ],
+    )
+    return LayoutCase(
+        :physical,
+        schema,
+        [batch],
+        expected,
+        true,
+        Set([
+            :binary,
+            :large_binary,
+            :fixed_size_binary,
+            :binary_view,
+            :map_sorted,
+            :fixed_size_list,
+            :date_units,
+            :time_units,
+            :timestamp_units,
+            :duration_units,
+            :run_end_encoded,
+            :nullable_struct_parent,
+        ]),
+    )
+end
+
+function _union_layout_case()
+    AC = Arrow.AC
+    denseintfield, denseintdata = AC.fromjulia("i", Int64[1, 3])
+    densestrfield, densestrdata = AC.fromjulia("s", ["two"])
+    densenulltype = AC.NullType()
+    densenullfield = AC.Field("null", densenulltype; nullable=true)
+    densenulldata = AC.ArrayData(densenulltype, 1, AC.BufferSlice[]; nullcount=1)
+    densetype = AC.UnionType(AC.DenseMode, Int8[0, 1, 2])
+    densefield = AC.Field(
+        "dense",
+        densetype;
+        nullable=true,
+        children=[denseintfield, densestrfield, densenullfield],
+    )
+    densedata = AC.ArrayData(
+        densetype,
+        4,
+        [AC._databuffer(Int8[0, 1, 2, 0]), AC._databuffer(Int32[0, 0, 0, 1])];
+        children=[denseintdata, densestrdata, densenulldata],
+        nullcount=0,
+    )
+
+    sparseintfield, sparseintdata = AC.fromjulia("i", Int64[1, 0, 3, 0])
+    sparsetextfield, sparsetextdata = AC.fromjulia("s", ["", "two", "", "four"])
+    sparsetype = AC.UnionType(AC.SparseMode, Int8[3, 7])
+    sparsefield = AC.Field(
+        "sparse",
+        sparsetype;
+        nullable=false,
+        children=[sparseintfield, sparsetextfield],
+    )
+    sparsedata = AC.ArrayData(
+        sparsetype,
+        4,
+        [AC._databuffer(Int8[3, 7, 3, 7])];
+        children=[sparseintdata, sparsetextdata],
+        nullcount=0,
+    )
+    schema = AC.Schema([densefield, sparsefield])
+    return LayoutCase(
+        :unions,
+        schema,
+        [AC.RecordBatch(schema, [densedata, sparsedata], 4)],
+        (
+            dense=Union{Missing,Int64,DataString}[
+                Int64(1),
+                DataString("two"),
+                missing,
+                Int64(3),
+            ],
+            sparse=Union{Int64,DataString}[
+                Int64(1),
+                DataString("two"),
+                Int64(3),
+                DataString("four"),
+            ],
+        ),
+        false,
+        Set([:dense_union, :sparse_union]),
+    )
+end
+
+function _decode_batches(bytes::Vector{UInt8}, file::Bool)
+    if file
+        decoded = Arrow.readfile(copy(bytes))
+        return decoded.schema, Arrow.AC.RecordBatch[decoded[i] for i = 1:length(decoded)]
+    end
+    decoded = Arrow.readstream(copy(bytes))
+    return decoded.schema, collect(Arrow.AC.RecordBatch, decoded.batches)
+end
+
+function _layoutbytes(schema, batches; file::Bool, compress::Symbol)
+    return file ? Arrow.writefile(schema, batches; compress) :
+           Arrow.writestream(schema, batches; compress)
+end
+
+function _run_layout_case(case::LayoutCase)
+    baseline = Arrow.Table(Arrow.writestream(case.schema, case.batches))
+    _check_expected_layout(baseline, case.expected; label="layout=$(case.label) baseline")
+    _check_original_schema(
+        baseline,
+        case.schema;
+        label="layout=$(case.label) baseline schema",
+    )
+    if case.label === :logical
+        fields = getfield(baseline, :schema).fields
+        extensionmeta = Dict(_metadataentries(fields[1].metadata))
+        pointmeta = Dict(_metadataentries(fields[2].metadata))
+        _require(
+            extensionmeta["ARROW:extension:name"] == String(_FUZZ_EXTENSION_NAME),
+            "scalar ArrowTypes extension name was not written",
+        )
+        _require(
+            pointmeta["ARROW:extension:name"] == String(_FUZZ_POINT_NAME) &&
+                pointmeta["ARROW:extension:metadata"] == "seeded-fuzz",
+            "struct ArrowTypes extension metadata was not written",
+        )
+        _require(
+            eltype(baseline.extension) === FuzzExtensionID,
+            "scalar extension was not lifted",
+        )
+        _require(
+            eltype(baseline.extension_struct) === Union{Missing,FuzzExtensionPoint},
+            "nullable struct extension was not lifted",
+        )
+    end
+    checks = 0
+    coverage = copy(case.coverage)
+    for file in (false, true), compress in (:none, :lz4, :zstd)
+        label = "layout=$(case.label) file=$file compress=$compress"
+        bytes = _layoutbytes(case.schema, case.batches; file, compress)
+        actual = Arrow.Table(copy(bytes))
+        _check_expected_layout(actual, case.expected; label)
+        _check_same_table(actual, baseline; label)
+        _check_same_schema(actual, baseline; label)
+        _check_original_schema(actual, case.schema; label="$label original schema")
+        checks += 1
+
+        decodedschema, decodedbatches = _decode_batches(bytes, file)
+        rewritten = _layoutbytes(
+            decodedschema,
+            decodedbatches;
+            file=(!file),
+            compress=_rewritecodec(compress),
+        )
+        rewrittenactual = Arrow.Table(copy(rewritten))
+        _check_expected_layout(rewrittenactual, case.expected; label="$label IPC rewrite")
+        _check_same_table(rewrittenactual, baseline; label="$label IPC rewrite")
+        _check_same_schema(rewrittenactual, baseline; label="$label IPC rewrite")
+        _check_original_schema(
+            rewrittenactual,
+            case.schema;
+            label="$label IPC rewrite original schema",
+        )
+        checks += 1
+
+        if case.retained
+            retained = ipcbytes(
+                Arrow.Table(copy(bytes));
+                file=(!file),
+                compress=_rewritecodec(compress),
+            )
+            retainedactual = Arrow.Table(copy(retained))
+            _check_expected_layout(
+                retainedactual,
+                case.expected;
+                label="$label retained rewrite",
+            )
+            _check_same_table(retainedactual, baseline; label="$label retained rewrite")
+            _check_same_schema(retainedactual, baseline; label="$label retained rewrite")
+            _check_original_schema(
+                retainedactual,
+                case.schema;
+                label="$label retained rewrite original schema",
+            )
+            push!(coverage, :retained_rewrite)
+            checks += 1
+        end
+    end
+    return checks, coverage
+end
+
+function run_layouts()
+    checks = 0
+    coverage = Set{Symbol}()
+    for case in (_logical_layout_case(), _physical_layout_case(), _union_layout_case())
+        casechecks, casecoverage = _run_layout_case(case)
+        checks += casechecks
+        union!(coverage, casecoverage)
+    end
+    return checks, coverage
+end
+
+function _run_differential_case(master::UInt64, index::Int)
+    case = make_case(master, index)
+    # A partition with no rows writes no record batch.
+    writtenparts = [p for p in case.expectedparts if length(first(p)) > 0]
+    nparts = length(writtenparts)
+    variants = 0
+    rewrites = 0
+    scanchecks = 0
+    for file in (false, true), compress in (:none, :lz4, :zstd)
+        label = "case=$index file=$file compress=$compress"
+        bytes = ipcbytes(Tables.partitioner(case.inputs); file=file, compress=compress)
+        check_expected_table(Arrow.Table(copy(bytes)), case.expected; label="$label whole")
+
+        batches = collect(Arrow.Stream(copy(bytes)))
+        _require(length(batches) == nparts, "$label partition count differs")
+        for (partition, (batch, expectedpart)) in enumerate(zip(batches, writtenparts))
+            check_expected_table(batch, expectedpart; label="$label partition=$partition")
+        end
+
+        rewritten = ipcbytes(
+            Arrow.Stream(copy(bytes));
+            file=(!file),
+            compress=_rewritecodec(compress),
+        )
+        check_expected_table(
+            Arrow.Table(copy(rewritten)),
+            case.expected;
+            label="$label rewrite",
+        )
+        rewrittenparts = collect(Arrow.Stream(copy(rewritten)))
+        _require(length(rewrittenparts) == nparts, "$label rewrite partition count differs")
+        for (partition, (batch, expectedpart)) in
+            enumerate(zip(rewrittenparts, writtenparts))
+            check_expected_table(
+                batch,
+                expectedpart;
+                label="$label rewrite partition=$partition",
+            )
+        end
+
+        full = Arrow.Table(copy(bytes))
+        for (scanindex, scancase) in enumerate(_scans(master, index, case.expected.dates))
+            scan = scancase.scan
+            reference = Tables.scan(full, scan)
+            whole = Arrow.Table(copy(bytes); scan=scan)
+            _check_same_table(whole, reference; label="$label whole scan=$scanindex")
+            scanchecks += 1
+            if file
+                source = FuzzBytesSource(copy(bytes))
+                ranged = Arrow.Table(
+                    Arrow.SourceFile(
+                        source;
+                        limits=STRICT_LIMITS,
+                        tailbytes=32,
+                        gapbytes=0,
+                    );
+                    scan=scan,
+                )
+                _check_same_table(ranged, reference; label="$label ranged scan=$scanindex")
+                _require(
+                    !any(
+                        request -> request == (Int64(0), Int64(length(bytes))),
+                        source.requests,
+                    ),
+                    "$label ranged scan=$scanindex fetched the full object",
+                )
+                scanchecks += 1
+            end
+        end
+        variants += 1
+        rewrites += 1
+    end
+    return (variants=variants, rewrites=rewrites, scanchecks=scanchecks)
+end
+
+function _failuretext(err, bt)
+    return sprint() do io
+        showerror(io, err, bt)
+    end
+end
+
+function _repropath(dir::AbstractString, lane::Symbol, index::Int, seed::UInt64, ext)
+    name = "$(lane)-$(lpad(index, 6, '0'))-$(string(seed; base=16)).$ext"
+    return joinpath(dir, name)
+end
+
+const _REPLAY_SCRIPT = "sh ./replay.sh /path/to/Arrow.jl"
+
+function _save_text_repro(
+    dir::Union{Nothing,AbstractString},
+    lane::Symbol,
+    index::Int,
+    seed::UInt64,
+    text::AbstractString,
+)
+    dir === nothing && return nothing
+    mkpath(dir)
+    path = _repropath(dir, lane, index, seed, "txt")
+    open(path, "w") do io
+        Base.write(io, text)
+    end
+    return path
+end
+
+function _save_mutation_repro(
+    dir::Union{Nothing,AbstractString},
+    index::Int,
+    seed::UInt64,
+    bytes::Vector{UInt8},
+    text::AbstractString,
+)
+    dir === nothing && return nothing
+    mkpath(dir)
+    Base.write(_repropath(dir, :mutation, index, seed, "arrowbytes"), bytes)
+    return _save_text_repro(dir, :mutation, index, seed, text)
+end
+
+_active_repro_path(dir::AbstractString, lane::Symbol, ext::AbstractString) =
+    joinpath(dir, "active-$(String(lane)).$ext")
+
+function _save_active_repro(
+    dir::Union{Nothing,AbstractString},
+    lane::Symbol,
+    text::AbstractString;
+    bytes::Union{Nothing,Vector{UInt8}}=nothing,
+)
+    dir === nothing && return nothing
+    mkpath(dir)
+    open(_active_repro_path(dir, lane, "txt"), "w") do io
+        Base.write(io, text)
+    end
+    bytes === nothing || Base.write(_active_repro_path(dir, lane, "arrowbytes"), bytes)
+    return nothing
+end
+
+function _clear_active_repro(dir::Union{Nothing,AbstractString}, lane::Symbol)
+    dir === nothing && return nothing
+    for ext in ("txt", "arrowbytes")
+        path = _active_repro_path(dir, lane, ext)
+        isfile(path) && rm(path)
+    end
+    return nothing
+end
+
+function run_differential(;
+    seed::UInt64=DEFAULT_SEED,
+    cases::Integer=EXTENDED_CASES,
+    case_index::Union{Nothing,Integer}=nothing,
+    sample::Tuple{Int,Int}=(0, 1),
+    include_layouts::Bool=true,
+    reproduction_dir::Union{Nothing,AbstractString}=nothing,
+    repro_environment::Union{Nothing,String}=nothing,
+    progress_io::Union{Nothing,IO}=nothing,
+)
+    cases >= 0 || throw(ArgumentError("negative differential case count"))
+    case_index === nothing ||
+        case_index >= 1 ||
+        throw(ArgumentError("differential case indices start at 1"))
+    variants = 0
+    rewrites = 0
+    scanchecks = 0
+    layoutchecks = 0
+    coverage = Set{Symbol}()
+    reproenv =
+        reproduction_dir === nothing ? nothing :
+        repro_environment === nothing ? _environmenttext() : repro_environment
+    if include_layouts
+        if reproenv !== nothing
+            layoutreplay =
+                reproenv *
+                "\nmaster_seed=0x$(string(seed; base=16))\n" *
+                "replay=$_REPLAY_SCRIPT --seed " *
+                "0x$(string(seed; base=16)) --cases 0 --layouts-only\n\n" *
+                "active layout lane; the process may have been interrupted\n"
+            _save_active_repro(reproduction_dir, :layout, layoutreplay)
+        end
+        try
+            layoutchecks, layoutcoverage = run_layouts()
+            union!(coverage, layoutcoverage)
+        catch err
+            err isa Union{InterruptException,OutOfMemoryError} && rethrow()
+            bt = catch_backtrace()
+            details = _failuretext(err, bt)
+            if reproenv !== nothing
+                text =
+                    reproenv *
+                    "\nmaster_seed=0x$(string(seed; base=16))\n" *
+                    "replay=$_REPLAY_SCRIPT --seed " *
+                    "0x$(string(seed; base=16)) --cases 0 --layouts-only\n\n$details\n"
+                _save_text_repro(reproduction_dir, :layout, 0, seed, text)
+            end
+            _clear_active_repro(reproduction_dir, :layout)
+            throw(FuzzFailure(:layout, 0, seed, seed, details))
+        end
+        _clear_active_repro(reproduction_dir, :layout)
+    end
+    # `sample = (k, n)` runs the cases whose index is k + 1 modulo n.
+    indices =
+        case_index === nothing ? ((1 + first(sample)):last(sample):Int(cases)) :
+        (Int(case_index):Int(case_index))
+    total = length(indices)
+    total == 0 || push!(coverage, :generated_differential)
+    progress_every = max(1, min(64, total ÷ 8))
+    for (completed, index) in enumerate(indices)
+        derived = case_seed(seed, index)
+        if reproenv !== nothing
+            replay =
+                reproenv *
+                "\nmaster_seed=0x$(string(seed; base=16))\n" *
+                "case_seed=0x$(string(derived; base=16))\nindex=$index\n" *
+                "replay=$_REPLAY_SCRIPT --seed " *
+                "0x$(string(seed; base=16)) --case-index $index\n\n" *
+                "active differential case; the process may have been interrupted\n"
+            _save_active_repro(reproduction_dir, :differential, replay)
+        end
+        result = try
+            _run_differential_case(seed, index)
+        catch err
+            err isa Union{InterruptException,OutOfMemoryError} && rethrow()
+            bt = catch_backtrace()
+            details = _failuretext(err, bt)
+            if reproenv !== nothing
+                command =
+                    reproenv *
+                    "\nmaster_seed=0x$(string(seed; base=16))\n" *
+                    "case_seed=0x$(string(derived; base=16))\nindex=$index\n" *
+                    "replay=$_REPLAY_SCRIPT --seed " *
+                    "0x$(string(seed; base=16)) --case-index $index\n\n$details\n"
+                _save_text_repro(reproduction_dir, :differential, index, derived, command)
+            end
+            _clear_active_repro(reproduction_dir, :differential)
+            throw(FuzzFailure(:differential, index, seed, derived, details))
+        end
+        _clear_active_repro(reproduction_dir, :differential)
+        variants += result.variants
+        rewrites += result.rewrites
+        scanchecks += result.scanchecks
+        if progress_io !== nothing &&
+           (completed == total || completed % progress_every == 0)
+            println(progress_io, "differential cases: $completed/$total")
+        end
+    end
+    return DifferentialSummary(
+        seed,
+        total,
+        variants,
+        rewrites,
+        scanchecks,
+        layoutchecks,
+        coverage,
+    )
+end
+
+struct MutationCorpus
+    label::Symbol
+    file::Bool
+    bytes::Vector{UInt8}
+end
+
+struct MutationRoute
+    corpus::MutationCorpus
+    lane::Symbol
+end
+
+function _mutationtable()
+    Part = @NamedTuple{
+        id::Vector{Int64},
+        text::Vector{Union{Missing,String}},
+        list::Vector{Vector{Int32}},
+        dict::Arrow.DictEncode{Union{Missing,String},Vector{Union{Missing,String}}},
+    }
+    firstpart = (
+        id=Int64[1, -2, 3],
+        text=Union{Missing,String}["alpha", missing, "\0"],
+        list=Vector{Int32}[Int32[1, 2], Int32[], Int32[3]],
+        dict=Arrow.DictEncode(Union{Missing,String}["x", missing, "y"]),
+    )
+    secondpart = (
+        id=Int64[4, 5],
+        text=Union{Missing,String}["\u03bb", "line\nbreak"],
+        list=Vector{Int32}[Int32[4], Int32[5, 6]],
+        dict=Arrow.DictEncode(Union{Missing,String}["y", "z"]),
+    )
+    return Tables.partitioner(Part[firstpart, secondpart])
+end
+
+function _mutationcorpus()
+    corpus = MutationCorpus[]
+    for file in (false, true), compress in (:none, :lz4, :zstd)
+        label = Symbol(file ? "file_$compress" : "stream_$compress")
+        push!(
+            corpus,
+            MutationCorpus(label, file, ipcbytes(_mutationtable(); file, compress)),
+        )
+    end
+    for case in (_logical_layout_case(), _physical_layout_case(), _union_layout_case())
+        for file in (false, true), compress in (:none, :lz4, :zstd)
+            label = Symbol("layout_$(case.label)_$(file ? "file" : "stream")_$compress")
+            push!(
+                corpus,
+                MutationCorpus(
+                    label,
+                    file,
+                    _layoutbytes(case.schema, case.batches; file, compress),
+                ),
+            )
+        end
+    end
+    return corpus
+end
+
+function _mutationroutes(corpus=_mutationcorpus())
+    routes = MutationRoute[]
+    for entry in corpus
+        if entry.file
+            push!(routes, MutationRoute(entry, :file_full))
+            push!(routes, MutationRoute(entry, :file_ranged))
+        else
+            push!(routes, MutationRoute(entry, :stream_full))
+        end
+        entry.label in (:stream_none, :file_none) &&
+            push!(routes, MutationRoute(entry, :auto_full))
+    end
+    return routes
+end
+
+const _MUTATION_OPERATIONS = (:flip, :set, :delete, :insert, :truncate)
+
+function _mutatebytes(base::Vector{UInt8}, rng, required::Symbol)
+    bytes = copy(base)
+    recipe = String[]
+    operations = Symbol[]
+    required in _MUTATION_OPERATIONS || throw(ArgumentError("unknown mutation $required"))
+    operationcount = _range(rng, 1, 4)
+    for operationindex = 1:operationcount
+        requested = operationindex == 1 ? required : _choice(rng, _MUTATION_OPERATIONS)
+        op = isempty(bytes) ? :insert : requested
+        push!(operations, op)
+        if op === :flip
+            index = _range(rng, firstindex(bytes), lastindex(bytes))
+            bit = UInt8(1) << _range(rng, 0, 7)
+            bytes[index] = xor(bytes[index], bit)
+            push!(recipe, "flip[$index]=0x$(string(bit; base=16, pad=2))")
+        elseif op === :set
+            index = _range(rng, firstindex(bytes), lastindex(bytes))
+            value = xor(bytes[index], UInt8(_range(rng, 1, typemax(UInt8))))
+            bytes[index] = value
+            push!(recipe, "set[$index]=0x$(string(value; base=16, pad=2))")
+        elseif op === :delete
+            start = _range(rng, firstindex(bytes), lastindex(bytes))
+            count = _range(rng, 1, min(8, length(bytes) - start + 1))
+            deleteat!(bytes, start:(start + count - 1))
+            push!(recipe, "delete[$start:$count]")
+        elseif op === :insert
+            count = _range(rng, 1, 8)
+            index = _range(rng, 1, length(bytes) + 1)
+            inserted = UInt8[_random(UInt8, rng) for _ = 1:count]
+            for (offset, value) in enumerate(inserted)
+                insert!(bytes, index + offset - 1, value)
+            end
+            push!(recipe, "insert[$index:$count]")
+        else
+            newlength = _range(rng, 0, length(bytes) - 1)
+            resize!(bytes, newlength)
+            push!(recipe, "truncate[$newlength]")
+        end
+    end
+    if bytes == base
+        if isempty(bytes)
+            push!(bytes, 0x01)
+            push!(operations, :insert)
+            push!(recipe, "ensure-insert[1]=0x01")
+        else
+            index = firstindex(bytes)
+            bytes[index] = xor(bytes[index], 0x01)
+            push!(operations, :flip)
+            push!(recipe, "ensure-flip[$index]=0x01")
+        end
+    end
+    length(bytes) <= length(base) + 32 || _fail("mutation exceeded its byte-growth bound")
+    bytes != base || _fail("mutation did not change its input")
+    return bytes, join(recipe, ","), operations
+end
+
+function _exercise_mutation(bytes::Vector{UInt8}, lane::Symbol)
+    requests = nothing
+    if lane === :stream_full
+        table = Arrow.Table(Arrow.readstream(copy(bytes); limits=STRICT_LIMITS))
+    elseif lane === :file_full
+        table = Arrow.Table(Arrow.readfile(copy(bytes); limits=STRICT_LIMITS))
+    elseif lane === :file_ranged
+        fuzzsource = FuzzBytesSource(copy(bytes))
+        source =
+            Arrow.SourceFile(fuzzsource; limits=STRICT_LIMITS, tailbytes=32, gapbytes=0)
+        try
+            table = Arrow.Table(source; scan=Tables.Scan())
+        finally
+            if length(bytes) > 32 && any(
+                request -> request == (Int64(0), Int64(length(bytes))),
+                fuzzsource.requests,
+            )
+                _fail("ranged mutation fetched the full object")
+            end
+        end
+        requests = copy(fuzzsource.requests)
+    elseif lane === :auto_full
+        table = Arrow.Table(copy(bytes); limits=STRICT_LIMITS)
+    else
+        throw(ArgumentError("unknown mutation lane $lane"))
+    end
+    nrows = Tables.rowcount(table)
+    names = collect(Symbol, Tables.columnnames(table))
+    eltypes = Type[]
+    values = Any[]
+    for index in eachindex(names)
+        column = Tables.getcolumn(table, index)
+        collected = collect(column)
+        length(collected) == nrows ||
+            _fail("accepted mutation produced a short column $(names[index])")
+        push!(eltypes, eltype(column))
+        push!(values, collected)
+    end
+    return (; nrows, names, eltypes, values, requests)
+end
+
+function _source_revision()
+    githubsha = strip(get(ENV, "GITHUB_SHA", ""))
+    isempty(githubsha) || return githubsha
+    root = normpath(joinpath(@__DIR__, "..", ".."))
+    try
+        head = readchomp(`git -C $root rev-parse HEAD`)
+        dirty = !isempty(readchomp(`git -C $root status --short --untracked-files=normal`))
+        return dirty ? "$head-dirty" : head
+    catch err
+        err isa Union{InterruptException,OutOfMemoryError} && rethrow()
+        return "unknown"
+    end
+end
+
+function _environmenttext()
+    packages = (Arrow, DataStrings, ArrowTypes, Tables)
+    lines = String["julia_version=$(VERSION)", "source_revision=$(_source_revision())"]
+    for package in packages
+        push!(lines, "$(nameof(package))_version=$(Base.pkgversion(package))")
+    end
+    return join(lines, '\n')
+end
+
+function _snapshot_environment(
+    dir::Union{Nothing,AbstractString},
+    activeproject::Union{Nothing,AbstractString}=Base.active_project(),
+)
+    dir === nothing && return nothing
+    activeproject === nothing &&
+        error("cannot snapshot a fuzz environment without an active Project.toml")
+    project = abspath(activeproject)
+    isfile(project) || error("active fuzz Project.toml does not exist: $project")
+    manifest = joinpath(dirname(project), "Manifest.toml")
+    isfile(manifest) ||
+        error("active fuzz environment has no Manifest.toml beside $project")
+    target = joinpath(dir, "environment")
+    mkpath(target)
+    cp(project, joinpath(target, "Project.toml"); force=true)
+    cp(manifest, joinpath(target, "Manifest.toml"); force=true)
+    script = joinpath(dir, "replay.sh")
+    open(script, "w") do io
+        Base.write(io, _replay_script_text())
+    end
+    restore = _repro_restore_text()
+    open(joinpath(target, "RESTORE.txt"), "w") do io
+        Base.write(io, restore)
+    end
+    return restore
+end
+
+function _replay_script_text()
+    return """#!/bin/sh
+set -eu
+if [ \"\$#\" -lt 1 ]; then
+    echo \"usage: sh ./replay.sh /path/to/Arrow.jl [fuzz options]\" >&2
+    exit 2
+fi
+artifact_dir=\$(CDPATH= cd -- \"\$(dirname -- \"\$0\")\" && pwd)
+checkout=\$(CDPATH= cd -- \"\$1\" && pwd)
+shift
+if [ ! -f \"\$checkout/Project.toml\" ] || [ ! -f \"\$checkout/test/fuzz.jl\" ]; then
+    echo \"not an Arrow.jl checkout: \$checkout\" >&2
+    exit 2
+fi
+backup=\$(mktemp -d \"\${TMPDIR:-/tmp}/arrow-replay.XXXXXX\")
+cp \"\$checkout/Project.toml\" \"\$backup/Project.toml\"
+had_manifest=false
+if [ -f \"\$checkout/Manifest.toml\" ]; then
+    cp \"\$checkout/Manifest.toml\" \"\$backup/Manifest.toml\"
+    had_manifest=true
+fi
+cleanup() {
+    cp \"\$backup/Project.toml\" \"\$checkout/Project.toml\"
+    if [ \"\$had_manifest\" = true ]; then
+        cp \"\$backup/Manifest.toml\" \"\$checkout/Manifest.toml\"
+    else
+        rm -f \"\$checkout/Manifest.toml\"
+    fi
+    rm -rf \"\$backup\"
+}
+trap cleanup 0
+trap 'exit 129' HUP
+trap 'exit 130' INT
+trap 'exit 143' TERM
+cp \"\$artifact_dir/environment/Project.toml\" \"\$checkout/Project.toml\"
+cp \"\$artifact_dir/environment/Manifest.toml\" \"\$checkout/Manifest.toml\"
+\"\${JULIA:-julia}\" --startup-file=no --history-file=no --project=\"\$checkout\" \\
+    -e 'using Pkg; Pkg.instantiate()'
+if [ \"\${1-}\" = \"--prepare-only\" ]; then
+    exit 0
+fi
+cd \"\$artifact_dir\"
+set +e
+\"\${JULIA:-julia}\" --startup-file=no --history-file=no --project=\"\$checkout\" \\
+    \"\$checkout/test/fuzz.jl\" \"\$@\"
+status=\$?
+set -e
+exit \"\$status\"
+"""
+end
+
+_repro_restore_text() =
+    "environment_restore=$_REPLAY_SCRIPT --prepare-only " *
+    "# instantiates the pinned environment and restores the checkout files"
+
+function _mutation_details(
+    master::UInt64,
+    derived::UInt64,
+    index::Int,
+    entry::MutationCorpus,
+    lane::Symbol,
+    recipe::AbstractString,
+    environment::AbstractString=_environmenttext(),
+)
+    return environment *
+           "\n" *
+           "master_seed=0x$(string(master; base=16))\n" *
+           "case_seed=0x$(string(derived; base=16))\n" *
+           "index=$index\ncorpus=$(entry.label)\nlane=$lane\nrecipe=$recipe\n"
+end
+
+"Quote one argument for the POSIX shell used by the replay command."
+_shellquote(value::AbstractString) = "'" * replace(String(value), "'" => "'\"'\"'") * "'"
+
+function _mutation_repro_text(
+    master::UInt64,
+    derived::UInt64,
+    index::Int,
+    entry::MutationCorpus,
+    lane::Symbol,
+    recipe::AbstractString,
+    artifact::AbstractString,
+    details::AbstractString,
+    environment::AbstractString=_environmenttext(),
+)
+    return _mutation_details(master, derived, index, entry, lane, recipe, environment) *
+           "replay_generated=$_REPLAY_SCRIPT --seed " *
+           "0x$(string(master; base=16)) --cases 0 --mutation-index $index " *
+           "--skip-layouts\n" *
+           "replay_bytes=$_REPLAY_SCRIPT --cases 0 --mutations 0 " *
+           "--mutation-file $(_shellquote(basename(artifact))) " *
+           "--mutation-lane $lane\n\n$details\n"
+end
+
+function _required_mutation_sweep_coverage!(
+    mutations::Int,
+    routes,
+    routecounts,
+    operationcounts,
+)
+    mutations == 0 && return nothing
+    if mutations >= length(routes)
+        missingroutes = Set((route.corpus.label, route.lane) for route in routes)
+        setdiff!(missingroutes, keys(routecounts))
+        isempty(missingroutes) || _fail("mutation routes were not covered: $missingroutes")
+    end
+    if mutations >= length(_MUTATION_OPERATIONS)
+        missingops = setdiff(Set(_MUTATION_OPERATIONS), keys(operationcounts))
+        isempty(missingops) || _fail("mutation operations were not covered: $missingops")
+    end
+    return nothing
+end
+
+function _classify_mutation(bytes::Vector{UInt8}, lane::Symbol)
+    try
+        snapshot = _exercise_mutation(bytes, lane)
+        return (; category=:accepted, snapshot, error=nothing, backtrace=nothing)
+    catch err
+        err isa Union{InterruptException,OutOfMemoryError} && rethrow()
+        category =
+            err isa Arrow.ValidationError ? :validation :
+            err isa Arrow.AllocationLimitError ? :allocation_limit : :unexpected
+        return (; category, snapshot=nothing, error=err, backtrace=catch_backtrace())
+    end
+end
+
+_errortext(err) = sprint(showerror, err)
+
+function _same_mutation_outcome(first, second)
+    first.category === second.category || return false
+    if first.category === :accepted
+        return isequal(first.snapshot, second.snapshot)
+    end
+    return typeof(first.error) === typeof(second.error) &&
+           _errortext(first.error) == _errortext(second.error)
+end
+
+function _mutation_outcome_text(outcome)
+    if outcome.category === :accepted
+        return "accepted snapshot=$(repr(outcome.snapshot))"
+    end
+    return "$(outcome.category) $(typeof(outcome.error)): $(_errortext(outcome.error))"
+end
+
+_shouldverify(completed::Int, routecount::Int, every::Integer) =
+    every > 0 && (completed <= routecount || completed % every == 0)
+
+function run_mutations(;
+    seed::UInt64=DEFAULT_SEED,
+    mutations::Integer=EXTENDED_MUTATIONS,
+    mutation_index::Union{Nothing,Integer}=nothing,
+    reproduction_dir::Union{Nothing,AbstractString}=nothing,
+    repro_environment::Union{Nothing,String}=nothing,
+    verify_determinism::Bool=false,
+    determinism_every::Integer=0,
+    progress_io::Union{Nothing,IO}=nothing,
+)
+    mutations >= 0 || throw(ArgumentError("negative mutation count"))
+    determinism_every >= 0 || throw(ArgumentError("negative determinism interval"))
+    mutation_index === nothing ||
+        mutation_index >= 1 ||
+        throw(ArgumentError("mutation indices start at 1"))
+    routes = _mutationroutes()
+    reproenv =
+        reproduction_dir === nothing ? nothing :
+        repro_environment === nothing ? _environmenttext() : repro_environment
+    counts = Dict{Symbol,Int}(:accepted => 0, :validation => 0, :allocation_limit => 0)
+    routecounts = Dict{Tuple{Symbol,Symbol},Int}()
+    operationcounts = Dict{Symbol,Int}()
+    indices =
+        mutation_index === nothing ? (1:Int(mutations)) :
+        (Int(mutation_index):Int(mutation_index))
+    total = length(indices)
+    determinismchecks = 0
+    progress_every = max(1, min(2_000, total ÷ 10))
+    for (completed, index) in enumerate(indices)
+        derived = case_seed(seed, index; lane=_MUTATION_LANE)
+        rng = StableRNG(derived)
+        route = routes[mod(index - 1, length(routes)) + 1]
+        entry, lane = route.corpus, route.lane
+        required = _MUTATION_OPERATIONS[mod(index - 1, length(_MUTATION_OPERATIONS)) + 1]
+        bytes, recipe, operations = _mutatebytes(entry.bytes, rng, required)
+        if reproenv !== nothing
+            activeartifact = _active_repro_path(reproduction_dir, :mutation, "arrowbytes")
+            activetext = _mutation_repro_text(
+                seed,
+                derived,
+                index,
+                entry,
+                lane,
+                recipe,
+                activeartifact,
+                "active mutation; the process may have been interrupted",
+                reproenv,
+            )
+            _save_active_repro(reproduction_dir, :mutation, activetext; bytes)
+        end
+        outcome = _classify_mutation(bytes, lane)
+        if outcome.category === :unexpected
+            details = _failuretext(outcome.error, outcome.backtrace)
+            if reproenv !== nothing
+                artifact =
+                    _repropath(reproduction_dir, :mutation, index, derived, "arrowbytes")
+                text = _mutation_repro_text(
+                    seed,
+                    derived,
+                    index,
+                    entry,
+                    lane,
+                    recipe,
+                    artifact,
+                    details,
+                    reproenv,
+                )
+                _save_mutation_repro(reproduction_dir, index, derived, bytes, text)
+            end
+            _clear_active_repro(reproduction_dir, :mutation)
+            throw(FuzzFailure(:mutation, index, seed, derived, details))
+        end
+        sample_determinism = _shouldverify(completed, length(routes), determinism_every)
+        if verify_determinism || sample_determinism
+            determinismchecks += 1
+            repeated = _classify_mutation(bytes, lane)
+            if !_same_mutation_outcome(outcome, repeated)
+                details =
+                    "mutation outcome changed between identical reads\n" *
+                    "first=$(_mutation_outcome_text(outcome))\n" *
+                    "second=$(_mutation_outcome_text(repeated))"
+                if reproenv !== nothing
+                    artifact = _repropath(
+                        reproduction_dir,
+                        :mutation,
+                        index,
+                        derived,
+                        "arrowbytes",
+                    )
+                    _save_mutation_repro(
+                        reproduction_dir,
+                        index,
+                        derived,
+                        bytes,
+                        _mutation_repro_text(
+                            seed,
+                            derived,
+                            index,
+                            entry,
+                            lane,
+                            recipe,
+                            artifact,
+                            details,
+                            reproenv,
+                        ),
+                    )
+                end
+                _clear_active_repro(reproduction_dir, :mutation)
+                throw(FuzzFailure(:mutation, index, seed, derived, details))
+            end
+        end
+        _clear_active_repro(reproduction_dir, :mutation)
+        counts[outcome.category] += 1
+        routekey = (entry.label, lane)
+        routecounts[routekey] = get(routecounts, routekey, 0) + 1
+        for operation in operations
+            operationcounts[operation] = get(operationcounts, operation, 0) + 1
+        end
+        if progress_io !== nothing &&
+           (completed == total || completed % progress_every == 0)
+            println(progress_io, "mutations: $completed/$total")
+        end
+    end
+    mutation_index === nothing && _required_mutation_sweep_coverage!(
+        Int(mutations),
+        routes,
+        routecounts,
+        operationcounts,
+    )
+    return MutationSummary(
+        seed,
+        total,
+        counts,
+        routecounts,
+        operationcounts,
+        determinismchecks,
+    )
+end
+
+const _FNV_OFFSET = UInt64(0xcbf2_9ce4_8422_2325)
+const _FNV_PRIME = UInt64(0x0000_0100_0000_01b3)
+
+@inline _fnvbyte(hash::UInt64, byte::UInt8) = xor(hash, UInt64(byte)) * _FNV_PRIME
+function _fnvuint(hash::UInt64, value::UInt64)
+    for shift = 0:8:56
+        hash = _fnvbyte(hash, UInt8((value >> shift) & 0xff))
+    end
+    return hash
+end
+function _fnvstring(hash::UInt64, value::AbstractString)
+    hash = _fnvuint(hash, UInt64(ncodeunits(value)))
+    for byte in codeunits(value)
+        hash = _fnvbyte(hash, byte)
+    end
+    return hash
+end
+
+_fingerprintvalue(hash::UInt64, ::Missing) = _fnvbyte(hash, 0x00)
+function _fingerprintvalue(hash::UInt64, value::Bool)
+    return _fnvbyte(_fnvbyte(hash, 0x01), UInt8(value))
+end
+function _fingerprintvalue(hash::UInt64, value::Integer)
+    hash = _fnvbyte(hash, 0x02)
+    hash = _fnvstring(hash, string(typeof(value)))
+    return _fnvuint(hash, UInt64(unsigned(value)))
+end
+function _fingerprintvalue(hash::UInt64, value::Float64)
+    return _fnvuint(_fnvbyte(hash, 0x03), reinterpret(UInt64, value))
+end
+function _fingerprintvalue(hash::UInt64, value::AbstractString)
+    return _fnvstring(_fnvbyte(hash, 0x04), value)
+end
+function _fingerprintvalue(hash::UInt64, value::Date)
+    bits = reinterpret(UInt64, Int64(Dates.value(value)))
+    return _fnvuint(_fnvbyte(hash, 0x05), bits)
+end
+function _fingerprintvalue(hash::UInt64, value::NamedTuple)
+    hash = _fnvbyte(hash, 0x06)
+    hash = _fnvuint(hash, UInt64(length(value)))
+    for (name, fieldvalue) in pairs(value)
+        hash = _fnvstring(hash, String(name))
+        hash = _fingerprintvalue(hash, fieldvalue)
+    end
+    return hash
+end
+function _fingerprintvalue(hash::UInt64, value::AbstractVector)
+    hash = _fnvbyte(hash, 0x07)
+    hash = _fnvuint(hash, UInt64(length(value)))
+    for item in value
+        hash = _fingerprintvalue(hash, item)
+    end
+    return hash
+end
+
+"A stable semantic fingerprint of one generated case, independent of IPC bytes."
+function case_fingerprint(master::UInt64, index::Integer)
+    case = make_case(master, index)
+    return _fingerprintvalue(_FNV_OFFSET, case.expectedparts)
+end
+
+function replay_mutation(bytes::Vector{UInt8}, lane::Symbol)
+    lane in (:stream_full, :file_full, :file_ranged, :auto_full) ||
+        throw(ArgumentError("unknown mutation lane $lane"))
+    outcome = _classify_mutation(bytes, lane)
+    repeated = _classify_mutation(bytes, lane)
+    if !_same_mutation_outcome(outcome, repeated)
+        return (
+            category=:unexpected,
+            details="mutation outcome changed between identical saved-byte reads\n" *
+                    "first=$(_mutation_outcome_text(outcome))\n" *
+                    "second=$(_mutation_outcome_text(repeated))",
+        )
+    end
+    details =
+        outcome.error === nothing ? nothing : _failuretext(outcome.error, outcome.backtrace)
+    return (; category=outcome.category, details)
+end
+
+function run_suite(;
+    seed::UInt64=DEFAULT_SEED,
+    cases::Integer=EXTENDED_CASES,
+    mutations::Integer=EXTENDED_MUTATIONS,
+    case_index::Union{Nothing,Integer}=nothing,
+    sample::Tuple{Int,Int}=(0, 1),
+    mutation_index::Union{Nothing,Integer}=nothing,
+    include_layouts::Bool=true,
+    reproduction_dir::Union{Nothing,AbstractString}=nothing,
+    verify_determinism::Bool=false,
+    determinism_every::Integer=0,
+    progress_io::Union{Nothing,IO}=nothing,
+)
+    repro_environment = reproduction_dir === nothing ? nothing : _environmenttext()
+    restore = _snapshot_environment(reproduction_dir)
+    repro_environment === nothing || (repro_environment *= "\n$restore")
+    differential = run_differential(;
+        seed,
+        cases,
+        case_index,
+        sample,
+        include_layouts,
+        reproduction_dir,
+        repro_environment,
+        progress_io,
+    )
+    mutation = run_mutations(;
+        seed,
+        mutations,
+        mutation_index,
+        reproduction_dir,
+        repro_environment,
+        verify_determinism,
+        determinism_every,
+        progress_io,
+    )
+    return FuzzSummary(differential, mutation)
+end
+
+run_pr_suite(; seed::UInt64=DEFAULT_SEED, sample::Tuple{Int,Int}=(0, 1)) = run_suite(;
+    seed,
+    cases=PR_CASES,
+    sample,
+    mutations=PR_MUTATIONS,
+    include_layouts=true,
+    verify_determinism=true,
+)
+
+end # module SeededFuzz
diff --git a/test/support/cdata_stress.jl b/test/support/cdata_stress.jl
new file mode 100644
index 00000000..8ea93c74
--- /dev/null
+++ b/test/support/cdata_stress.jl
@@ -0,0 +1,260 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# The fresh-process C Data stress probe and its exact dependencies. This file
+# is included into both acceptance support and the narrow child support module.
+
+const TEST_CONFORMING_RELEASES = ReleaseCounter()
+
+function _test_conforming_release(p::Ptr{CArrowArray})::Cvoid
+    increment!(TEST_CONFORMING_RELEASES)
+    _store_field!(p, :release, Ptr{Cvoid}(C_NULL))
+    return nothing
+end
+
+# Runtime accessor, not a module-level pointer constant: a raw @cfunction
+# pointer stored in a const is invalid after a precompile-cache reload.
+test_conforming_release() = @cfunction(_test_conforming_release, Cvoid, (Ptr{CArrowArray},))
+
+# The thread a test producer's release last ran on.
+mutable struct ReleaseThread
+    @atomic id::Int
+end
+const TEST_RELEASE_THREAD = ReleaseThread(0)
+
+function _test_thread_release(p::Ptr{CArrowArray})::Cvoid
+    @atomic TEST_RELEASE_THREAD.id = Threads.threadid()
+    _store_field!(p, :release, Ptr{Cvoid}(C_NULL))
+    return nothing
+end
+
+test_thread_release() = @cfunction(_test_thread_release, Cvoid, (Ptr{CArrowArray},))
+
+function _test_c_array(release::Ptr{Cvoid})
+    return CArrowArray(
+        0,
+        0,
+        0,
+        0,
+        0,
+        Ptr{Ptr{Cvoid}}(C_NULL),
+        Ptr{Ptr{CArrowArray}}(C_NULL),
+        Ptr{CArrowArray}(C_NULL),
+        release,
+        Ptr{Cvoid}(C_NULL),
+    )
+end
+
+# A moved test array whose owner is unreachable once this returns.
+@noinline function _drop_import()
+    arr = Ref(_test_c_array(test_thread_release()))
+    GC.@preserve arr _moveowner(Base.unsafe_convert(Ptr{CArrowArray}, arr))
+    return nothing
+end
+
+# The thread pool of the thread `_drop_import_on_foreign_thread` started.
+const FOREIGN_POOL = Ref(:none)
+
+function _foreign_drop_import(::Ptr{Cvoid})
+    FOREIGN_POOL[] = Threads.threadpool()
+    _drop_import()
+    return nothing
+end
+
+# Runs `_drop_import` on a thread Julia did not start, as a C library's worker
+# thread would call back into Julia, and waits for that thread to end.
+function _drop_import_on_foreign_thread()
+    entry = @cfunction(_foreign_drop_import, Cvoid, (Ptr{Cvoid},))
+    tid = Ref{UInt}(0)
+    err = ccall(
+        :uv_thread_create,
+        Cint,
+        (Ptr{UInt}, Ptr{Cvoid}, Ptr{Cvoid}),
+        tid,
+        entry,
+        C_NULL,
+    )
+    err == 0 || error("uv_thread_create failed: $err")
+    # Joined GC-safe, so a collection the adopted thread waits for can run.
+    state = ccall(:jl_gc_safe_enter, Int8, ())
+    err = ccall(:uv_thread_join, Cint, (Ptr{UInt},), tid)
+    ccall(:jl_gc_safe_leave, Cvoid, (Int8,), state)
+    err == 0 || error("uv_thread_join failed: $err")
+    return nothing
+end
+
+_registry_count() = lock(REGISTRY_LOCK) do
+    length(EXPORTS)
+end
+"Free every export released before the call."
+_reapreleased!() = _reap!()
+"Reap, then count what is still registered."
+_drained() = (_reapreleased!(); _registry_count())
+"The registry key of the export whose struct is at `p`."
+_exportkey(p::Ptr) = Ptr{Int64}(unsafe_load(p).private_data)
+_registered(key::Ptr{Int64}) = lock(REGISTRY_LOCK) do
+    haskey(EXPORTS, key)
+end
+
+# Wait up to `seconds` for `done()`, sleeping so tasks on this thread and on
+# other threads run meanwhile.
+function _waitfor(done; seconds=30.0)
+    t = time()
+    while !done() && time() - t < seconds
+        sleep(0.001)
+    end
+    return done()
+end
+
+# Collect and reap until `done()`: a collection hands an import's release to the
+# thread that made the import, which runs it once that thread wakes.
+_collectuntil(done) = _waitfor(() -> (GC.gc(true); _reap!(); done()))
+
+function _stress_reaper(ready, start, done, workers)
+    increment!(ready)
+    wait(start)
+    reaped = 0
+    for _ = 1:10_000
+        reaped += _reap!()
+        done[] == workers && _registry_count() == 0 && break
+        yield()
+    end
+    return reaped
+end
+
+function _threaded_cdata_stress()
+    Threads.nthreads() >= 4 ||
+        error("threaded C Data stress requires at least four threads")
+
+    # Different exports may be released concurrently, from any thread, while
+    # reapers scan and free the released ones; each export is freed once.
+    n = 1_000
+    workers = 4
+    f, d = fromjulia("registry-race", Int64[1])
+    roots = [to_c_data(f, d) for _ = 1:n]
+    ready = ReleaseCounter()
+    done = ReleaseCounter()
+    start = Base.Event()
+    releasers = [errormonitor(Threads.@spawn begin
+        increment!(ready)
+        wait(start)
+        try
+            for i = worker:workers:n
+                sp, ap = roots[i]
+                _release_c!(sp)
+                _release_c!(ap)
+                i % 16 == 0 && yield()
+            end
+        finally
+            increment!(done)
+        end
+    end) for worker = 1:workers]
+    reapers = [
+        errormonitor(Threads.@spawn _stress_reaper(ready, start, done, workers)) for _ = 1:3
+    ]
+    while ready[] != length(releasers) + length(reapers)
+        yield()
+    end
+    notify(start)
+    foreach(fetch, releasers)
+    reaped_by_task = fetch.(reapers)
+    reaped = sum(reaped_by_task) + _reapreleased!()
+    @assert reaped == n (reaped, reaped_by_task, _registry_count())
+    @assert _registry_count() == 0
+
+    # One atomic swap must choose between explicit release and the registered
+    # finalizer before either path reads or frees the native struct copy.
+    rounds = 200
+    before = TEST_CONFORMING_RELEASES[]
+    owners = ForeignOwner[]
+    for _ = 1:rounds
+        arr = Ref(_test_c_array(test_conforming_release()))
+        push!(
+            owners,
+            GC.@preserve arr _moveowner(Base.unsafe_convert(Ptr{CArrowArray}, arr))
+        )
+    end
+    ready = ReleaseCounter()
+    start = Base.Event()
+    contenders = Task[]
+    for owner in owners
+        push!(contenders, errormonitor(Threads.@spawn begin
+            increment!(ready)
+            wait(start)
+            release!(owner)
+        end))
+        push!(contenders, errormonitor(Threads.@spawn begin
+            increment!(ready)
+            wait(start)
+            finalize(owner)
+        end))
+    end
+    while ready[] != length(contenders)
+        yield()
+    end
+    notify(start)
+    foreach(fetch, contenders)
+    @assert TEST_CONFORMING_RELEASES[] - before == rounds
+    for owner in owners
+        @assert (@atomic owner.cell.closed)
+    end
+
+    # Tables exported and imported back on several threads at once, with the
+    # imports released by garbage collection: every export is freed, and
+    # every import reads what was exported.
+    tasks = [
+        errormonitor(Threads.@spawn begin
+                for i = 1:250
+                    xs = collect(Int64, i:(i + 99))
+                    sp, ap = to_c_data((x=xs, s=["a", "bb"][mod1.(1:100, 2)]))
+                    t = Table(sp, ap)
+                    @assert collect(t.x) == xs
+                    i % 50 == 0 && GC.gc(false)
+                end
+            end) for _ = 1:4
+    ]
+    foreach(fetch, tasks)
+    @assert _collectuntil(() -> _registry_count() == 0) _registry_count()
+
+    # A garbage collection on another thread hands an import's release to the
+    # thread that imported it, so a release that waits on a lock the importing
+    # thread holds (Python's GIL) cannot stall the collection.
+    importer = Threads.threadid()
+    crossed = false
+    for _ = 1:20
+        @atomic TEST_RELEASE_THREAD.id = 0
+        _drop_import()
+        collector = fetch(errormonitor(Threads.@spawn begin
+            GC.gc(true)
+            Threads.threadid()
+        end))
+        _waitfor(() -> (@atomic TEST_RELEASE_THREAD.id) != 0)
+        @assert (@atomic TEST_RELEASE_THREAD.id) == importer
+        crossed = collector != importer
+        crossed && break
+    end
+    @assert crossed
+
+    # A thread Julia adopted from a foreign library runs no Julia tasks, so an
+    # import made there is released on thread 1 once collected.
+    @atomic TEST_RELEASE_THREAD.id = 0
+    _drop_import_on_foreign_thread()
+    @assert FOREIGN_POOL[] === :foreign
+    _collectuntil(() -> (@atomic TEST_RELEASE_THREAD.id) != 0)
+    released = @atomic TEST_RELEASE_THREAD.id
+    @assert released == 1 released
+    return nothing
+end
diff --git a/test/support/generate_dictionary_fixtures.py b/test/support/generate_dictionary_fixtures.py
new file mode 100644
index 00000000..20266783
--- /dev/null
+++ b/test/support/generate_dictionary_fixtures.py
@@ -0,0 +1,57 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import pyarrow as pa, pyarrow.ipc as ipc
+from pathlib import Path
+root=Path(__file__).resolve().parents[1] / 'fixtures-dictionaries';root.mkdir(exist_ok=True)
+cases={'strings':pa.array(['alpha','beta','gamma',None,'delta']), 'bool':pa.array([True,False,None,True,False]), 'int':pa.array([1,2,3,None,4],type=pa.int16()), 'list':pa.array([[1,2],[],[3],None,[4,5]],type=pa.list_(pa.int32())), 'struct':pa.array([{'x':1},{'x':2},{'x':3},None,{'x':4}],type=pa.struct([('x',pa.int32())]))}
+for name,values in cases.items():
+ for kind in ('stream','file'):
+  for codec in (None,'lz4','zstd'):
+   batches=[pa.record_batch({'a':pa.DictionaryArray.from_arrays(pa.array(ix,pa.int32()),values.slice(0,n))}) for n,ix in [(2,[0,1,None]),(3,[2,0,None]),(5,[3,4,1])]]
+   path=root/f'{name}-{kind}-{codec}.arrowbytes'
+   opener=ipc.new_stream if kind=='stream' else ipc.new_file
+   with opener(path,batches[0].schema,options=ipc.IpcWriteOptions(emit_dictionary_deltas=True,compression=codec)) as w:
+    for b in batches:w.write_batch(b)
+    assert w.stats.num_dictionary_deltas==2, (name,w.stats)
+   print(path)
+
+# Issue #610: full replacements with no schema feature declaration.
+for version in (ipc.MetadataVersion.V4, ipc.MetadataVersion.V5):
+    batches = [pa.record_batch({'a': pa.DictionaryArray.from_arrays(
+        pa.array([0, 1], pa.int32()), pa.array(pool))})
+        for pool in (['alpha', 'beta'], ['gamma', 'delta'])]
+    path = root / f'replacement-{version.name}.arrowbytes'
+    with ipc.new_stream(path, batches[0].schema,
+                        options=ipc.IpcWriteOptions(metadata_version=version)) as w:
+        for batch in batches:
+            w.write_batch(batch)
+        assert w.stats.num_replaced_dictionaries == 1
+    assert ipc.open_stream(path).read_all().column(0).to_pylist() == [
+        'alpha', 'beta', 'gamma', 'delta']
+print('Generated with PyArrow', pa.__version__)
+
+# V4 metadata also supports deltas; only body compression requires V5.
+values = pa.array(['alpha', 'beta', 'gamma'])
+batches = [pa.record_batch({'a': pa.DictionaryArray.from_arrays(
+    pa.array([n-1], pa.int32()), values.slice(0, n))}) for n in (2, 3)]
+for kind, opener in [('stream', ipc.new_stream), ('file', ipc.new_file)]:
+    with opener(root / f'delta-V4-{kind}.arrowbytes', batches[0].schema,
+                options=ipc.IpcWriteOptions(metadata_version=ipc.MetadataVersion.V4,
+                                            emit_dictionary_deltas=True)) as w:
+        for batch in batches:
+            w.write_batch(batch)
+        assert w.stats.num_dictionary_deltas == 1
diff --git a/test/support/generate_polars_fixtures.py b/test/support/generate_polars_fixtures.py
new file mode 100644
index 00000000..9a9d2a9c
--- /dev/null
+++ b/test/support/generate_polars_fixtures.py
@@ -0,0 +1,48 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Writes the Polars IPC fixtures read by test/polars_tests.jl.
+import datetime, decimal
+from pathlib import Path
+import polars as pl
+
+root = Path(__file__).resolve().parents[1] / "fixtures-polars"
+root.mkdir(exist_ok=True)
+df = pl.DataFrame({
+    "i": [1, 2, None],
+    "f": [1.5, None, 3.0],
+    "s": ["a", None, "a much longer string value"],
+    "b": [True, False, None],
+    "d": [datetime.date(2024, 1, 1), None, datetime.date(2024, 1, 3)],
+    "ts": [datetime.datetime(2024, 1, 1, 12), None, datetime.datetime(2024, 1, 3)],
+    "dur": [datetime.timedelta(seconds=5), None, datetime.timedelta(days=1)],
+    "t": [datetime.time(1, 2, 3), None, datetime.time(23, 59)],
+    "dec": pl.Series([decimal.Decimal("1.25"), None, decimal.Decimal("-3.50")],
+                     dtype=pl.Decimal(10, 2)),
+    "cat": pl.Series(["x", "y", "x"], dtype=pl.Categorical),
+    "l": [[1, 2], None, []],
+    "bin": [b"\x00\x01", None, b"xyz"],
+})
+for name, kw in (("default", {}), ("lz4", {"compression": "lz4"}),
+                 ("zstd", {"compression": "zstd"})):
+    df.write_ipc(root / f"{name}.arrowbytes", **kw)
+df.write_ipc_stream(root / "stream.arrowbytes")
+# Polars' 128-bit integers use the non-standard Int bitWidth 128.
+pl.DataFrame({
+    "i128": pl.Series([1, -(2**100), None], dtype=pl.Int128),
+    "u128": pl.Series([2**127 + 5, 0, None], dtype=pl.UInt128),
+}).write_ipc(root / "int128.arrowbytes")
+print("Generated with Polars", pl.__version__)
diff --git a/test/support/mapped.jl b/test/support/mapped.jl
new file mode 100644
index 00000000..55a9ab08
--- /dev/null
+++ b/test/support/mapped.jl
@@ -0,0 +1,33 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Delete `path`, which views that are now garbage may still map. Windows
+# refuses to delete a mapped file until the mapping's finalizer has run, so
+# this collects and retries, and in the end leaves the file in the temporary
+# directory: deleting it is cleanup, not a check.
+function rmmapped(path::AbstractString)
+    for _ = 1:20
+        GC.gc(true)
+        try
+            rm(path; force=true)
+            return true
+        catch err
+            (Sys.iswindows() && err isa Base.IOError) || rethrow()
+            sleep(0.05)
+        end
+    end
+    return false
+end
diff --git a/test/testappend.jl b/test/testappend.jl
deleted file mode 100644
index b289d4c9..00000000
--- a/test/testappend.jl
+++ /dev/null
@@ -1,154 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-
-function testappend(nm, t, writekw, readkw, extratests)
-    @testset "append: $nm" begin
-        io = Arrow.tobuffer(t; writekw...)
-        bytes = read(io)
-        mktemp() do path, io
-            write(io, bytes)
-            close(io)
-
-            t1 = Arrow.Table(read(path); readkw...)
-            f1 = first(Tables.columns(t1))
-            Arrow.append(path, t1; writekw..., readkw...)
-            nparts = 0
-            for t2 in Arrow.Stream(path)
-                @test isequal(f1, first(Tables.columns(t2)))
-                nparts += 1
-            end
-            @test nparts == 2
-        end
-    end
-end
-
-function testappend_compression(compression_option)
-    mktempdir() do path
-        testdata = (col1=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],)
-        file1 = joinpath(path, "table1.arrow")
-        file2 = joinpath(path, "table2.arrow")
-
-        open(file1, "w") do io
-            Arrow.write(io, testdata; file=false, compress=compression_option)
-        end
-        isstream, schema, compression = open(Arrow.stream_properties, file1)
-        @test isstream
-        @test compression == compression_option
-
-        open(file2, "w") do io
-            Arrow.write(io, testdata; file=false)
-        end
-
-        arrow_table2 = Arrow.Table(file2)
-        arrow_table2 |> Arrow.append(file1)
-        arrow_table1 = Arrow.Table(file1)
-
-        isstream, schema, compression = open(Arrow.stream_properties, file1)
-        @test isstream
-        @test compression == compression_option
-
-        @test length(Tables.columns(arrow_table1)[1]) == 20
-        @test length(Tables.columns(arrow_table2)[1]) == 10
-    end
-end
-
-function testappend_partitions()
-    mktempdir() do path
-        testdata = (col1=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],)
-        file1 = joinpath(path, "table1.arrow")
-        file2 = joinpath(path, "table2.arrow")
-        open(file1, "w") do io
-            Arrow.write(io, testdata; file=false)
-        end
-        arrow_table1 = Arrow.Table(file1)
-        isstream, schema, compression = open(Arrow.stream_properties, file1)
-        @test isstream
-        @test compression === nothing
-        @test schema.names == (:col1,)
-        @test schema.types == (Int64,)
-
-        # can only append to arrow stream
-        open(file2, "w") do io
-            Arrow.write(io, testdata; file=true)
-        end
-        @test_throws ArgumentError Arrow.append(file2, arrow_table1)
-
-        # can append to an empty file
-        rm(file2)
-        for _ = 1:5
-            Arrow.append(file2, arrow_table1)
-        end
-        appended_table1 = Arrow.Table(file2)
-        @test length(Tables.columns(appended_table1)[1]) == 50
-
-        # schema must match
-        testdata2 = (col2=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],)
-        open(file2, "w") do io
-            Arrow.write(io, testdata2; file=false)
-        end
-        @test_throws ArgumentError Arrow.append(file2, arrow_table1)
-
-        # recreate file2 in arrow format with correct schema
-        open(file2, "w") do io
-            Arrow.write(io, testdata; file=false)
-        end
-
-        # start
-        # arrow_table1: 1 partition, 10 rows
-        # arrow_table2: 1 partition, 10 rows
-        arrow_table2 = Arrow.Table(file2)
-        @test length(Tables.columns(arrow_table1)[1]) == 10
-        @test length(Tables.columns(arrow_table2)[1]) == 10
-
-        @test_throws ArgumentError Arrow.append(file1, arrow_table2; ntasks=-1)
-        arrow_table2 |> Arrow.append(file1)
-        arrow_table1 = Arrow.Table(file1)
-        # now
-        # arrow_table1: 2 partitions, 20 rows
-        # arrow_table2: 1 partition, 10 rows
-
-        @test Tables.schema(arrow_table1) == Tables.schema(arrow_table2)
-        @test length(Tables.columns(arrow_table1)[1]) == 20
-        @test length(Tables.columns(arrow_table2)[1]) == 10
-        @test length(collect(Tables.partitions(Arrow.Stream(file1)))) ==
-              2 * length(collect(Tables.partitions(Arrow.Stream(file2))))
-
-        Arrow.append(file2, arrow_table1; ntasks=1) # append with single task
-        arrow_table2 = Arrow.Table(file2)
-        # now
-        # arrow_table1: 2 partitions, 20 rows
-        # arrow_table2: 2 partitions, 30 rows (both partitions of table1 are appended as separate partitions)
-
-        @test Tables.schema(arrow_table1) == Tables.schema(arrow_table2)
-        @test length(Tables.columns(arrow_table1)[1]) == 20
-        @test length(Tables.columns(arrow_table2)[1]) == 30
-        @test length(collect(Tables.partitions(Arrow.Stream(file1)))) == 2
-        @test length(collect(Tables.partitions(Arrow.Stream(file2)))) == 3
-
-        Arrow.append(file1, Arrow.Stream(file2))
-        arrow_table1 = Arrow.Table(file1)
-        # now
-        # arrow_table1: 4 partitions, 50 rows (partitions of file2 stream are appended without being merged)
-        # arrow_table2: 2 partitions, 30 rows
-
-        @test Tables.schema(arrow_table1) == Tables.schema(arrow_table2)
-        @test length(Tables.columns(arrow_table1)[1]) == 50
-        @test length(Tables.columns(arrow_table2)[1]) == 30
-        @test length(collect(Tables.partitions(Arrow.Stream(file1)))) == 5
-        @test length(collect(Tables.partitions(Arrow.Stream(file2)))) == 3
-    end
-end
diff --git a/test/testtables.jl b/test/testtables.jl
deleted file mode 100644
index 1ee54045..00000000
--- a/test/testtables.jl
+++ /dev/null
@@ -1,340 +0,0 @@
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-testtables = [
-    (
-        "basic",
-        (col1=Int64[1, 2, 3, 4, 5, 6, 7, 8, 9, 10],),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "missing values",
-        (col1=Union{Int64,Missing}[1, 2, 3, 4, 5, 6, 7, 8, 9, missing],),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "primitive types",
-        (
-            col1=[missing, missing, missing, missing],
-            col2=Union{UInt8,Missing}[0, 1, 2, missing],
-            col3=Union{UInt16,Missing}[0, 1, 2, missing],
-            col4=Union{UInt32,Missing}[0, 1, 2, missing],
-            col5=Union{UInt64,Missing}[0, 1, 2, missing],
-            col6=Union{Int8,Missing}[0, 1, 2, missing],
-            col7=Union{Int16,Missing}[0, 1, 2, missing],
-            col8=Union{Int32,Missing}[0, 1, 2, missing],
-            col9=Union{Int64,Missing}[0, 1, 2, missing],
-            col10=Union{Float16,Missing}[0, 1, 2, missing],
-            col11=Union{Float32,Missing}[0, 1, 2, missing],
-            col12=Union{Float64,Missing}[0, 1, 2, missing],
-            col13=[true, false, true, missing],
-        ),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "arrow date/time types",
-        (
-            col14=[
-                zero(Arrow.Decimal{Int32(2),Int32(2),Int128}),
-                zero(Arrow.Decimal{Int32(2),Int32(2),Int128}),
-                zero(Arrow.Decimal{Int32(2),Int32(2),Int128}),
-                missing,
-            ],
-            col15=[
-                zero(Arrow.Date{Arrow.Meta.DateUnit.DAY,Int32}),
-                zero(Arrow.Date{Arrow.Meta.DateUnit.DAY,Int32}),
-                zero(Arrow.Date{Arrow.Meta.DateUnit.DAY,Int32}),
-                missing,
-            ],
-            col16=[
-                zero(Arrow.Time{Arrow.Meta.TimeUnit.SECOND,Int32}),
-                zero(Arrow.Time{Arrow.Meta.TimeUnit.SECOND,Int32}),
-                zero(Arrow.Time{Arrow.Meta.TimeUnit.SECOND,Int32}),
-                missing,
-            ],
-            col17=[
-                zero(Arrow.Timestamp{Arrow.Meta.TimeUnit.SECOND,nothing}),
-                zero(Arrow.Timestamp{Arrow.Meta.TimeUnit.SECOND,nothing}),
-                zero(Arrow.Timestamp{Arrow.Meta.TimeUnit.SECOND,nothing}),
-                missing,
-            ],
-            col18=[
-                zero(Arrow.Interval{Arrow.Meta.IntervalUnit.YEAR_MONTH,Int32}),
-                zero(Arrow.Interval{Arrow.Meta.IntervalUnit.YEAR_MONTH,Int32}),
-                zero(Arrow.Interval{Arrow.Meta.IntervalUnit.YEAR_MONTH,Int32}),
-                missing,
-            ],
-            col19=[
-                zero(Arrow.Duration{Arrow.Meta.TimeUnit.SECOND}),
-                zero(Arrow.Duration{Arrow.Meta.TimeUnit.SECOND}),
-                zero(Arrow.Duration{Arrow.Meta.TimeUnit.SECOND}),
-                missing,
-            ],
-            col20=[
-                zero(Arrow.Date{Arrow.Meta.DateUnit.MILLISECOND,Int64}),
-                zero(Arrow.Date{Arrow.Meta.DateUnit.MILLISECOND,Int64}),
-                zero(Arrow.Date{Arrow.Meta.DateUnit.MILLISECOND,Int64}),
-                missing,
-            ],
-        ),
-        NamedTuple(),
-        (convert=false,),
-        nothing,
-    ),
-    (
-        "list types",
-        (
-            col1=Union{String,Missing}["hey", "there", "sailor", missing],
-            col2=Union{Vector{UInt8},Missing}[b"hey", b"there", b"sailor", missing],
-            col3=Union{Vector{Int64},Missing}[Int64[1], Int64[2], Int64[3], missing],
-            col4=Union{NTuple{2,Vector{Int64}},Missing}[
-                (Int64[1], Int64[2]),
-                missing,
-                missing,
-                (Int64[3], Int64[4]),
-            ],
-            col5=Union{NTuple{2,UInt8},Missing}[
-                (0x01, 0x02),
-                (0x03, 0x04),
-                missing,
-                (0x05, 0x06),
-            ],
-            col6=NamedTuple{(:a, :b),Tuple{Int64,String}}[
-                (a=Int64(1), b="hey"),
-                (a=Int64(2), b="there"),
-                (a=Int64(3), b="sailor"),
-                (a=Int64(4), b="jo-bob"),
-            ],
-        ),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    ("empty list types", (col1=[[]], col2=[()]), NamedTuple(), NamedTuple(), nothing),
-    (
-        "unions",
-        (
-            col1=Arrow.DenseUnionVector(
-                Union{Int64,Float64,Missing}[1, 2.0, 3, 4.0, missing],
-            ),
-            col2=Arrow.SparseUnionVector(
-                Union{Int64,Float64,Missing}[1, 2.0, 3, 4.0, missing],
-            ),
-        ),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "dict encodings",
-        (col1=Arrow.DictEncode(Int64[4, 5, 6]),),
-        NamedTuple(),
-        NamedTuple(),
-        function (tt)
-            col1 = copy(tt.col1)
-            @test typeof(col1) == PooledVector{Int64,Int8,Vector{Int8}}
-        end,
-    ),
-    (
-        "more dict encodings",
-        (
-            col1=Arrow.DictEncode(
-                NamedTuple{(:a, :b),Tuple{Int64,Union{String,Missing}}}[
-                    (a=Int64(1), b=missing),
-                    (a=Int64(1), b=missing),
-                    (a=Int64(3), b="sailor"),
-                    (a=Int64(4), b="jo-bob"),
-                ],
-            ),
-        ),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    ("PooledArray", (col1=PooledArray([4, 5, 6, 6]),), NamedTuple(), NamedTuple(), nothing),
-    (
-        "auto-converting types",
-        (
-            col1=[Date(2001, 1, 2), Date(2010, 10, 10), Date(2020, 12, 1)],
-            col2=[Time(1, 1, 2), Time(13, 10, 10), Time(22, 12, 1)],
-            col3=[DateTime(2001, 1, 2), DateTime(2010, 10, 10), DateTime(2020, 12, 1)],
-            col4=[
-                ZonedDateTime(2001, 1, 2, TimeZone("America/Denver")),
-                ZonedDateTime(2010, 10, 10, TimeZone("America/Denver")),
-                ZonedDateTime(2020, 12, 1, TimeZone("America/Denver")),
-            ],
-        ),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "Map",
-        (col1=[Dict(Int32(1) => Float32(3.14)), missing],),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "non-standard types",
-        (
-            col1=[:hey, :there, :sailor],
-            col2=['a', 'b', 'c'],
-            col3=Arrow.DictEncode(['a', 'a', 'b']),
-            col4=[
-                UUID("48075322-8645-4ac6-b590-c9f46068565a"),
-                UUID("99c7d976-ccfd-45b9-9793-51008607c638"),
-                UUID("f96d9974-5a7b-47e3-bbc0-d680d11490d4"),
-            ],
-        ),
-        NamedTuple(),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "large lists",
-        (
-            col1=Union{String,Missing}["hey", "there", "sailor", missing],
-            col2=Union{Vector{UInt8},Missing}[b"hey", b"there", b"sailor", missing],
-            col3=Union{Vector{Int64},Missing}[Int64[1], Int64[2], Int64[3], missing],
-            col4=Union{NTuple{2,Vector{Int64}},Missing}[
-                (Int64[1], Int64[2]),
-                missing,
-                missing,
-                (Int64[3], Int64[4]),
-            ],
-            col5=Union{NTuple{2,UInt8},Missing}[
-                (0x01, 0x02),
-                (0x03, 0x04),
-                missing,
-                (0x05, 0x06),
-            ],
-            col6=NamedTuple{(:a, :b),Tuple{Int64,String}}[
-                (a=Int64(1), b="hey"),
-                (a=Int64(2), b="there"),
-                (a=Int64(3), b="sailor"),
-                (a=Int64(4), b="jo-bob"),
-            ],
-        ),
-        (largelists=true,),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "dictencode keyword",
-        (
-            col1=Int64[1, 2, 3, 4],
-            col2=Union{String,Missing}["hey", "there", "sailor", missing],
-            col3=Arrow.DictEncode(
-                NamedTuple{(:a, :b),Tuple{Int64,Union{String,Missing}}}[
-                    (a=Int64(1), b=missing),
-                    (a=Int64(1), b=missing),
-                    (a=Int64(3), b="sailor"),
-                    (a=Int64(4), b="jo-bob"),
-                ],
-            ),
-            col4=[:a, :b, :c, missing],
-            col5=[Date(2020, 1, 1) for x = 1:4],
-        ),
-        (dictencode=true,),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "nesteddictencode keyword",
-        (
-            col1=NamedTuple{
-                (:a, :b),
-                Tuple{Int64,Union{Missing,NamedTuple{(:c,),Tuple{String}}}},
-            }[
-                (a=Int64(1), b=missing),
-                (a=Int64(1), b=missing),
-                (a=Int64(3), b=(c="sailor",)),
-                (a=Int64(4), b=(c="jo-bob",)),
-            ],
-        ),
-        (dictencode=true, dictencodenested=true),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "Julia unions",
-        (
-            col1=Union{Int,String}[1, "hey", 2, "ho"],
-            col2=Union{Char,NamedTuple{(:a,),Tuple{Symbol}}}['a', (a=:hey,), 'b', (a=:ho,)],
-        ),
-        (denseunions=false,),
-        NamedTuple(),
-        nothing,
-    ),
-    (
-        "Decimal256",
-        (
-            col1=[
-                zero(Arrow.Decimal{Int32(2),Int32(2),Arrow.Int256}),
-                zero(Arrow.Decimal{Int32(2),Int32(2),Arrow.Int256}),
-                zero(Arrow.Decimal{Int32(2),Int32(2),Arrow.Int256}),
-                missing,
-            ],
-        ),
-        NamedTuple(),
-        (convert=false,),
-        nothing,
-    ),
-];
-
-function testtable(nm, t, writekw, readkw, extratests)
-    @testset "testing: $nm" begin
-        io = Arrow.tobuffer(t; writekw...)
-        tt = Arrow.Table(io; readkw...)
-        @test length(tt) == length(t)
-        @test all(isequal.(values(t), values(tt)))
-        extratests !== nothing && extratests(tt)
-        seekstart(io)
-        str = Arrow.Stream(io; readkw...)
-        tt = first(str)
-        @test length(tt) == length(t)
-        @test all(isequal.(values(t), values(tt)))
-        # compressed
-        io = Arrow.tobuffer(t; compress=((:lz4, :zstd)[rand(1:2)]), writekw...)
-        tt = Arrow.Table(io; readkw...)
-        @test length(tt) == length(t)
-        @test all(isequal.(values(t), values(tt)))
-        extratests !== nothing && extratests(tt)
-        seekstart(io)
-        str = Arrow.Stream(io; readkw...)
-        tt = first(str)
-        @test length(tt) == length(t)
-        @test all(isequal.(values(t), values(tt)))
-        # file
-        io = Arrow.tobuffer(t; file=true, writekw...)
-        tt = Arrow.Table(io; readkw...)
-        @test length(tt) == length(t)
-        @test all(isequal.(values(t), values(tt)))
-        extratests !== nothing && extratests(tt)
-        seekstart(io)
-        str = Arrow.Stream(io; readkw...)
-        tt = first(str)
-        @test length(tt) == length(t)
-        @test all(isequal.(values(t), values(tt)))
-    end
-end
diff --git a/test/threaded_stress.jl b/test/threaded_stress.jl
new file mode 100644
index 00000000..d3198d23
--- /dev/null
+++ b/test/threaded_stress.jl
@@ -0,0 +1,92 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Stress the concurrent validation caches and the shared allocation budget.
+# Run as a child process with `-t 4` (core_tests.jl launches it with
+# `--threads=4`); it requires Threads.nthreads() >= 4.
+
+using Test
+
+using Arrow
+using Arrow.ArrowCore
+using Tables
+const AC = ArrowCore
+
+@testset "ArrowCore threaded caches" begin
+    @test Threads.nthreads() >= 4
+
+    @testset "concurrent validation caches" begin
+        f, built = fromjulia("x", [i % 7 == 0 ? missing : i for i = 1:10_000])
+        d = AC.ArrayData(built.type, built.len, built.buffers)
+        expected = count(i -> i % 7 == 0, 1:10_000)
+        failures = AC.ReleaseCounter()
+        Threads.@threads for _ = 1:1000
+            try
+                nullcount(d) == expected || AC.increment!(failures)
+                validate_semantic(f, d) === d || AC.increment!(failures)
+            catch
+                AC.increment!(failures)
+            end
+        end
+        @test failures[] == 0
+        @test (@atomic d.nullcount) == expected
+        @test (@atomic d.semachecked)
+    end
+
+    @testset "concurrent allocation budget" begin
+        limit = 100_000
+        budget = Arrow.AllocationBudget(limit)
+        successes = Threads.Atomic{Int}(0)
+        @sync for _ = 1:Threads.nthreads()
+            Threads.@spawn for _ = 1:limit
+                try
+                    Arrow._charge!(budget, Int64(1), "threaded budget probe")
+                    Threads.atomic_add!(successes, 1)
+                catch e
+                    e isa Arrow.AllocationLimitError || rethrow()
+                end
+            end
+        end
+        @test successes[] == limit
+        @test Arrow._remaining(budget) == 0
+    end
+
+    @testset "parallel reads from concurrent tasks" begin
+        n = 100_000
+        parts = Tables.partitioner([
+            (x=collect(1:n), s=[i % 9 == 0 ? missing : string(i, base=7) for i = 1:n]),
+            (x=collect(1:n), s=[repeat("long value ", i % 4) for i = 1:n]),
+        ])
+        io = IOBuffer()
+        Arrow.write(io, parts; compress=:zstd)
+        bytes = take!(io)
+        expected = Arrow.Table(bytes; ntasks=1)
+        failures = AC.ReleaseCounter()
+        tasks = map(1:4) do _
+            errormonitor(
+                Threads.@spawn begin
+                    for _ = 1:5
+                        t = Arrow.Table(bytes; ntasks=4)
+                        isequal(t.x, expected.x) && isequal(t.s, expected.s) ||
+                            AC.increment!(failures)
+                    end
+                end
+            )
+        end
+        foreach(wait, tasks)
+        @test failures[] == 0
+    end
+end
diff --git a/test/timezones_child.jl b/test/timezones_child.jl
new file mode 100644
index 00000000..7d13fbf3
--- /dev/null
+++ b/test/timezones_child.jl
@@ -0,0 +1,111 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# ArrowTimeZonesExt coverage. Loading TimeZones.jl activates the extension
+# for the whole process, so compat_tests.jl re-execs this file as a child:
+# the parent process stays extension-free and keeps testing the
+# TimeZones-free reads.
+module TimeZonesExtChild
+
+using Test, Dates, Tables, TimeZones
+import Arrow
+import Durations
+using Durations: ZonedTimestamp
+const AC = Arrow.ArrowCore
+
+# One single-column file-format buffer with a timestamp descriptor built
+# directly, exercising the read side independently of the fresh writer.
+function tzfile(unit, tz, values::Vector{Int64}; validity=nothing)
+    t = AC.TimestampType(unit, tz)
+    bufs =
+        validity === nothing ? [AC.BufferSlice(), AC._databuffer(values)] :
+        [AC._databuffer(validity), AC._databuffer(values)]
+    d = AC.ArrayData(t, length(values), bufs; nullcount=validity === nothing ? 0 : -1)
+    f = AC.Field("ts", t; nullable=validity !== nothing)
+    sch = AC.Schema([f])
+    return Arrow.writefile(sch, [AC.RecordBatch(sch, [d])])
+end
+
+@testset "ArrowTimeZonesExt" begin
+    @test Base.get_extension(Arrow, :ArrowTimeZonesExt) !== nothing
+    @test Base.get_extension(Durations, :DurationsTimeZonesExt) !== nothing
+    denver = tz"America/Denver"
+    Dnv = ZonedTimestamp{Millisecond,Symbol("America/Denver")}
+
+    @testset "zoned reads are ZonedTimestamp; ZonedDateTime compares" begin
+        t = Arrow.Table(tzfile(AC.MILLISECOND, "America/Denver", Int64[0, 1_000]))
+        @test eltype(t.ts) == Dnv
+        @test t.ts[1] == ZonedDateTime(DateTime(1970, 1, 1), denver; from_utc=true)
+        @test t.ts[2] == ZonedDateTime(DateTime(1970, 1, 1, 0, 0, 1), denver; from_utc=true)
+        @test ZonedDateTime(t.ts[1]) ==
+              ZonedDateTime(DateTime(1970, 1, 1), denver; from_utc=true)
+        # named-zone local-time operations work with TimeZones loaded
+        @test hour(t.ts[1]) == 17  # 1970-01-01T00:00 UTC is 17:00 MST the day before
+        @test Date(t.ts[1]) == Date(1969, 12, 31)
+    end
+
+    @testset "second unit scales" begin
+        t = Arrow.Table(tzfile(AC.SECOND, "UTC", Int64[42]))
+        @test eltype(t.ts) == ZonedTimestamp{Second,:UTC}
+        @test t.ts[1] ==
+              ZonedDateTime(DateTime(1970, 1, 1, 0, 0, 42), tz"UTC"; from_utc=true)
+    end
+
+    @testset "fresh ZonedDateTime columns write as timestamps" begin
+        zs = [
+            ZonedDateTime(DateTime(2020, 1, 1, 12), denver),
+            ZonedDateTime(DateTime(2020, 1, 2, 12), denver),
+        ]
+        io = IOBuffer()
+        Arrow.write(io, (; ts=zs))
+        t = Arrow.Table(take!(io))
+        @test eltype(t.ts) == Dnv
+        @test t.ts == zs
+        @test ZonedDateTime.(t.ts) == zs
+        mixed =
+            [ZonedDateTime(DateTime(2020), denver), ZonedDateTime(DateTime(2020), tz"UTC")]
+        @test_throws ArgumentError Arrow.write(IOBuffer(), (; ts=mixed))
+        io = IOBuffer()
+        Arrow.write(io, (; ts=[zs[1], missing]))
+        t2 = Arrow.Table(take!(io))
+        @test eltype(t2.ts) == Union{Missing,Dnv}
+        @test t2.ts[1] == zs[1]
+        @test t2.ts[2] === missing
+    end
+
+    @testset "scan filter compares a ZonedDateTime literal" begin
+        bytes = tzfile(AC.MILLISECOND, "America/Denver", Int64[0, 1_000, 2_000])
+        want = ZonedDateTime(DateTime(1970, 1, 1, 0, 0, 1), denver; from_utc=true)
+        for op in (==, <)  # zoned columns push down ordered comparisons too
+            t = Arrow.Table(
+                bytes;
+                scan=Tables.Scan(filter=Tables.colcmp(op, Tables.col(:ts), want)),
+            )
+            @test length(t.ts) == 1
+            @test only(t.ts) == (op === (==) ? want : want - Second(1))
+        end
+        # a sub-second ZonedDateTime literal against a SECOND column
+        sbytes = tzfile(AC.SECOND, "America/Denver", Int64[0, 1, 2])
+        subsec = ZonedDateTime(DateTime(1970, 1, 1, 0, 0, 1, 500), denver; from_utc=true)
+        t = Arrow.Table(
+            sbytes;
+            scan=Tables.Scan(filter=Tables.colcmp(<, Tables.col(:ts), subsec)),
+        )
+        @test length(t.ts) == 2
+    end
+end
+
+end # module TimeZonesExtChild
diff --git a/src/metadata/Flatbuf.jl b/test/trim/Project.toml
similarity index 82%
rename from src/metadata/Flatbuf.jl
rename to test/trim/Project.toml
index 9e9f2e44..3077b3a6 100644
--- a/src/metadata/Flatbuf.jl
+++ b/test/trim/Project.toml
@@ -14,13 +14,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-module Flatbuf
 
-using EnumX
-using ..FlatBuffers
+[deps]
+DataStrings = "48204bd6-5611-42ea-b167-fc1d713f9be2"
+JuliaC = "acedd4c2-ced6-4a15-accc-2607eb759ba2"
 
-include("Schema.jl")
-include("File.jl")
-include("Message.jl")
-
-end # module
+[compat]
+DataStrings = "1"
+JuliaC = "=0.3.8"
+julia = "1.12"
diff --git a/test/trim_compile_tests.jl b/test/trim_compile_tests.jl
new file mode 100644
index 00000000..4d47ad20
--- /dev/null
+++ b/test/trim_compile_tests.jl
@@ -0,0 +1,147 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# JuliaC `--trim=safe` compile gate for ArrowCore and DataStrings, following the harness
+# convention from JSON/HTTP/Reseau/StructUtils: compile the workload
+# entrypoint, require ZERO verifier errors and ZERO verifier warnings, then
+# run the produced binary and require exit 0.
+#
+# Run explicitly (needs network on first run to install JuliaC):
+#     julia --startup-file=no test/trim_compile_tests.jl
+#
+# It is intentionally NOT included by test/runtests.jl (it installs JuliaC
+# and compiles a binary; the default suite stays fast).
+
+using Test
+import Pkg
+
+const _TRIM_SUPPORTED = VERSION >= v"1.12.0-rc1"
+const _JULIAC_ENTRYPOINT_EXPR = "using JuliaC; if isdefined(JuliaC, :main); JuliaC.main(ARGS); else JuliaC._main_cli(ARGS); end"
+const _TRIM_COMPILE_TIMEOUT_S = 600.0
+const _TRIM_RUN_TIMEOUT_S = 60.0
+
+function _prepare_trim_project(trim_project::String)::Nothing
+    mkpath(trim_project)
+    cp(
+        joinpath(@__DIR__, "trim", "Project.toml"),
+        joinpath(trim_project, "Project.toml");
+        force=true,
+    )
+    original_project = Base.active_project()
+    try
+        Pkg.activate(trim_project)
+        Pkg.instantiate()
+    finally
+        original_project === nothing || Pkg.activate(dirname(original_project))
+    end
+    return nothing
+end
+
+function _run_with_timeout(cmd::Cmd; timeout_s::Float64, label::String)
+    output_path = tempname()
+    out = open(output_path, "w")
+    exit_code = -1
+    timed_out = false
+    try
+        proc = run(pipeline(ignorestatus(cmd), stdout=out, stderr=out); wait=false)
+        started = time()
+        next_log = started + 15.0
+        while Base.process_running(proc)
+            if time() - started >= timeout_s
+                kill(proc)
+                timed_out = true
+                break
+            end
+            if time() >= next_log
+                println("[trim] $(label) WAIT $(round(time() - started; digits=1))s")
+                flush(stdout)
+                next_log = time() + 15.0
+            end
+            sleep(0.2)
+        end
+        timed_out || wait(proc)
+        exit_code = something(proc.exitcode, -1)
+    finally
+        close(out)
+    end
+    output = try
+        read(output_path, String)
+    catch
+        ""
+    finally
+        rm(output_path; force=true)
+    end
+    return exit_code, output, timed_out
+end
+
+function _count_verifier_messages(output::String)::Tuple{Int,Int}
+    errors = length(collect(eachmatch(r"Verifier error #\d+:", output)))
+    warnings = length(collect(eachmatch(r"Verifier warning #\d+:", output)))
+    return errors, warnings
+end
+
+@testset "ArrowCore and DataStrings trim compile" begin
+    if !_TRIM_SUPPORTED
+        println("[trim] skip: JuliaC --trim requires Julia >= 1.12")
+    elseif Sys.iswindows()
+        println("[trim] skip Windows: JuliaC trim compilation stalls on Windows CI")
+    else
+        script_path = joinpath(@__DIR__, "trim_entrypoint.jl")
+        @test isfile(script_path)
+        mktempdir() do tmp
+            trim_project = joinpath(tmp, "trimproj")
+            _prepare_trim_project(trim_project)
+            cd(tmp) do
+                julia_exe = joinpath(Sys.BINDIR, Base.julia_exename())
+                cmd = `$julia_exe --startup-file=no --history-file=no
+                    --project=$trim_project -e $_JULIAC_ENTRYPOINT_EXPR --
+                    --output-exe arrow_trim --project=$trim_project
+                    --experimental --trim=safe $script_path`
+                println("[trim] compile START")
+                exit_code, output, timed_out = _run_with_timeout(
+                    cmd;
+                    timeout_s=_TRIM_COMPILE_TIMEOUT_S,
+                    label="compile",
+                )
+                timed_out && error("trim compile timed out\n$output")
+                errors, warnings = _count_verifier_messages(output)
+                if errors > 0 || warnings > 0 || exit_code != 0
+                    println("---- trim compile output ----")
+                    println(output)
+                    println("---- end output ----")
+                end
+                @test errors == 0
+                @test warnings == 0
+                @test exit_code == 0
+                binpath = abspath("arrow_trim")
+                @test isfile(binpath)
+                run_exit, run_output, run_timed_out = _run_with_timeout(
+                    `$binpath`;
+                    timeout_s=_TRIM_RUN_TIMEOUT_S,
+                    label="run",
+                )
+                run_timed_out && error("trim executable timed out\n$run_output")
+                if run_exit != 0
+                    println("---- trim executable output ----")
+                    println(run_output)
+                    println("---- end output ----")
+                end
+                @test run_exit == 0
+                println("[trim] compile + run PASSED")
+            end
+        end
+    end
+end
diff --git a/test/trim_entrypoint.jl b/test/trim_entrypoint.jl
new file mode 100644
index 00000000..1c46033f
--- /dev/null
+++ b/test/trim_entrypoint.jl
@@ -0,0 +1,332 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# JuliaC `--trim=safe` workload for ArrowCore and DataStrings (compiled and
+# executed by test/trim_compile_tests.jl, following the trim harness convention
+# from JSON/HTTP/Reseau/StructUtils). Everything reachable from `main` must be
+# free of dynamic dispatch: this file is the executable definition of the
+# exercised trim-safe surface.
+
+include(joinpath(@__DIR__, "..", "src", "ArrowCore.jl"))
+using .ArrowCore
+import .ArrowCore: release!
+const AC = ArrowCore
+# The C data interface is part of the trim-safe surface: a trimmed binary
+# that moves columns across the C seams is the canonical embedding use.
+include(joinpath(@__DIR__, "..", "src", "cdata.jl"))
+using DataStrings
+using DataStrings: StringVector, StringPayload, BytesVector, DataBytes
+const AS = DataStrings
+
+function checked(cond::Bool, msg::String)::Nothing
+    cond || error(msg)
+    return nothing
+end
+
+function exercise_regions()::Nothing
+    v = Int64[1, 2, 3, 4]
+    r = heapregion(v)
+    b = BufferSlice(r, 0, 32)
+    checked(AC.loadat(b, Int64, Int64(0)) == 1, "heap load failed")
+    checked(AC.loadat(b, Int64, Int64(24)) == 4, "heap tail load failed")
+    sub = AC.subslice(b, 8, 16)
+    checked(AC.loadat(sub, Int64, Int64(0)) == 2, "subslice load failed")
+    # Validity is reachability: the region's root IS the vector's storage, and
+    # holding the region is what keeps the memory alive. No lifecycle state
+    # exists to exercise.
+    checked(r.root === AC._storageroot(v), "heap region root identity failed")
+    bytes = UInt8[0x7f]
+    fr = GC.@preserve bytes AC.OwnerRegion(Ptr{UInt8}(pointer(bytes)), 1; root=bytes)
+    fb = BufferSlice(fr, 0, 1)
+    checked(AC.loadat(fb, UInt8, Int64(0)) == 0x7f, "rooted raw load failed")
+    # Each raw load retains its final bounds check in the constrained model.
+    caught = false
+    try
+        AC.loadat(b, Int64, Int64(32))
+    catch e
+        caught = e isa BoundsError
+    end
+    checked(caught, "out-of-bounds load accepted")
+    return nothing
+end
+
+function exercise_mmap(dir::String)::Nothing
+    path = joinpath(dir, "trim.bin")
+    # Explicit open/write/close: Base's `write(filename, x)` convenience
+    # routes through the vararg-splatting do-block `open`, which trim cannot
+    # resolve.
+    io = open(path, "w")
+    write(io, UInt8[0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88])
+    close(io)
+    r = mmapregion(path)
+    b = BufferSlice(r, 0, 8)
+    checked(AC.loadat(b, UInt32, Int64(4)) == 0x88776655, "mmap load failed")
+    root = r.root
+    checked(
+        root isa Vector{UInt8} && length(root) == 8,
+        "mmap region root is not the stdlib-mapped array",
+    )
+    # Deterministic release: release! unmaps NOW (the Windows delete-a-mapped-
+    # file case) and later access is a clean error, not a fault.
+    release!(r)
+    caught = false
+    try
+        AC.loadat(b, UInt32, Int64(4))
+    catch e
+        caught = e isa InvalidStateException
+    end
+    checked(caught, "use after release! accepted")
+    return nothing
+end
+
+function exercise_cdata()::Nothing
+    f0, d = fromjulia("xs", Int64[1, 2, 3])
+    f = Field(
+        "xs",
+        f0.type;
+        nullable=f0.nullable,
+        metadata=["mk" => "mv"],
+        children=Field[],
+    )
+    sp, ap = to_c_data(f, d)
+    f2, d2 = from_c_data(sp, ap)
+    validate_semantic(f2, d2)
+    checked(getvalue(f2, d2, 3) === Int64(3), "cdata round-trip value failed")
+    m2 = f2.metadata
+    checked(
+        m2 !== nothing && length(m2) == 1 && first(m2[1]) == "mk" && last(m2[1]) == "mv",
+        "cdata metadata round-trip failed",
+    )
+    # A column imported over the C seam reads through a caller-supplied
+    # static type, fully resolved.
+    tm = materialize(Int64, f2, d2)
+    checked(tm isa Vector{Int64} && tm == Int64[1, 2, 3], "cdata typed materialize failed")
+    checked(nullcount(d2) == 0, "cdata round-trip nullcount failed")
+    # release! on the imported region runs the foreign release callback now;
+    # the export registry must be empty once the consumer releases.
+    release!(d2.buffers[2].region::OwnerRegion)
+    caught = false
+    try
+        getvalue(f2, d2, 1)
+    catch e
+        caught = e isa InvalidStateException
+    end
+    checked(caught, "use after cdata release accepted")
+    # The consumer's release counts the export off, and a reap frees it.
+    _reap!()
+    checked(isempty(EXPORTS), "export registry not empty after reap")
+    return nothing
+end
+
+function exercise_values()::Nothing
+    # Columns are adapted one concrete vector at a time: heterogeneous
+    # NamedTuple iteration (the `batch(nt)` convenience) is runtime-schema
+    # work that belongs to the facade's builders, not a trim-safe core path.
+    f1, c1 = fromjulia("xs", Int64[1, 2, 3])
+    f2, c2 = fromjulia("ys", [1.5, missing, 3.5])
+    f3, c3 = fromjulia("flags", [true, missing, false])
+    f4, c4 = fromjulia("strs", ["a", "", missing])
+    # A concrete Vector{Vector{Int64}} column; missing-list coverage lives
+    # in the plain test suite (a Union-eltype column makes this call's
+    # argument type imprecise for trim verification).
+    f5, c5 = fromjulia("lists", [Int64[1, 2], Int64[3], Int64[]])
+    for (f, col) in ((f1, c1), (f2, c2), (f3, c3), (f4, c4), (f5, c5))
+        validate_structural(f, col)
+        validate_semantic(f, col)
+    end
+    checked(getvalue(f1, c1, 2) === Int64(2), "int getvalue failed")
+    checked(nullcount(c2) == 1, "nullcount failed")
+    m1 = materialize(f1, c1)
+    checked(length(m1) == 3, "materialize length wrong")
+    checked(getvalue(f4, c4, 1) == "a", "string getvalue failed")
+    checked(getvalue(f4, c4, 3) === missing, "missing string wrong")
+    v5 = getvalue(f5, c5, 1)
+    checked(v5 isa Vector{Any} && length(v5) == 2, "list getvalue failed")
+    checked(getvalue(f5, c5, 3) isa Vector{Any}, "empty list getvalue failed")
+    # Hand-built struct column: `fromjulia_struct` iterates a heterogeneous
+    # NamedTuple (runtime-schema builder work, facade territory).
+    saf, sad = fromjulia("a", Int64[7, 8])
+    sbf, sbd = fromjulia("b", ["x", "y"])
+    sf = Field("st", StructType(); nullable=false, children=[saf, sbf])
+    sd = AC.ArrayData(StructType(), 2, [BufferSlice()]; children=[sad, sbd], nullcount=0)
+    validate_structural(sf, sd)
+    sv = getvalue(sf, sd, 2)
+    checked(sv isa Vector{Pair{String,Any}} && length(sv) == 2, "struct getvalue failed")
+    df, dd = AC.fromjulia_dict("d", ["lo", "hi"], [0, 1, missing, 0])
+    validate_structural(df, dd)
+    validate_semantic(df, dd)
+    checked(getvalue(df, dd, 4) == "lo", "dictionary getvalue failed")
+    checked(getvalue(df, dd, 3) === missing, "dictionary null failed")
+    return nothing
+end
+
+function exercise_typed_values()::Nothing
+    # A caller-supplied static schema makes element access fully
+    # resolvable — concrete claims at every call site below.
+    f1, c1 = fromjulia("xs", Int64[1, 2, 3])
+    checked(getvalue(Int64, f1, c1, 2) === Int64(2), "typed int failed")
+    m1 = materialize(Int64, f1, c1)
+    checked(m1 isa Vector{Int64} && m1[3] === Int64(3), "typed int materialize failed")
+    f2, c2 = fromjulia("ys", [1.5, missing, 3.5])
+    m2 = materialize(Union{Missing,Float64}, f2, c2)
+    checked(
+        m2 isa Vector{Union{Missing,Float64}} && m2[2] === missing,
+        "typed float materialize failed",
+    )
+    f4, c4 = fromjulia("strs", ["a", "", missing])
+    checked(getvalue(Union{Missing,String}, f4, c4, 1) == "a", "typed string failed")
+    f5, c5 = fromjulia("lists", [Int64[1, 2], Int64[3], Int64[]])
+    m5 = materialize(Vector{Int64}, f5, c5)
+    checked(
+        m5 isa Vector{Vector{Int64}} && m5[1] == Int64[1, 2],
+        "typed list materialize failed",
+    )
+    saf, sad = fromjulia("a", Int64[7, 8])
+    sbf, sbd = fromjulia("b", ["x", "y"])
+    sf = Field("st", StructType(); nullable=false, children=[saf, sbf])
+    sd = AC.ArrayData(StructType(), 2, [BufferSlice()]; children=[sad, sbd], nullcount=0)
+    sv = getvalue(NamedTuple{(:a, :b),Tuple{Int64,String}}, sf, sd, 2)
+    checked(sv === (a=Int64(8), b="y"), "typed struct failed")
+    df, dd = AC.fromjulia_dict("d", ["lo", "hi"], [0, 1, missing, 0])
+    checked(getvalue(Union{Missing,String}, df, dd, 2) == "hi", "typed dictionary failed")
+    # Four HETEROGENEOUS NamedTuple fields, both entry points: ntuple
+    # closures erase per-field types at this arity — the unrolled struct
+    # row must stay fully resolved.
+    h1f, h1d = fromjulia("a", Int64[1, 2])
+    h2f, h2d = fromjulia("b", [1.5, 2.5])
+    h3f, h3d = fromjulia("c", ["x", "y"])
+    h4f, h4d = fromjulia("flag", [true, false])
+    hf = Field("st4", StructType(); nullable=false, children=[h1f, h2f, h3f, h4f])
+    hd = AC.ArrayData(
+        StructType(),
+        2,
+        [BufferSlice()];
+        children=[h1d, h2d, h3d, h4d],
+        nullcount=0,
+    )
+    NT4 = NamedTuple{(:a, :b, :c, :flag),Tuple{Int64,Float64,String,Bool}}
+    hv = getvalue(NT4, hf, hd, 2)
+    checked(
+        hv === (a=Int64(2), b=2.5, c="y", flag=false),
+        "typed 4-field struct getvalue failed",
+    )
+    hm = materialize(NT4, hf, hd)
+    checked(hm isa Vector{NT4} && hm[1].c == "x", "typed 4-field struct materialize failed")
+    # The claim is exact: a mismatched static type refuses, never converts.
+    caught = false
+    try
+        getvalue(Int32, f1, c1, 1)
+    catch e
+        caught = e isa ArgumentError
+    end
+    checked(caught, "typed mismatch accepted")
+    caught = false
+    try
+        getvalue(Float64, f2, c2, 2)
+    catch e
+        caught = e isa ArgumentError
+    end
+    checked(caught, "typed null under non-missing claim accepted")
+    return nothing
+end
+
+function exercise_validation_errors()::Nothing
+    t = IntType(64, true)
+    f = Field("x", t)
+    short = AC._databuffer(Int64[1])
+    d = AC.ArrayData(t, 3, [BufferSlice(), short])
+    caught = false
+    try
+        validate_structural(f, d)
+    catch e
+        caught = e isa ValidationError
+    end
+    checked(caught, "short data buffer accepted")
+    ut = Utf8Type(false)
+    uf = Field("s", ut)
+    offs = AC._databuffer(Int32[0, 2, 1, 3])
+    data = AC._databuffer(UInt8[0x61, 0x62, 0x63])
+    ud = AC.ArrayData(ut, 3, [BufferSlice(), offs, data])
+    validate_structural(uf, ud)
+    caught = false
+    try
+        validate_semantic(uf, ud)
+    catch e
+        caught = e isa ValidationError
+    end
+    checked(caught, "non-monotonic offsets accepted")
+    return nothing
+end
+
+function exercise_arrowstrings()::Nothing
+    inline = UInt8[0x61, 0x62, 0x63, 0x64]
+    viewed = Vector{UInt8}(codeunits("a much longer value"))
+    p1 = AS.inline_payload(inline, 1, 4)
+    p2 = AS.view_payload(viewed, 1, length(viewed), 0, 0)
+    present = StringVector{DataString}([p1, p2], Vector{UInt8}[viewed])
+    checked(present[1] == "abcd", "DataStrings inline access failed")
+    checked(present[2] == "a much longer value", "DataStrings view access failed")
+    checked(isless(present[1], "z"), "DataStrings comparison failed")
+    materialized = AS.materialize(present)
+    checked(
+        materialized isa Vector{String} && materialized == ["abcd", "a much longer value"],
+        "DataStrings materialize failed",
+    )
+
+    nullable = StringVector{Union{Missing,DataString}}(
+        [p1, AS.PAYLOAD_MISSING, p2],
+        Vector{UInt8}[viewed],
+    )
+    checked(nullable[2] === missing, "DataStrings missing access failed")
+    nullable_materialized = AS.materialize(nullable)
+    checked(
+        nullable_materialized isa Vector{Union{String,Missing}} && isequal(
+            nullable_materialized,
+            Union{String,Missing}["abcd", missing, "a much longer value"],
+        ),
+        "DataStrings nullable materialize failed",
+    )
+    return nothing
+end
+
+function run_trim_workload()::Nothing
+    exercise_regions()
+    # Plain mkdir/rm rather than `mktempdir() do`: Base's temp-path cleanup
+    # registry (locks + atexit hooks) parks the scheduler under the trimmed
+    # runtime; the primitive filesystem calls are all the workload needs.
+    dir = joinpath(tempdir(), "arrowcore-trim-" * string(getpid()))
+    mkdir(dir)
+    try
+        exercise_mmap(dir)
+    finally
+        rm(joinpath(dir, "trim.bin"); force=true)
+        rm(dir)
+    end
+    exercise_values()
+    exercise_typed_values()
+    exercise_validation_errors()
+    exercise_cdata()
+    exercise_arrowstrings()
+    return nothing
+end
+
+function @main(args::Vector{String})::Cint
+    _ = args
+    run_trim_workload()
+    return 0
+end
+
+Base.Experimental.entrypoint(main, (Vector{String},))
diff --git a/test/typed_alloc_child.jl b/test/typed_alloc_child.jl
new file mode 100644
index 00000000..01bca20e
--- /dev/null
+++ b/test/typed_alloc_child.jl
@@ -0,0 +1,74 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Fresh-process typed-materialization allocation pin: the
+# recursion architecture must not box per row in a process that never ran
+# compiler introspection — warm-up alone must reach steady state. The
+# bound sits between the intended cost (the output vector, 16 B/row; Julia
+# 1.10's inference adds ~32 B/row of leaf-load boxing) and the boxed
+# regression (~200 B/row).
+using Arrow
+const AC = Arrow.ArrowCore
+
+c1 = AC.fromjulia("a", collect(Int64, 1:100_000))
+c2 = AC.fromjulia("b", collect(Int64, 1:100_000))
+sf = AC.Field("st", AC.StructType(); nullable=false, children=[c1[1], c2[1]])
+sd = AC.ArrayData(
+    AC.StructType(),
+    100_000,
+    [AC.BufferSlice()];
+    children=[c1[2], c2[2]],
+    nullcount=0,
+)
+NT = NamedTuple{(:a, :b),Tuple{Int64,Int64}}
+for _ = 1:3
+    AC.materialize(NT, sf, sd)
+end
+bytes = @allocated AC.materialize(NT, sf, sd)
+bytes < 12_000_000 || error(
+    "typed struct materialization allocates " *
+    "$bytes bytes per 100k rows; the recursion edge is boxing again",
+)
+println("typed alloc ok: $bytes")
+
+# Every NO-CHILD leaf layout must ride the inline fast ladder, not the
+# compiled composite shell: an Interval child pins the non-juliatype-
+# uniform remainder.
+iv = AC.ArrayData(
+    AC.IntervalType(AC.YEAR_MONTH),
+    100_000,
+    [AC.BufferSlice(), AC._databuffer(collect(Int32, 1:100_000))],
+)
+ivf = AC.Field("iv", AC.IntervalType(AC.YEAR_MONTH); nullable=false)
+sf2 = AC.Field("st", AC.StructType(); nullable=false, children=[c1[1], ivf])
+sd2 = AC.ArrayData(
+    AC.StructType(),
+    100_000,
+    [AC.BufferSlice()];
+    children=[c1[2], iv],
+    nullcount=0,
+)
+NT2 = NamedTuple{(:a, :iv),Tuple{Int64,Int32}}
+for _ = 1:3
+    AC.materialize(NT2, sf2, sd2)
+end
+bytes2 = @allocated AC.materialize(NT2, sf2, sd2)
+bytes2 < 12_000_000 || error(
+    "typed interval-child materialization " *
+    "allocates $bytes2 bytes per 100k rows; a no-child leaf layout is " *
+    "routing through the compiled shell",
+)
+println("typed interval alloc ok: $bytes2")
diff --git a/test/writer_fault_child.jl b/test/writer_fault_child.jl
new file mode 100644
index 00000000..31077de2
--- /dev/null
+++ b/test/writer_fault_child.jl
@@ -0,0 +1,82 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Fresh process: a batch that fails to compress leaves the sink holding the
+# batches published before it, the same bytes for any `ntasks`, and the
+# writer refuses further batches. The failure is injected by replacing the
+# compression entry point (a copy of `_compressbytes` that fails on the
+# buffer starting with batch 2's first id), so this runs in its own process.
+using Arrow, Tables, Test
+using PooledArrays: PooledArray
+
+const SENTINEL = Int64(1_000_001)
+@eval Arrow function _compressbytes(
+    state::EncodeState,
+    codec::Int8,
+    ptr::Ptr{UInt8},
+    len::Int,
+)
+    len >= 8 &&
+        unsafe_load(Ptr{Int64}(ptr)) == $SENTINEL &&
+        error("injected compression failure")
+    out = isempty(state.free) ? UInt8[] : pop!(state.free)
+    need = len + (len >> 7) + 1024
+    length(out) < need && resize!(out, need)
+    frame =
+        codec == CODEC_LZ4_FRAME ?
+        _lz4frame(state, TS.Buffer(unsafe_wrap(Array, ptr, len)), out) :
+        _zstdframe(state, ptr, len, out)
+    push!(state.inuse, frame)
+    return frame
+end
+
+n = 3_000_000
+tbl = (
+    id=collect(Int64, 1:n),
+    c=PooledArray([string("cat", (i - 1) ÷ 1_000_000) for i = 1:n]),
+)
+sinks = Dict{Int,Vector{UInt8}}()
+for ntasks in (1, 4)
+    io = IOBuffer()
+    w = Arrow.Writer(io; file=false, compress=:zstd, ntasks=ntasks, batchsize=1_000_000)
+    @test_throws ErrorException Arrow.write(w, tbl)
+    if ntasks > 1
+        # Batch 3 was staged on batch 2's dictionary state and was discarded
+        # with it, so the writer takes no more batches.
+        err = @test_throws ArgumentError Arrow.write(w, (id=[1], c=PooledArray(["x"])))
+        @test occursin("failed to encode", err.value.msg)
+    end
+    close(w)
+    sinks[ntasks] = take!(io)
+    t = Arrow.Table(sinks[ntasks])
+    @test length(t.id) == 1_000_000 && t.id[end] == 1_000_000
+end
+@test sinks[1] == sinks[4]
+# A do-block writer to a path abandons its output, as a failed Arrow.write
+# does: the path keeps its old file.
+path = tempname()
+Arrow.write(path, (id=Int64[0],))
+before = read(path)
+@test_throws ErrorException Arrow.Writer(
+    path;
+    compress=:zstd,
+    ntasks=4,
+    batchsize=1_000_000,
+) do w
+    Arrow.write(w, tbl)
+end
+@test read(path) == before
+rm(path)
diff --git a/test/writer_sink_tests.jl b/test/writer_sink_tests.jl
new file mode 100644
index 00000000..ffad2699
--- /dev/null
+++ b/test/writer_sink_tests.jl
@@ -0,0 +1,416 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module WriterSinkTests
+
+using Test
+using Arrow
+using Tables
+using PooledArrays: PooledArray
+
+# Inject sink failures at the public path/IO boundary. The path wrapper lets
+# the writer own a controlled IO without depending on OS-specific failures.
+mutable struct FailingSink <: IO
+    data::IOBuffer
+    writeerror::Union{Nothing,Exception}
+    closeerror::Union{Nothing,Exception}
+    flusherror::Union{Nothing,Exception}
+    closes::Int
+end
+FailingSink() = FailingSink(IOBuffer(), nothing, nothing, nothing, 0)
+
+struct SinkPath <: AbstractString
+    io::FailingSink
+end
+Arrow._openpath(path::SinkPath) = Arrow._PathSink(path.io, "", nothing, false)
+Base.isopen(io::FailingSink) = isopen(io.data)
+function Base.write(io::FailingSink, bytes::Vector{UInt8})
+    io.writeerror === nothing || throw(io.writeerror)
+    return write(io.data, bytes)
+end
+function Base.close(io::FailingSink)
+    io.closes += 1
+    close(io.data)
+    io.closeerror === nothing || throw(io.closeerror)
+    return nothing
+end
+function Base.flush(io::FailingSink)
+    io.flusherror === nothing || throw(io.flusherror)
+    return flush(io.data)
+end
+
+function caught(f)
+    try
+        f()
+        return nothing
+    catch err
+        return err
+    end
+end
+
+@testset "writer sink validation and cleanup" begin
+    table = (; a=fill(Int64(7), 64))
+
+    @testset "invalid constructor options preserve the sink" begin
+        original = UInt8[0x00, 0xff, 0x41, 0x52, 0x52, 0x4f, 0x57]
+        constructors = (
+            (sink, options) -> Arrow.Writer(sink; options...),
+            (sink, options) -> open(Arrow.Writer, sink; options...),
+            (sink, options) -> Arrow.Writer(_ -> nothing, sink; options...),
+            (sink, options) -> open(_ -> nothing, Arrow.Writer, sink; options...),
+        )
+        invalid = (
+            ((; compress=:invalid), ArgumentError),
+            ((; dictreplacement=true, file=true), ArgumentError),
+            ((; file=:invalid), TypeError),
+            ((; compress=1), ArgumentError),
+            ((; dictreplacement=:invalid), TypeError),
+            ((; unknown=true), ArgumentError),
+        )
+        mktempdir() do dir
+            path = joinpath(dir, "existing.arrow")
+            missingpath = joinpath(dir, "missing.arrow")
+            for construct in constructors, (options, error) in invalid
+                write(path, original)
+                @test_throws error construct(path, options)
+                @test read(path) == original
+                @test_throws error construct(missingpath, options)
+                @test !ispath(missingpath)
+
+                io = IOBuffer(copy(original); read=true, write=true)
+                seek(io, 3)
+                @test_throws error construct(io, options)
+                @test isopen(io)
+                @test position(io) == 3
+                @test take!(io) == original
+                close(io)
+                # The old constructor creates this file before rejecting.
+                rm(missingpath; force=true)
+            end
+        end
+    end
+
+    @testset "valid constructors retain eager byte parity and ownership" begin
+        mktempdir() do dir
+            path = joinpath(dir, "valid.arrow")
+            for file in (true, false), compress in (nothing, :none, :lz4, :zstd)
+                expected = Arrow._writebytes(table; file=file, compress=compress)
+                write(path, "replace this longer existing destination"^100)
+                # nullable=false declares what one eager write declares.
+                w = Arrow.Writer(path; file=file, compress=compress, nullable=false)
+                @test Arrow.write(w, table) === w
+                @test close(w) === nothing
+                @test !isopen(w.io)
+                @test read(path) == expected
+
+                io = IOBuffer()
+                result =
+                    Arrow.Writer(io; file=file, compress=compress, nullable=false) do writer
+                        Arrow.write(writer, table)
+                        :done
+                    end
+                @test result === :done
+                @test isopen(io)
+                @test take!(io) == expected
+                close(io)
+            end
+            w = Arrow.Writer(path)
+            close(w)
+            @test !isopen(w.io)
+            # A writer that got no table writes a valid output with no columns.
+            none = Arrow.Table(path)
+            @test isempty(Tables.columnnames(none)) && Tables.rowcount(none) == 0
+        end
+    end
+
+    @testset "an IO gets the stream format and a path the file format" begin
+        stream = Arrow._writebytes(table; file=false)
+        io = IOBuffer()
+        Arrow.write(io, table)
+        @test take!(io) == stream
+        io = IOBuffer()
+        Arrow.Writer(w -> Arrow.write(w, table), io; nullable=false)
+        @test take!(io) == stream
+        io = IOBuffer()
+        Arrow.write(io, table; file=true)
+        @test take!(io) == Arrow._writebytes(table; file=true)
+        mktempdir() do dir
+            path = joinpath(dir, "default.arrow")
+            Arrow.write(path, table)
+            @test read(path) == Arrow._writebytes(table; file=true)
+        end
+        # A reader at the other end of a pipe gets each batch as it is
+        # written, before the writer closes.
+        pipe = Base.BufferStream()
+        w = Arrow.Writer(pipe)
+        Arrow.write(w, table)
+        reader = @async first(Arrow.Stream(pipe)).a
+        @test timedwait(() -> istaskdone(reader), 60) === :ok
+        # Closing first ends a reader that is still waiting, so a regression
+        # fails here instead of hanging the suite.
+        close(w)
+        close(pipe)
+        @test fetch(reader) == table.a
+    end
+
+    @testset "eager write and append reject options before changing bytes" begin
+        mktempdir() do dir
+            path = joinpath(dir, "existing.arrow")
+            original = Arrow._writebytes(table; file=false)
+            for operation in (Arrow.write, Arrow.append)
+                for (options, error) in (
+                    ((; compress=:invalid), ArgumentError),
+                    ((; compress=1), ArgumentError),
+                    ((; unknown=true), ArgumentError),
+                )
+                    write(path, original)
+                    @test_throws error operation(path, table; options...)
+                    @test read(path) == original
+                    io = IOBuffer(copy(original); read=true, write=true)
+                    @test_throws error operation(io, table; options...)
+                    @test isopen(io)
+                    @test take!(io) == original
+                    close(io)
+                end
+            end
+        end
+    end
+
+    @testset "finalization failures still release owned sinks and codecs" begin
+        for ownio in (true, false), file in (true, false), compress in (nothing, :zstd)
+            io = FailingSink()
+            w = Arrow.Writer(ownio ? SinkPath(io) : io; file=file, compress=compress)
+            Arrow.write(w, table)
+            failure = ErrorException("final output write failed")
+            io.writeerror = failure
+            io.closeerror = ErrorException("sink close also failed")
+            @test caught(() -> close(w)) === failure
+            @test !isopen(w)
+            @test w.st.finished
+            @test io.closes == Int(ownio)
+            @test isopen(io) == !ownio
+            @test all(s -> s.zstd == C_NULL, w.st.states)
+            @test close(w) === nothing
+            @test io.closes == Int(ownio)
+            io.closeerror = nothing
+            ownio || close(io)
+        end
+    end
+
+    @testset "a failed asynchronous batch releases its codecs" begin
+        io = FailingSink()
+        batch = Arrow.AC.batch(table)
+        st = Arrow.beginwrite!(io, batch.schema; file=false, compress=:zstd, ntasks=2)
+        Arrow.writebatch!(st, batch)
+        task, states, _ = only(st.pending)
+        wait(task)
+        @test any(s -> s.zstd != C_NULL, states)
+        failure = ErrorException("asynchronous output write failed")
+        io.writeerror = failure
+        @test caught(() -> Arrow.drainwrite!(st)) === failure
+        Arrow.abortwrite!(st)
+        @test all(s -> s.zstd == C_NULL, states)
+        @test isopen(io)
+        close(io)
+    end
+
+    @testset "function forms preserve the body error when close also fails" begin
+        for construct in
+            (Arrow.Writer, (f, sink; kw...) -> open(f, Arrow.Writer, sink; kw...))
+            for ownio in (true, false), file in (true, false)
+                io = FailingSink()
+                failure = ErrorException("body failed")
+                err = caught() do
+                    construct(ownio ? SinkPath(io) : io; file=file) do w
+                        Arrow.write(w, table)
+                        io.writeerror = ErrorException("final output write also failed")
+                        io.closeerror = ErrorException("sink close also failed")
+                        throw(failure)
+                    end
+                end
+                @test err === failure
+                @test io.closes == Int(ownio)
+                @test isopen(io) == !ownio
+                io.closeerror = nothing
+                ownio || close(io)
+            end
+        end
+    end
+
+    @testset "a body error ends an IO's accepted batches and abandons a path's" begin
+        mktempdir() do dir
+            path = joinpath(dir, "body-error.arrow")
+            for ownio in (true, false), file in (true, false)
+                io = IOBuffer()
+                failure = ErrorException("body failed after publishing a batch")
+                writer = Ref{Arrow.Writer}()
+                err = caught() do
+                    Arrow.Writer(ownio ? path : io; file=file, nullable=false) do w
+                        writer[] = w
+                        Arrow.write(w, table)
+                        throw(failure)
+                    end
+                end
+                @test err === failure
+                @test !isopen(writer[])
+                @test isopen(writer[].io) == !ownio
+                if ownio
+                    # As after a failed Arrow.write: no file, and no temporary one.
+                    @test isempty(readdir(dir))
+                else
+                    @test take!(io) == Arrow._writebytes(table; file=file)
+                end
+                close(io)
+            end
+        end
+    end
+
+    @testset "overwriting a memory-mapped file keeps the live handle valid" begin
+        mktempdir() do dir
+            path = joinpath(dir, "mapped.arrow")
+            parts = [(; a=collect(Int64, (1:100_000) .+ 100_000k)) for k = 0:3]
+            Arrow.write(path, Tables.partitioner(parts))
+            sums = [sum(p.a) for p in parts]
+            for overwrite in (
+                p -> Arrow.write(p, (; a=Int64[1])),
+                p -> Arrow.Writer(w -> Arrow.write(w, (; a=Int64[1])), p),
+            )
+                s = Arrow.Stream(path; mmap=true)  # maps the file; batches decode lazily
+                overwrite(path)
+                @test [sum(b.a) for b in s] == sums
+                @test Arrow.Table(path).a == [1]
+                Arrow.write(path, Tables.partitioner(parts))
+                @test readdir(dir) == ["mapped.arrow"]
+            end
+        end
+    end
+
+    @testset "replacing a file keeps its mode and symlinks; failures keep it" begin
+        mktempdir() do dir
+            target = joinpath(dir, "target.arrow")
+            link = joinpath(dir, "link.arrow")
+            Arrow.write(target, table)
+            original = read(target)
+            Sys.iswindows() || chmod(target, 0o640)
+            symlink(target, link)
+            Arrow.write(link, (; b=["x"]))
+            @test islink(link)
+            @test Arrow.Table(target).b == ["x"]
+            Sys.iswindows() || @test filemode(target) & 0o777 == 0o640
+            Arrow.write(target, table)
+            @test read(target) == original
+            # The second partition's columns do not match the first's.
+            unwritable = Tables.partitioner([(; a=Int64[1]), (; b=Int64[2])])
+            @test caught(() -> Arrow.write(target, unwritable)) isa Exception
+            @test read(target) == original
+            fresh = joinpath(dir, "fresh.arrow")
+            @test caught(() -> Arrow.write(fresh, unwritable)) isa Exception
+            @test !ispath(fresh)
+            @test sort(readdir(dir)) == ["link.arrow", "target.arrow"]
+        end
+    end
+
+    @testset "a read-only file refuses, as opening it for writing does" begin
+        mktempdir() do dir
+            target = joinpath(dir, "readonly.arrow")
+            Arrow.write(target, table)
+            original = read(target)
+            chmod(target, 0o444)
+            # Privileges that ignore file modes (root) open it for writing anyway.
+            ignored = caught(() -> close(open(target, "a"))) === nothing
+            if !ignored
+                err = caught(() -> Arrow.write(target, (; b=["x"])))
+                # The message names the file (Windows prints the path escaped).
+                @test err isa SystemError &&
+                      occursin("readonly.arrow", sprint(showerror, err))
+                @test caught(() -> Arrow.Writer(target)) isa SystemError
+                @test read(target) == original
+                @test readdir(dir) == ["readonly.arrow"]
+            end
+            chmod(target, 0o644)
+        end
+    end
+
+    @testset "columns of different lengths are refused" begin
+        for sink in (IOBuffer(), tempname()), tbl in ((a=[1], b=[1, 2]), (a=[1, 2], b=[1]))
+            err = @test_throws ArgumentError Arrow.write(sink, tbl)
+            @test occursin(
+                "every column of a table must have the same length",
+                err.value.msg,
+            )
+            @test occursin("column b has", err.value.msg)
+        end
+        Arrow.Writer(IOBuffer()) do w
+            Arrow.write(w, (a=[1],))
+            @test_throws ArgumentError Arrow.write(w, (a=[1, 2], b=[1]))
+        end
+    end
+
+    @testset "a one-table stream's dictionaries can grow past 128 categories" begin
+        path = tempname()
+        Arrow.write(path, (k=PooledArray(["c0"]),); file=false)
+        for i = 1:200
+            Arrow.append(path, (k=PooledArray(["c$i"]),))
+        end
+        @test Arrow.Table(path).k == ["c$i" for i = 0:200]
+        rm(path)
+        # The file format keeps the narrowest indices for a one-table write; a
+        # stream, which can be appended to, declares Int32 indices.
+        indexbits(bytes) =
+            getfield(Arrow.Table(bytes), :schema).fields[1].type.indextype.bits
+        @test indexbits(
+            take!(Arrow.write(IOBuffer(), (k=PooledArray(["x"]),); file=true)),
+        ) == 8
+        @test indexbits(take!(Arrow.tobuffer((k=PooledArray(["x"]),)))) == 32
+    end
+
+    @testset "a batch that fails to compress publishes nothing after it" begin
+        @test success(
+            `$(Base.julia_cmd()) --startup-file=no --project=$(Base.active_project()) $(joinpath(@__DIR__, "writer_fault_child.jl"))`,
+        )
+    end
+
+    @testset "a 2.x compressor object names the codec keyword" begin
+        err = @test_throws ArgumentError Arrow.write(
+            IOBuffer(),
+            (a=[1],);
+            compress=Arrow.LZ4FrameCompressor(),
+        )
+        @test occursin("takes the codec's name", err.value.msg)
+    end
+
+    @testset "cleanup errors propagate when the body succeeds" begin
+        for ownio in (true, false), written in (true, false)
+            io = FailingSink()
+            failure = ErrorException("sink cleanup failed")
+            io.closeerror = ownio ? failure : nothing
+            io.flusherror = ownio ? nothing : failure
+            err = caught() do
+                Arrow.Writer(ownio ? SinkPath(io) : io) do w
+                    written && Arrow.write(w, table)
+                    :done
+                end
+            end
+            @test err === failure
+            @test io.closes == Int(ownio)
+            @test isopen(io) == !ownio
+            io.closeerror = nothing
+            ownio || close(io)
+        end
+    end
+end
+
+end # module WriterSinkTests
diff --git a/tools/fbsgen.jl b/tools/fbsgen.jl
new file mode 100644
index 00000000..6176f909
--- /dev/null
+++ b/tools/fbsgen.jl
@@ -0,0 +1,931 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# =============================================================================
+# fbsgen.jl — generate the FlatBuffers metadata bindings and shape verifier
+# (src/metadata/{Schema,File,Message,Verifier}.jl) from the Arrow format's
+# .fbs files, over the vendored src/FlatBuffers runtime.
+#
+#     julia tools/fbsgen.jl <fbs-dir> <out-dir>
+#
+# Regeneration is mechanical: parse the schema, emit bindings, diff. Rerun
+# whenever the vendored src/metadata/fbs/*.fbs are updated, then run
+# JuliaFormatter over the output (the repository's format check covers the
+# generated files).
+#
+# Scope: the subset of the FlatBuffers IDL that Arrow's three schemas use —
+# `table`, `struct`, `enum` (with explicit values), `union`, scalar and
+# vector fields, table/string references, defaults, `(deprecated)`, and
+# `namespace`/`root_type` (ignored). Comments become nothing; the .fbs is the
+# documentation. Julia name collisions with Base/Core (`Int`, `Bool`, `Type`,
+# `Struct_`) are resolved so user code (`Meta.Int`, `Meta.Bool`,
+# `Meta.Struct`) works.
+# =============================================================================
+
+module FbsGen
+
+struct FbsField
+    name::String
+    type::String          # raw IDL type: "int", "[Buffer]", "string", "Type", ...
+    default::Union{Nothing,String}
+    deprecated::Bool
+end
+
+struct FbsTable
+    name::String
+    isstruct::Bool
+    fields::Vector{FbsField}
+end
+
+struct FbsEnum
+    name::String
+    basetype::String
+    members::Vector{Pair{String,Int}}
+    isunion::Bool
+end
+
+# --- tokenizer / parser ---------------------------------------------------------
+
+function _strip_comments(src::String)
+    out = IOBuffer()
+    i = 1
+    n = ncodeunits(src)
+    while i <= n
+        c = src[i]
+        if c == '/' && i < n && src[i + 1] == '/'
+            j = findnext('\n', src, i)
+            i = j === nothing ? n + 1 : j
+        elseif c == '/' && i < n && src[i + 1] == '*'
+            j = findnext("*/", src, i)
+            i = j === nothing ? n + 1 : last(j) + 1
+        else
+            print(out, c)
+            i = nextind(src, i)
+        end
+    end
+    return String(take!(out))
+end
+
+"""
+Parse one .fbs source into ordered declarations. Order is preserved: the
+emitted Julia must define types before their users, and .fbs authors already
+order dependencies for flatc.
+"""
+function parsefbs(src::String)
+    src = _strip_comments(src)
+    decls = Any[]
+    # Attributes/includes/namespace/root_type lines
+    src = replace(src, r"\binclude\s+\"[^\"]*\";" => "")
+    src = replace(src, r"\bnamespace\s+[\w.]+;" => "")
+    src = replace(src, r"\broot_type\s+\w+;" => "")
+    pos = 1
+    while true
+        m = match(r"\b(table|struct|enum|union)\s+(\w+)\s*(?::\s*(\w+))?\s*\{", src, pos)
+        m === nothing && break
+        kind, name, base = m.captures
+        bodystart = m.offset + ncodeunits(m.match)
+        depth = 1
+        i = bodystart
+        while depth > 0
+            i = nextind(src, i - 1) + 0
+            i > ncodeunits(src) && error("unterminated $kind $name")
+            c = src[i]
+            c == '{' && (depth += 1)
+            c == '}' && (depth -= 1)
+            i += 1
+        end
+        body = src[bodystart:(i - 2)]
+        pos = i
+        if kind == "table" || kind == "struct"
+            fields = FbsField[]
+            for stmt in split(body, ';')
+                s = strip(stmt)
+                isempty(s) && continue
+                s = replace(s, r"\[\s+" => "[", r"\s+\]" => "]")   # `[ int ]` -> `[int]`
+                fm = match(
+                    r"^(\w+)\s*:\s*(\[?[\w.]+\]?)\s*(?:=\s*([^\s(]+))?\s*(\([^)]*\))?$",
+                    s,
+                )
+                fm === nothing && error("cannot parse field '$s' in $name")
+                fname, ftype, fdefault, attrs = fm.captures
+                # Message.fbs qualifies cross-file types
+                # (`org.apache.arrow.flatbuf.MetadataVersion`); all three
+                # schemas share one Julia module, so keep the leaf name.
+                ftype = replace(ftype, r"[\w.]*\.(\w+)" => s"\1")
+                push!(
+                    fields,
+                    FbsField(
+                        fname,
+                        ftype,
+                        fdefault,
+                        attrs !== nothing && occursin("deprecated", attrs),
+                    ),
+                )
+            end
+            push!(decls, FbsTable(name, kind == "struct", fields))
+        else
+            members = Pair{String,Int}[]
+            # FlatBuffers unions reserve tag 0 for the implicit NONE member,
+            # so the first NAMED union member is 1; enums start at 0.
+            next = kind == "union" ? 1 : 0
+            for stmt in split(body, ',')
+                s = strip(stmt)
+                isempty(s) && continue
+                em = match(r"^(\w+)\s*(?:=\s*(-?\d+))?$", s)
+                em === nothing && error("cannot parse enum member '$s' in $name")
+                v = em.captures[2] === nothing ? next : parse(Int, em.captures[2])
+                push!(members, em.captures[1] => v)
+                next = v + 1
+            end
+            push!(
+                decls,
+                FbsEnum(
+                    name,
+                    something(base, kind == "union" ? "ubyte" : "int"),
+                    members,
+                    kind == "union",
+                ),
+            )
+        end
+    end
+    return decls
+end
+
+# --- type mapping -----------------------------------------------------------------
+
+const SCALARS = Dict(
+    "bool" => ("Base.Bool", 1),
+    "byte" => ("Int8", 1),
+    "ubyte" => ("UInt8", 1),
+    "short" => ("Int16", 2),
+    "ushort" => ("UInt16", 2),
+    "int" => ("Int32", 4),
+    "uint" => ("UInt32", 4),
+    "long" => ("Int64", 8),
+    "ulong" => ("UInt64", 8),
+    "float" => ("Float32", 4),
+    "double" => ("Float64", 8),
+    "int8" => ("Int8", 1),
+    "uint8" => ("UInt8", 1),
+    "int16" => ("Int16", 2),
+    "uint16" => ("UInt16", 2),
+    "int32" => ("Int32", 4),
+    "uint32" => ("UInt32", 4),
+    "int64" => ("Int64", 8),
+    "uint64" => ("UInt64", 8),
+    "float32" => ("Float32", 4),
+    "float64" => ("Float64", 8),
+)
+
+# Public name choices for Base/Core collisions.
+const RENAMES = Dict("Struct_" => "Struct")
+jlname(n::AbstractString) = get(RENAMES, String(n), String(n))
+
+isvector(t) = startswith(t, "[")
+elemtype(t) = t[2:(end - 1)]
+
+# --- emitter ---------------------------------------------------------------------
+
+lowerfirst(s) = isempty(s) ? s : lowercase(s[1:1]) * s[2:end]
+# Builder names normalize to lowerFirst(TableName) + CamelCase(field); the
+# adapters call exactly these names.
+camel(s) = join(uppercasefirst.(split(s, '_')))
+
+# Union fields occupy TWO vtable slots (type tag, then value); every emitter
+# must agree on the numbering.
+function slotmap(d::FbsTable, enums)
+    slots = String[]
+    slotof = Dict{String,Int}()
+    for f in d.fields
+        if haskey(enums, f.type) && enums[f.type].isunion
+            slotof[f.name * "_type"] = length(slots)
+            push!(slots, f.name * "_type")
+        end
+        slotof[f.name] = length(slots)
+        push!(slots, f.name)
+    end
+    return slots, slotof
+end
+
+"Fixed byte size of a struct (natural alignment, padded to max alignment)."
+function structsize(st::FbsTable)
+    off = 0
+    ma = 1
+    for f in st.fields
+        sz = SCALARS[f.type][2]
+        off = cld(off, sz) * sz + sz
+        ma = max(ma, sz)
+    end
+    return cld(off, ma) * ma
+end
+
+# Enum members as raw wire constants (two's complement at the base width),
+# for domain checks against byte-assembled loads.
+function enumdomain(e::FbsEnum)
+    width = SCALARS[e.basetype][2]
+    mask = width == 8 ? typemax(UInt64) : (UInt64(1) << (8 * width)) - UInt64(1)
+    return [reinterpret(UInt64, Int64(v)) & mask for (_, v) in e.members]
+end
+
+# Arrow-semantic required fields. The .fbs files declare no `(required)`
+# attributes, but the format is meaningless without these, and the readers'
+# downstream mapping assumes verification enforced them (a Field without a
+# type, a Message without a header). For union entries both the tag and the
+# value are required and the tag must be a named member.
+const REQUIRED = Dict(
+    "Message" => ("header",),
+    "Field" => ("type",),
+    "Schema" => ("fields",),
+    "DictionaryBatch" => ("data",),
+    "Footer" => ("schema",),
+    "KeyValue" => ("key", "value"),
+)
+isrequired(tname::String, fname::String) = fname in get(REQUIRED, tname, ())
+
+function emit(decls, io::IO; alldecls=decls)
+    # Name resolution spans every generated schema (Message.fbs references
+    # Schema.fbs tables; all three land in one module), so `alldecls`
+    # supplies the known-name set while `decls` drives emission order.
+    enums = Dict{String,FbsEnum}()
+    tables = Dict{String,FbsTable}()
+    for d in alldecls
+        d isa FbsEnum && (enums[d.name] = d)
+        d isa FbsTable && (tables[d.name] = d)
+    end
+    for d in decls
+        if d isa FbsEnum && !d.isunion
+            base = SCALARS[d.basetype][1]
+            print(io, "@enumx ", d.name, "::", base, " ")
+            println(io, join(("$(m.first)=$(m.second)" for m in d.members), " "))
+            println(io)
+        elseif d isa FbsEnum && d.isunion
+            # Tag -> type and type -> tag ladders for the union
+            # (`Type(b::UInt8)`/`Type(::Base.Type{T})`, `MessageHeader`).
+            # A bare `function X end` first creates a MODULE-LOCAL generic, so
+            # a union named `Type` shadows `Base.Type` instead of extending it.
+            println(io, "function ", d.name, " end")
+            println(io)
+            # Members whose tables come from schemas we do not generate
+            # (Tensor/SparseTensor live in Tensor.fbs) are emitted as comments
+            # so the ladder neither references undefined names nor silently
+            # drops the tag.
+            known(m) = haskey(tables, m) || haskey(enums, m)
+            println(io, "function ", d.name, "(b::UInt8)")
+            for (mname, v) in d.members
+                mname == "NONE" && continue
+                pre = known(mname) ? "    " : "    # "
+                println(io, pre, "b == ", v, " && return ", jlname(mname))
+            end
+            println(io, "    return nothing")
+            println(io, "end")
+            println(io)
+            println(io, "function ", d.name, "(::Base.Type{T})::Int16 where {T}")
+            for (mname, v) in d.members
+                mname == "NONE" && continue
+                pre = known(mname) ? "    " : "    # "
+                println(io, pre, "T == ", jlname(mname), " && return ", v)
+            end
+            println(io, "    return 0")
+            println(io, "end")
+            println(io)
+        elseif d isa FbsTable && d.isstruct
+            emitstruct(io, d)
+        elseif d isa FbsTable
+            emittable(io, d, enums, tables)
+        end
+    end
+end
+
+function emitstruct(io::IO, d::FbsTable)
+    name = jlname(d.name)
+    println(io, "struct ", name, " <: FlatBuffers.Struct")
+    println(io, "    bytes::Vector{UInt8}")
+    println(io, "    pos::Base.Int")
+    println(io, "end")
+    println(io)
+    # Layout: natural alignment of each scalar, total padded to max alignment.
+    off = 0
+    maxalign = 1
+    layout = Tuple{String,String,Int}[]
+    for f in d.fields
+        jt, sz = SCALARS[f.type]
+        off = cld(off, sz) * sz
+        push!(layout, (f.name, jt, off))
+        off += sz
+        maxalign = max(maxalign, sz)
+    end
+    total = cld(off, maxalign) * maxalign
+    println(io, "FlatBuffers.structsizeof(::Base.Type{", name, "}) = ", total)
+    println(io)
+    println(
+        io,
+        "Base.propertynames(x::",
+        name,
+        ") = (",
+        join((":" * f for (f, _, _) in layout), ", "),
+        length(layout) == 1 ? ",)" : ")",
+    )
+    println(io)
+    println(io, "function Base.getproperty(x::", name, ", field::Symbol)")
+    firstbranch = true
+    for (f, jt, o) in layout
+        println(io, "    ", firstbranch ? "if" : "elseif", " field === :", f)
+        println(
+            io,
+            "        return FlatBuffers.get(x, FlatBuffers.pos(x)",
+            o == 0 ? "" : " + $o",
+            ", ",
+            jt,
+            ")",
+        )
+        firstbranch = false
+    end
+    println(io, "    end")
+    println(io, "    return nothing")
+    println(io, "end")
+    println(io)
+    args = join(("$(f)::$(jt)" for (f, jt, _) in layout), ", ")
+    println(io, "function create", name, "(b::FlatBuffers.Builder, ", args, ")")
+    println(io, "    FlatBuffers.prep!(b, ", maxalign, ", ", total, ")")
+    # prepend in reverse, inserting pad where the layout has gaps
+    prevoff = total
+    for (f, jt, o) in reverse(layout)
+        sz = SCALARS[first(k for (k, v) in SCALARS if v[1] == jt)][2]
+        pad = prevoff - (o + sz)
+        pad > 0 && println(io, "    FlatBuffers.pad!(b, ", pad, ")")
+        println(io, "    prepend!(b, ", f, ")")
+        prevoff = o
+    end
+    println(io, "    return FlatBuffers.offset(b)")
+    println(io, "end")
+    println(io)
+end
+
+function emittable(io::IO, d::FbsTable, enums, tables)
+    name = jlname(d.name)
+    lname = lowerfirst(name)
+    println(io, "struct ", name, " <: FlatBuffers.Table")
+    println(io, "    bytes::Vector{UInt8}")
+    println(io, "    pos::Base.Int")
+    println(io, "end")
+    println(io)
+    slots, slotof = slotmap(d, enums)
+    props = [f.name for f in d.fields if !f.deprecated]
+    println(
+        io,
+        "Base.propertynames(x::",
+        name,
+        ") = (",
+        join((":" * p for p in props), ", "),
+        length(props) == 1 ? ",)" : ")",
+    )
+    println(io)
+    if !isempty(props)
+        println(io, "function Base.getproperty(x::", name, ", field::Symbol)")
+        firstbranch = true
+        for f in d.fields
+            f.deprecated && continue
+            vo = 4 + 2 * slotof[f.name]
+            println(io, "    ", firstbranch ? "if" : "elseif", " field === :", f.name)
+            firstbranch = false
+            t = f.type
+            if haskey(enums, t) && enums[t].isunion
+                # tag slot precedes value slot
+                tvo = 4 + 2 * slotof[f.name * "_type"]
+                println(io, "        o = FlatBuffers.offset(x, ", tvo, ")")
+                println(io, "        if o != 0")
+                println(
+                    io,
+                    "            T = ",
+                    t,
+                    "(FlatBuffers.get(x, o + FlatBuffers.pos(x), UInt8))",
+                )
+                println(io, "            o = FlatBuffers.offset(x, ", vo, ")")
+                println(io, "            pos = FlatBuffers.union(x, o)")
+                println(io, "            if o != 0")
+                println(
+                    io,
+                    "                return FlatBuffers.init(T, FlatBuffers.bytes(x), pos)",
+                )
+                println(io, "            end")
+                println(io, "        end")
+            elseif haskey(enums, t)
+                e = enums[t]
+                println(io, "        o = FlatBuffers.offset(x, ", vo, ")")
+                println(
+                    io,
+                    "        o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), ",
+                    t,
+                    ".T)",
+                )
+                # default: explicit or first member
+                dv = f.default === nothing ? e.members[1].first : f.default
+                println(io, "        return ", t, ".", dv)
+            elseif haskey(SCALARS, t)
+                jt = SCALARS[t][1]
+                println(io, "        o = FlatBuffers.offset(x, ", vo, ")")
+                println(
+                    io,
+                    "        o != 0 && return FlatBuffers.get(x, o + FlatBuffers.pos(x), ",
+                    jt,
+                    ")",
+                )
+                if f.default !== nothing
+                    dv = f.default
+                    println(io, "        return ", jt == "Base.Bool" ? dv : "$jt($dv)")
+                elseif jt == "Base.Bool"
+                    println(io, "        return false")
+                else
+                    println(io, "        return ", jt, "(0)")
+                end
+            elseif t == "string"
+                println(io, "        o = FlatBuffers.offset(x, ", vo, ")")
+                println(io, "        o != 0 && return String(x, o + FlatBuffers.pos(x))")
+            elseif isvector(t)
+                et = elemtype(t)
+                jt =
+                    haskey(SCALARS, et) ? SCALARS[et][1] :
+                    haskey(enums, et) ? et * ".T" : jlname(et)
+                println(io, "        o = FlatBuffers.offset(x, ", vo, ")")
+                println(io, "        if o != 0")
+                println(io, "            return FlatBuffers.Array{", jt, "}(x, o)")
+                println(io, "        end")
+            else # table reference
+                println(io, "        o = FlatBuffers.offset(x, ", vo, ")")
+                println(io, "        if o != 0")
+                println(
+                    io,
+                    "            y = FlatBuffers.indirect(x, o + FlatBuffers.pos(x))",
+                )
+                println(
+                    io,
+                    "            return FlatBuffers.init(",
+                    jlname(t),
+                    ", FlatBuffers.bytes(x), y)",
+                )
+                println(io, "        end")
+            end
+        end
+        println(io, "    end")
+        println(io, "    return nothing")
+        println(io, "end")
+        println(io)
+    end
+    # builders
+    println(
+        io,
+        lname,
+        "Start(b::FlatBuffers.Builder) = FlatBuffers.startobject!(b, ",
+        length(slots),
+        ")",
+    )
+    for f in d.fields
+        f.deprecated && continue
+        t = f.type
+        fc = camel(f.name)
+        slot = slotof[f.name]
+        if haskey(enums, t) && enums[t].isunion
+            tslot = slotof[f.name * "_type"]
+            println(
+                io,
+                lname,
+                "Add",
+                fc,
+                "Type(b::FlatBuffers.Builder, ::Core.Type{T}) where {T} =",
+            )
+            println(io, "    FlatBuffers.prependslot!(b, ", tslot, ", ", t, "(T), 0)")
+            println(
+                io,
+                lname,
+                "Add",
+                fc,
+                "(b::FlatBuffers.Builder, ",
+                f.name,
+                "::FlatBuffers.UOffsetT) =",
+            )
+            println(
+                io,
+                "    FlatBuffers.prependoffsetslot!(b, ",
+                slot,
+                ", ",
+                f.name,
+                ", 0)",
+            )
+        elseif haskey(enums, t)
+            e = enums[t]
+            # The runtime compares `x != T(default)`, so the default is the
+            # member's INTEGER value (constructible into the enum), never
+            # the enum instance itself.
+            dname = f.default === nothing ? e.members[1].first : f.default
+            dval = something(findfirst(m -> m.first == dname, e.members), 1)
+            println(
+                io,
+                lname,
+                "Add",
+                fc,
+                "(b::FlatBuffers.Builder, ",
+                f.name,
+                "::",
+                t,
+                ".T) =",
+            )
+            println(
+                io,
+                "    FlatBuffers.prependslot!(b, ",
+                slot,
+                ", ",
+                f.name,
+                ", ",
+                e.members[dval].second,
+                ")",
+            )
+        elseif haskey(SCALARS, t)
+            jt = SCALARS[t][1]
+            dv = f.default === nothing ? (jt == "Base.Bool" ? "false" : "0") : f.default
+            println(
+                io,
+                lname,
+                "Add",
+                fc,
+                "(b::FlatBuffers.Builder, ",
+                f.name,
+                "::",
+                jt,
+                ") =",
+            )
+            println(
+                io,
+                "    FlatBuffers.prependslot!(b, ",
+                slot,
+                ", ",
+                f.name,
+                ", ",
+                dv,
+                ")",
+            )
+        else # string / vector / table: offset slot
+            println(
+                io,
+                lname,
+                "Add",
+                fc,
+                "(b::FlatBuffers.Builder, ",
+                f.name,
+                "::FlatBuffers.UOffsetT) =",
+            )
+            println(
+                io,
+                "    FlatBuffers.prependoffsetslot!(b, ",
+                slot,
+                ", ",
+                f.name,
+                ", 0)",
+            )
+            if isvector(t)
+                et = elemtype(t)
+                esz, ealign = if haskey(SCALARS, et)
+                    (SCALARS[et][2], SCALARS[et][2])
+                elseif haskey(enums, et)
+                    (SCALARS[enums[et].basetype][2], SCALARS[enums[et].basetype][2])
+                elseif haskey(tables, et) && tables[et].isstruct
+                    st = tables[et]
+                    szs = [SCALARS[ff.type][2] for ff in st.fields]
+                    off = 0
+                    ma = 1
+                    for s in szs
+                        off = cld(off, s) * s + s
+                        ma = max(ma, s)
+                    end
+                    (cld(off, ma) * ma, ma)
+                else
+                    (4, 4)
+                end
+                println(
+                    io,
+                    lname,
+                    "Start",
+                    fc,
+                    "Vector(b::FlatBuffers.Builder, numelems) =",
+                )
+                println(
+                    io,
+                    "    FlatBuffers.startvector!(b, ",
+                    esz,
+                    ", numelems, ",
+                    ealign,
+                    ")",
+                )
+            end
+        end
+    end
+    println(io, lname, "End(b::FlatBuffers.Builder) = FlatBuffers.endobject!(b)")
+    println(io)
+end
+
+# --- verifier emitter -------------------------------------------------------------
+#
+# One shape-verification function per table, driven entirely by the parsed
+# schema: scalar widths and alignment, bool and enum domains (from the enum
+# declarations), string bounds/NUL/UTF-8, vector bounds with element sizes
+# (struct sizes computed from their layout), table recursion with depth and
+# object accounting, and COMPLETE union dispatch — the tag ladder is the
+# schema's member list, so it cannot stop short. Members whose tables live
+# outside the generated schemas
+# (Tensor family) fail closed by name.
+
+function emitverifier(io::IO, alldecls)
+    enums = Dict{String,FbsEnum}()
+    tables = Dict{String,FbsTable}()
+    for d in alldecls
+        d isa FbsEnum && (enums[d.name] = d)
+        d isa FbsTable && (tables[d.name] = d)
+    end
+    domain(e::FbsEnum) =
+        "(" * join(("0x" * string(v, base=16, pad=16) for v in enumdomain(e)), ", ") * ",)"
+    for d in alldecls
+        (d isa FbsTable && !d.isstruct) || continue
+        name = jlname(d.name)
+        _, slotof = slotmap(d, enums)
+        # Two stages per table: INLINE (table shell, accounting, and every
+        # non-reference field) and REFS (everything that traverses away from
+        # the table). Adapters gate policy fields — the metadata version —
+        # between the ROOT's stages, so rejected input fails in constant
+        # time instead of after a full attacker-directed graph walk.
+        inline = IOBuffer()
+        refs = IOBuffer()
+        for f in d.fields
+            f.deprecated && continue
+            slot = slotof[f.name]
+            req = isrequired(d.name, f.name)
+            reqkw = req ? "; required=true" : ""
+            t = f.type
+            label = "$(d.name).$(f.name)"
+            if haskey(enums, t) && enums[t].isunion
+                e = enums[t]
+                tslot = slotof[f.name * "_type"]
+                println(refs, "    tagp = _vfield(t, ", tslot, ", 1", reqkw, ")")
+                println(refs, "    tag = tagp === nothing ? 0x00 : _vu8(bytes, tagp)")
+                req && println(
+                    refs,
+                    "    tag != 0x00 || _vfail(\"",
+                    label,
+                    " union tag is required\")",
+                )
+                println(refs, "    valp = _vref(t, ", slot, reqkw, ")")
+                println(refs, "    if tag == 0x00")
+                println(refs, "        valp === nothing ||")
+                println(
+                    refs,
+                    "            _vfail(\"",
+                    label,
+                    " union has a value but no tag\")",
+                )
+                firstmember = true
+                for (mname, v) in e.members
+                    mname == "NONE" && continue
+                    println(refs, "    elseif tag == 0x", string(v, base=16, pad=2))
+                    if haskey(tables, mname) && !tables[mname].isstruct
+                        println(refs, "        valp === nothing &&")
+                        println(
+                            refs,
+                            "            _vfail(\"",
+                            label,
+                            " union has a tag but no value\")",
+                        )
+                        println(
+                            refs,
+                            "        verify_",
+                            jlname(mname),
+                            "(bytes, valp, ctx, depth + 1)",
+                        )
+                    else
+                        println(
+                            refs,
+                            "        _vfail(\"",
+                            label,
+                            " union member ",
+                            mname,
+                            " is outside the generated schemas\")",
+                        )
+                    end
+                    firstmember = false
+                end
+                println(refs, "    else")
+                println(refs, "        _vfail(\"", label, " union has unknown tag\")")
+                println(refs, "    end")
+            elseif haskey(enums, t)
+                e = enums[t]
+                println(
+                    inline,
+                    "    _venum(t, ",
+                    slot,
+                    ", ",
+                    SCALARS[e.basetype][2],
+                    ", ",
+                    domain(e),
+                    ")",
+                )
+            elseif t == "bool"
+                println(inline, "    _vbool(t, ", slot, ")")
+            elseif haskey(SCALARS, t)
+                println(inline, "    _vfield(t, ", slot, ", ", SCALARS[t][2], reqkw, ")")
+            elseif t == "string"
+                # Arrow custom metadata is opaque binary data despite its
+                # FlatBuffers string representation. Keep framing checks.
+                strkw =
+                    d.name == "KeyValue" ?
+                    (req ? "; required=true, utf8=false" : "; utf8=false") : reqkw
+                println(refs, "    _vstring(t, ", slot, ", ctx", strkw, ")")
+            elseif isvector(t)
+                et = elemtype(t)
+                if haskey(enums, et) && !enums[et].isunion
+                    e = enums[et]
+                    println(
+                        refs,
+                        "    _venumvector(t, ",
+                        slot,
+                        ", ",
+                        SCALARS[e.basetype][2],
+                        ", ",
+                        domain(e),
+                        ", ctx, \"",
+                        label,
+                        "\"",
+                        reqkw,
+                        ")",
+                    )
+                elseif haskey(SCALARS, et)
+                    println(
+                        refs,
+                        "    _vvector(t, ",
+                        slot,
+                        ", ",
+                        SCALARS[et][2],
+                        ", ctx",
+                        reqkw,
+                        ")",
+                    )
+                elseif haskey(tables, et) && tables[et].isstruct
+                    println(
+                        refs,
+                        "    _vvector(t, ",
+                        slot,
+                        ", ",
+                        structsize(tables[et]),
+                        ", ctx",
+                        reqkw,
+                        ")",
+                    )
+                elseif haskey(tables, et)
+                    println(
+                        refs,
+                        "    _vtablevector(t, ",
+                        slot,
+                        ", verify_",
+                        jlname(et),
+                        ", ctx, depth",
+                        reqkw,
+                        ")",
+                    )
+                else
+                    error(
+                        "verifier: unsupported vector element '$et' in $(d.name).$(f.name)",
+                    )
+                end
+            elseif haskey(tables, t) && tables[t].isstruct
+                println(
+                    inline,
+                    "    _vfield(t, ",
+                    slot,
+                    ", ",
+                    structsize(tables[t]),
+                    reqkw,
+                    ")",
+                )
+            elseif haskey(tables, t)
+                println(refs, "    p = _vref(t, ", slot, reqkw, ")")
+                println(
+                    refs,
+                    "    p === nothing || verify_",
+                    jlname(t),
+                    "(bytes, p, ctx, depth + 1)",
+                )
+            else
+                error("verifier: unsupported field type '$t' in $(d.name).$(f.name)")
+            end
+        end
+        # Only the two message roots (Message, Footer) need the staged form,
+        # so a caller can gate the metadata version between the stages.
+        if name in ("Message", "Footer")
+            println(
+                io,
+                "function verifyrootstart_",
+                name,
+                "(bytes::Vector{UInt8}, ctx::VerifyContext)",
+            )
+            println(io, "    length(bytes) >= 4 || _vfail(\"missing root offset\")")
+            println(io, "    root = Int64(_vu32(bytes, Int64(0)))")
+            println(io, "    root >= 4 || _vfail(\"invalid root offset\")")
+            println(io, "    t = _vtable(bytes, root)")
+            println(io, "    _vvisit!(ctx, \"", name, "\")")
+            print(io, String(take!(inline)))
+            println(io, "    return t")
+            println(io, "end")
+            println(io)
+            println(io, "function verifyrootrest_", name, "(t::VTable, ctx::VerifyContext)")
+            println(io, "    bytes = t.bytes")
+            println(io, "    depth = 0")
+            print(io, String(take!(refs)))
+            println(io, "    return nothing")
+            println(io, "end")
+        else
+            println(
+                io,
+                "function verify_",
+                name,
+                "(bytes::Vector{UInt8}, pos::Int64, ctx::VerifyContext, depth::Base.Int)",
+            )
+            println(io, "    t = _vtable(bytes, pos)")
+            println(io, "    _vvisit!(ctx, \"", name, "\")")
+            println(io, "    depth <= ctx.maxdepth || _vlimit(:depth, ctx.maxdepth)")
+            print(io, String(take!(inline)))
+            print(io, String(take!(refs)))
+            println(io, "    return nothing")
+            println(io, "end")
+        end
+        println(io)
+    end
+end
+
+const HEADER = """
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# GENERATED by tools/fbsgen.jl from apache/arrow format/{name}.fbs —
+# do not edit by hand; rerun the generator against the current spec.
+
+"""
+
+# The verifier banner extends HEADER with the shape of the emitted functions.
+const VERIFIER_HEADER = """
+# Four functions per table: verifyinline_T proves the table shell and every
+# non-reference field; verifyrefs_T walks the reference graph; verify_T does
+# both; verifyrootstart_T/verifyrootrest_T split the root so a caller can gate
+# the metadata version between the two stages.
+
+"""
+
+function generate(fbsdir::AbstractString, outdir::AbstractString)
+    mkpath(outdir)
+    names = ("Schema", "File", "Message")
+    parsed = Dict(n => parsefbs(read(joinpath(fbsdir, n * ".fbs"), String)) for n in names)
+    alldecls = reduce(vcat, (parsed[n] for n in names))
+    for name in names
+        decls = parsed[name]
+        io = IOBuffer()
+        print(io, replace(HEADER, "{name}" => name))
+        emit(decls, io; alldecls=alldecls)
+        write(joinpath(outdir, name * ".jl"), take!(io))
+        println("generated ", name, ".jl: ", length(decls), " declarations")
+    end
+    vio = IOBuffer()
+    print(vio, replace(HEADER, "{name}" => "{Schema,File,Message}"))
+    print(vio, VERIFIER_HEADER)
+    emitverifier(vio, alldecls)
+    write(joinpath(outdir, "Verifier.jl"), take!(vio))
+    println("generated Verifier.jl")
+    return nothing
+end
+
+end # module FbsGen
+
+if abspath(PROGRAM_FILE) == abspath(@__FILE__)
+    length(ARGS) == 2 || error("usage: julia fbsgen.jl <fbs-dir> <out-dir>")
+    FbsGen.generate(ARGS[1], ARGS[2])
+end