diff --git a/.gitattributes b/.gitattributes
index 57eb8a8807..f507ce96ca 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,3 +1,9 @@
 *.py linguist-language=python
 *.ipynb linguist-documentation
 .git_archival.txt export-subst
+
+# just refuses to format a CRLF file, so `just just-check` would fail on a Windows
+# checkout with core.autocrlf=true before the contributor has changed anything.
+Justfile text eol=lf
+*/justfile text eol=lf
+packages/*/justfile text eol=lf
diff --git a/.github/labeler.yml b/.github/labeler.yml
index 7eb74211ea..482207d6cb 100644
--- a/.github/labeler.yml
+++ b/.github/labeler.yml
@@ -2,3 +2,21 @@ needs release notes:
   - all:
     - changed-files:
       - all-globs-to-all-files: '!changes/*.md'
+
+# Subpackage labels: a pull request whose changes all live under one package
+# directory gets that package's label, which .github/release.yml uses to keep
+# subpackage work out of the generated `zarr` release notes.
+zarr-metadata:
+  - all:
+    - changed-files:
+      - all-globs-to-all-files: 'packages/zarr-metadata/**'
+
+zarr-indexing:
+  - all:
+    - changed-files:
+      - all-globs-to-all-files: 'packages/zarr-indexing/**'
+
+zarr-http-server:
+  - all:
+    - changed-files:
+      - all-globs-to-all-files: 'packages/zarr-http-server/**'
diff --git a/.github/release.yml b/.github/release.yml
new file mode 100644
index 0000000000..a66182c50a
--- /dev/null
+++ b/.github/release.yml
@@ -0,0 +1,22 @@
+# Configuration for GitHub's "Generate release notes" button.
+#
+# The zarr-python repository also hosts the companion packages under packages/
+# (zarr-metadata, zarr-indexing, zarr-http-server), which have their own release
+# cadence, tags and changelogs. Pull requests that only touch a subpackage are
+# labelled by the labeler workflow (.github/labeler.yml) and excluded here, so a
+# `zarr` release lists only the changes that ship in `zarr`.
+changelog:
+  exclude:
+    labels:
+      - zarr-metadata
+      - zarr-indexing
+      - zarr-http-server
+    authors:
+      - pre-commit-ci[bot]
+  categories:
+    - title: Dependency updates
+      labels:
+        - dependencies
+    - title: What's Changed
+      labels:
+        - "*"
diff --git a/.github/workflows/check_changelogs.yml b/.github/workflows/check_changelogs.yml
index f642eb17ca..960451cc4c 100644
--- a/.github/workflows/check_changelogs.yml
+++ b/.github/workflows/check_changelogs.yml
@@ -22,16 +22,22 @@ jobs:
           persist-credentials: false
 
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+
+      - name: Install just
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
 
       - name: Check zarr-python changelog entries
-        run: uv run --no-sync python ci/check_changelog_entries.py
+        run: just check-changelogs
 
       - name: Check zarr-metadata changelog entries
-        run: uv run --no-sync python ci/check_changelog_entries.py packages/zarr-metadata/changes
+        run: just check-changelogs packages/zarr-metadata/changes
 
       - name: Check zarr-indexing changelog entries
-        run: uv run --no-sync python ci/check_changelog_entries.py packages/zarr-indexing/changes
+        run: just check-changelogs packages/zarr-indexing/changes
 
       - name: Check zarr-http-server changelog entries
-        run: uv run --no-sync python ci/check_changelog_entries.py packages/zarr-http-server/changes
+        run: just check-changelogs packages/zarr-http-server/changes
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 1441950c3f..a58ce40a9d 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -31,10 +31,19 @@ jobs:
       uses: pypa/hatch@f647ed70d49adb885f53a27d1c7f5bdaeacf2c60
       with:
         version: '1.16.5'
+    # No interpreter is set up in this job on purpose. Benchmarks are only comparable
+    # across runs if the interpreter underneath them does not move: adding a pinned
+    # Python here measured a uniform ~13% slowdown on every benchmark, because hatch
+    # then built the environment on that interpreter instead of the runner's own.
+    - name: Install just
+      uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+      with:
+        repo: casey/just
+        version: 1.58.0
     - name: Run the benchmarks
       uses: CodSpeedHQ/action@373d6868929f444bc08d901fd0eb0ad52a8875ea # v5.2.1
       env:
         ZARR_BENCHMARK_CLEAR_CACHE: '1'
       with:
           mode: walltime
-          run: hatch run test.py3.12-minimal:pytest tests/benchmarks --codspeed
+          run: HATCH_ENV=test.py3.12-minimal just benchmark-codspeed
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 0f9c711a60..990866a109 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -22,19 +22,23 @@ jobs:
       - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
         with:
           persist-credentials: false
-      - uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
-      - run: uv sync --group docs
+      - uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
+      - name: Install just
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       # Fast source-level guards that need no built site, so they run before the (slower)
       # build for a quick failure: every public export is in the API reference, and no
       # docstring/Markdown carries reStructuredText markup that MkDocs won't render.
-      - run: uv run python ci/check_documented_exports.py docs/api
-      - run: uv run python ci/lint_docs.py
+      - run: just check-doc-exports
+      - run: just lint-docs
       # --strict turns warnings into errors, so a docs code block that fails to execute
       # at build time (e.g. a non-exec python fence disrupting a later exec="true" block)
       # fails CI instead of merging as a silent warning.
-      - run: uv run mkdocs build --strict
+      - run: just docs-build
         env:
           DISABLE_MKDOCS_2_WARNING: "true"
           NO_MKDOCS_2_WARNING: "true"
-      - run: uv run python ci/check_unlinked_types.py
+      - run: just check-doc-links
         continue-on-error: true
diff --git a/.github/workflows/downstream.yml b/.github/workflows/downstream.yml
index 30210cd452..76cfaa0aa8 100644
--- a/.github/workflows/downstream.yml
+++ b/.github/workflows/downstream.yml
@@ -45,7 +45,7 @@ jobs:
           python-version: '3.13'
 
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
 
       - name: Install xarray and test dependencies
         working-directory: xarray
@@ -59,10 +59,11 @@ jobs:
         working-directory: xarray
         run: uv pip install --no-deps ..
 
+      # Keep the branch override: syncing xarray would reinstall zarr from PyPI.
       - name: Show versions
         working-directory: xarray
         run: |
-          uv run python -c "
+          uv run --no-sync python -c "
           import zarr; print(f'zarr {zarr.__version__}')
           import xarray; print(f'xarray {xarray.__version__}')
           "
@@ -70,7 +71,7 @@ jobs:
       - name: Run xarray zarr backend tests
         working-directory: xarray
         run: |
-          uv run python -m pytest --no-header -q \
+          uv run --no-sync python -m pytest --no-header -q \
             xarray/tests/test_backends.py \
             xarray/tests/test_backends_api.py \
             xarray/tests/test_backends_datatree.py
@@ -102,7 +103,7 @@ jobs:
           python-version: '3.13'
 
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
 
       - name: Install numcodecs with test-zarr-main group
         working-directory: numcodecs
diff --git a/.github/workflows/gpu_test.yml b/.github/workflows/gpu_test.yml
index c902bfdaa8..a8e989f580 100644
--- a/.github/workflows/gpu_test.yml
+++ b/.github/workflows/gpu_test.yml
@@ -62,22 +62,29 @@ jobs:
         python-version: ${{ matrix.python-version }}
         cache: 'pip'
     - name: Install uv
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
     - name: Install Hatch
       uses: pypa/hatch@f647ed70d49adb885f53a27d1c7f5bdaeacf2c60
       with:
         version: '1.16.5'
+    - name: Install just
+      uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+      with:
+        repo: casey/just
+        version: 1.58.0
+    # Two names for the same environment on purpose: `just setup` builds whatever
+    # HATCH_ENV points at, while `just gpu` reads GPU_HATCH_ENV so that an
+    # ambient HATCH_ENV can never redirect `pytest -m gpu` into a CPU environment.
     - name: Set Up Hatch Env
       env:
         HATCH_ENV: gputest.py${{ matrix.python-version }}
       run: |
-        hatch env create "$HATCH_ENV"
-        hatch env run -e "$HATCH_ENV" list-env
+        just setup
     - name: Run Tests
       env:
-        HATCH_ENV: gputest.py${{ matrix.python-version }}
+        GPU_HATCH_ENV: gputest.py${{ matrix.python-version }}
       run: |
-        hatch env run --env "$HATCH_ENV" run-coverage
+        just gpu
 
     - name: Upload coverage
       uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f  # v7.0.0
diff --git a/.github/workflows/hypothesis.yaml b/.github/workflows/hypothesis.yaml
index 352888f749..3be6f3ba60 100644
--- a/.github/workflows/hypothesis.yaml
+++ b/.github/workflows/hypothesis.yaml
@@ -60,17 +60,21 @@ jobs:
         python-version: ${{ matrix.python-version }}
         cache: 'pip'
     - name: Install uv
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
     - name: Install Hatch
       uses: pypa/hatch@f647ed70d49adb885f53a27d1c7f5bdaeacf2c60
       with:
         version: '1.16.5'
+    - name: Install just
+      uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+      with:
+        repo: casey/just
+        version: 1.58.0
     - name: Set Up Hatch Env
       env:
         HATCH_ENV: test.py${{ matrix.python-version }}-${{ matrix.dependency-set }}
       run: |
-        hatch env create "$HATCH_ENV"
-        hatch env run -e "$HATCH_ENV" list-env
+        just setup
     # https://github.com/actions/cache/blob/main/tips-and-workarounds.md#update-a-cache
     - name: Restore cached hypothesis directory
       id: restore-hypothesis-cache
@@ -89,7 +93,7 @@ jobs:
         PYTEST_ADDOPTS: "--report-log=output-${{ matrix.python-version }}-log.jsonl"
       run: |
         echo "Using Hypothesis profile: $HYPOTHESIS_PROFILE"
-        hatch env run --env "$HATCH_ENV" run-hypothesis
+        just hypothesis
 
     # explicitly save the cache so it gets updated, also do this even if it fails.
     - name: Save cached hypothesis directory
diff --git a/.github/workflows/issue-metrics.yml b/.github/workflows/issue-metrics.yml
index 7b4cd08a0b..507451e04a 100644
--- a/.github/workflows/issue-metrics.yml
+++ b/.github/workflows/issue-metrics.yml
@@ -33,7 +33,7 @@ jobs:
         echo "last_month=$first_day..$last_day" >> "$GITHUB_ENV"
 
     - name: Run issue-metrics tool
-      uses: github-community-projects/issue-metrics@61084fa9599a62c7821f06602e180a42d1c7a205 # v5.0.1
+      uses: github-community-projects/issue-metrics@a7dc2fb675661e208d4fc6fa321a6b95fc4a06f9 # v5.0.2
       env:
         GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         SEARCH_QUERY: 'repo:zarr-developers/zarr-python is:issue created:${{ env.last_month }} -reason:"not planned"'
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index 24521aadc5..f47fbcac11 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -27,7 +27,29 @@ jobs:
         with:
           python-version: "3.12"
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
-      - uses: j178/prek-action@4e14d07f9231acabce116ccfca13b13dd9755ece # v3.0.0
+      - name: Install just
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
+      # `uvx prek` builds each hook's environment from scratch, so cache them the
+      # way the prek action used to. Keyed on the hook config: a new pinned rev or
+      # a new hook is exactly when the cached environments stop being valid.
+      - name: Cache prek hook environments
+        uses: actions/cache@55cc8345863c7cc4c66a329aec7e433d2d1c52a9 # v6.1.0
+        with:
+          path: ~/.cache/prek
+          # Justfile is hashed too: prek_version lives there, and a bumped prek
+          # must not restore a store built by the previous one. No restore-keys
+          # fallback for the same reason.
+          key: prek-${{ runner.os }}-${{ hashFiles('.pre-commit-config.yaml', 'Justfile') }}
+      - name: Lint
+        run: just lint
+      - name: Check justfile formatting
+        # After the linters, and never masking them: this is cosmetic, and a
+        # mis-formatted recipe should not cost someone their ruff/mypy results.
+        if: always()
+        run: just just-check
diff --git a/.github/workflows/nightly_wheels.yml b/.github/workflows/nightly_wheels.yml
index 2cb913511e..3d7fc60bb4 100644
--- a/.github/workflows/nightly_wheels.yml
+++ b/.github/workflows/nightly_wheels.yml
@@ -42,7 +42,7 @@ jobs:
         run: hatch build
 
       - name: Upload nightly wheels
-        uses: scientific-python/upload-nightly-action@e76cfec8a4611fd02808a801b0ff5a7d7c1b2d99
+        uses: scientific-python/upload-nightly-action@16fa02eacee1655195143de09f03676e60ef2bf5
         with:
           artifacts_path: dist
           anaconda_nightly_upload_token: ${{ secrets.ANACONDA_ORG_UPLOAD_TOKEN }}
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index 650932309c..0d7d396fff 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -66,21 +66,25 @@ jobs:
         python-version: ${{ matrix.python-version }}
         cache: 'pip'
     - name: Install uv
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
     - name: Install Hatch
       run: python -m pip install hatch==1.16.5
+    - name: Install just
+      uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+      with:
+        repo: casey/just
+        version: 1.58.0
     - name: Set Up Hatch Env
       env:
         HATCH_ENV: test.py${{ matrix.python-version }}-${{ matrix.dependency-set }}
       run: |
-        hatch env create "$HATCH_ENV"
-        hatch env run -e "$HATCH_ENV" list-env
+        just setup
     - name: Run Tests
       env:
         HYPOTHESIS_PROFILE: ci
         HATCH_ENV: test.py${{ matrix.python-version }}-${{ matrix.dependency-set }}
       run: |
-        hatch env run --env "$HATCH_ENV" run-coverage
+        just coverage
     - name: Upload coverage
       if: ${{ matrix.dependency-set == 'optional' && matrix.os == 'ubuntu-latest' }}
       uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
@@ -115,20 +119,24 @@ jobs:
         python-version: ${{ matrix.python-version }}
         cache: 'pip'
     - name: Install uv
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
     - name: Install Hatch
       run: python -m pip install hatch==1.16.5
+    - name: Install just
+      uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+      with:
+        repo: casey/just
+        version: 1.58.0
     - name: Set Up Hatch Env
       env:
         HATCH_ENV: ${{ matrix.dependency-set }}
       run: |
-        hatch env create "$HATCH_ENV"
-        hatch env run -e "$HATCH_ENV" list-env
+        just setup
     - name: Run Tests
       env:
         HATCH_ENV: ${{ matrix.dependency-set }}
       run: |
-        hatch env run --env "$HATCH_ENV" run-coverage
+        just coverage
     - name: Upload coverage
       uses: codecov/codecov-action@fb8b3582c8e4def4969c97caa2f19720cb33a72f # v7.0.0
       with:
@@ -150,15 +158,20 @@ jobs:
         python-version: '3.13'
         cache: 'pip'
     - name: Install uv
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
     - name: Install Hatch
       run: python -m pip install hatch==1.16.5
+    - name: Install just
+      uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+      with:
+        repo: casey/just
+        version: 1.58.0
     - name: Set Up Hatch Env
       run: |
-        hatch run doctest:pip list
+        HATCH_ENV=doctest just setup
     - name: Run Tests
       run: |
-        hatch run doctest:test
+        just doctest
 
   benchmarks:
     name: Benchmark smoke test
@@ -174,14 +187,19 @@ jobs:
         python-version: '3.13'
         cache: 'pip'
     - name: Install uv
-      uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+      uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
     - name: Install Hatch
       run: python -m pip install hatch==1.16.5
+    - name: Install just
+      uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+      with:
+        repo: casey/just
+        version: 1.58.0
     - name: Run Benchmarks
       env:
         ZARR_BENCHMARK_CLEAR_CACHE: '1'
       run: |
-        hatch env run --env "test.py3.13-minimal" run-benchmark
+        HATCH_ENV=test.py3.13-minimal just benchmark
 
   test-complete:
     name: Test complete
diff --git a/.github/workflows/zarr-http-server-release.yml b/.github/workflows/zarr-http-server-release.yml
index fb5e0fc21f..703cb7fd26 100644
--- a/.github/workflows/zarr-http-server-release.yml
+++ b/.github/workflows/zarr-http-server-release.yml
@@ -51,7 +51,7 @@ jobs:
           path: dist
 
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: false
 
diff --git a/.github/workflows/zarr-http-server.yml b/.github/workflows/zarr-http-server.yml
index a30d990a33..4a8fcca101 100644
--- a/.github/workflows/zarr-http-server.yml
+++ b/.github/workflows/zarr-http-server.yml
@@ -47,13 +47,16 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Sync test dependency groups
         # The examples group carries the deps the README examples need, so the
         # test that reads a served array back with a zarr client runs here
@@ -74,9 +77,12 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Run ruff
         run: just lint
 
@@ -92,13 +98,16 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Set up Python
         run: uv python install 3.12
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Sync test dependency group
         run: uv sync --group test --python 3.12
       - name: Run mypy
@@ -116,11 +125,14 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Build docs
         run: just docs-check
 
diff --git a/.github/workflows/zarr-indexing-release.yml b/.github/workflows/zarr-indexing-release.yml
index 5d95eb1996..2ae363294d 100644
--- a/.github/workflows/zarr-indexing-release.yml
+++ b/.github/workflows/zarr-indexing-release.yml
@@ -51,7 +51,7 @@ jobs:
           path: dist
 
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: false
 
diff --git a/.github/workflows/zarr-indexing.yml b/.github/workflows/zarr-indexing.yml
index 3b106e16aa..9af8ed1e3d 100644
--- a/.github/workflows/zarr-indexing.yml
+++ b/.github/workflows/zarr-indexing.yml
@@ -36,11 +36,14 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
       # The suite imports nothing from `zarr`; it runs against the repo-root
@@ -67,9 +70,12 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Run ruff
         # The ruff version pin lives in packages/zarr-indexing/justfile.
         run: just lint
@@ -86,7 +92,7 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Set up Python
@@ -94,7 +100,10 @@ jobs:
       - name: Sync test dependency group
         run: uv sync --group test --python 3.12
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Run pyright
         # The pyright invocation lives in packages/zarr-indexing/justfile.
         run: just typecheck
@@ -111,11 +120,14 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Build docs
         # The strict mkdocs build lives in packages/zarr-indexing/justfile.
         run: just docs-check
diff --git a/.github/workflows/zarr-metadata-release.yml b/.github/workflows/zarr-metadata-release.yml
index 3125d2529a..d3409a1176 100644
--- a/.github/workflows/zarr-metadata-release.yml
+++ b/.github/workflows/zarr-metadata-release.yml
@@ -51,7 +51,7 @@ jobs:
           path: dist
 
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: false
 
diff --git a/.github/workflows/zarr-metadata.yml b/.github/workflows/zarr-metadata.yml
index 069f6d5060..3c42f4810f 100644
--- a/.github/workflows/zarr-metadata.yml
+++ b/.github/workflows/zarr-metadata.yml
@@ -39,11 +39,14 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}
       - name: Sync test dependency group
@@ -63,9 +66,12 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Run ruff
         run: just lint
 
@@ -81,11 +87,14 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Run pyright
         # The pyright version and interpreter pins live in the justfile.
         run: just typecheck
@@ -102,11 +111,14 @@ jobs:
         with:
           persist-credentials: false
       - name: Install uv
-        uses: astral-sh/setup-uv@20cfd1bf945f4377ade1205e4dbc17946fc9a30d # v10.0.1
+        uses: astral-sh/setup-uv@bec219d24cd3e171d82865faccec33120bb574f4 # v10.1.0
         with:
           enable-cache: true
       - name: Install just
-        uses: extractions/setup-just@53165ef7e734c5c07cb06b3c8e7b647c5aa16db3 # v4
+        uses: extractions/setup-crate@7577c1bdf2d95e6d65d532788f35ed79d4b1dda2 # v2.0.1
+        with:
+          repo: casey/just
+          version: 1.58.0
       - name: Build docs
         run: just docs-check
 
diff --git a/.github/workflows/zizmor.yml b/.github/workflows/zizmor.yml
index eb9a68d07d..19bdb461ea 100644
--- a/.github/workflows/zizmor.yml
+++ b/.github/workflows/zizmor.yml
@@ -32,4 +32,4 @@ jobs:
           persist-credentials: false
 
       - name: Run zizmor
-        uses: zizmorcore/zizmor-action@70fb788f84895a7701f5643d103d587e460b5c99 # v0.6.3
+        uses: zizmorcore/zizmor-action@cc914d7f3750a2d13d75c7f184a1060aa0e9d482 # v0.6.4
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 54345c819e..be96f1551f 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,13 +17,13 @@ default_language_version:
 
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.16.0
+    rev: v0.16.6
     hooks:
       - id: ruff-check
         args: ["--fix", "--show-fixes"]
       - id: ruff-format
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.4.2
+    rev: v2.4.3
     hooks:
       - id: codespell
         args: ["-L", "fo,ihs,kake,te", "-S", "fixture"]
@@ -34,7 +34,7 @@ repos:
         exclude: mkdocs.yml
       - id: trailing-whitespace
   - repo: https://github.com/DavidAnson/markdownlint-cli2
-    rev: v0.22.1
+    rev: v0.23.2
     hooks:
       # Markdown structure/hygiene. Rule selection and ignores are in
       # .markdownlint-cli2.jsonc; complements ci/lint_docs.py (RST residue,
@@ -72,7 +72,7 @@ repos:
         files: ^packages/zarr-http-server/
         stages: [pre-push]
   - repo: https://github.com/scientific-python/cookie
-    rev: 2026.06.18
+    rev: 2026.08.14
     hooks:
       - id: sp-repo-review
   - repo: https://github.com/numpy/numpydoc
@@ -89,10 +89,10 @@ repos:
         types: [python]
         files: ^(src|tests)/
   - repo: https://github.com/zizmorcore/zizmor-pre-commit
-    rev: v1.26.1
+    rev: v1.30.0
     hooks:
       - id: zizmor
   - repo: https://github.com/twisted/towncrier
-    rev: 25.8.0
+    rev: 26.9.0
     hooks:
       - id: towncrier-check
diff --git a/.readthedocs.yaml b/.readthedocs.yaml
index dddf8449a4..872eb2be80 100644
--- a/.readthedocs.yaml
+++ b/.readthedocs.yaml
@@ -19,15 +19,24 @@ build:
         fi
     install:
       - pip install --upgrade pip
-      - pip install .[remote] --group docs
+      # The docs recipes resolve their toolchain from uv.lock, so uv is all that is
+      # needed here besides just itself.
+      - pip install uv==0.12.9
+      # No GitHub Action is available on Read the Docs, so fetch the official just
+      # release and verify it against the checksum casey/just publishes. Installed
+      # into the build virtualenv's bin, which is already on PATH.
+      - |
+        curl -fsSL -o /tmp/just.tar.gz https://github.com/casey/just/releases/download/1.58.0/just-1.58.0-x86_64-unknown-linux-musl.tar.gz
+        echo "4a5cc2f53e6f0f8c59092a6cc38291eb729d46a7dd95d3ae582008881b84931d  /tmp/just.tar.gz" | sha256sum -c -
+        tar -xzf /tmp/just.tar.gz -C "$READTHEDOCS_VIRTUALENV_PATH/bin" just
     pre_build:
       - |
         if [ "$READTHEDOCS_VERSION_TYPE" != "tag" ];
         then
-          towncrier build --version Unreleased --yes;
+          just changelog-build --version Unreleased --yes;
         fi
     build:
         html:
-          - mkdocs build --strict --site-dir $READTHEDOCS_OUTPUT/html
+          - just docs-build --site-dir $READTHEDOCS_OUTPUT/html
 mkdocs:
   configuration: mkdocs.yml
diff --git a/Justfile b/Justfile
new file mode 100644
index 0000000000..6e56644207
--- /dev/null
+++ b/Justfile
@@ -0,0 +1,165 @@
+# Development and CI verbs live here; Hatch owns Python environments in pyproject.toml.
+# Install: uv tool install hatch==1.16.5 && uv tool install rust-just==1.58.0
+# Select test dependencies/interpreter: HATCH_ENV=test.py3.13-minimal just test
+# On Windows, use Git Bash (the same shell used by the test workflow).
+set shell := ["bash", "-eu", "-o", "pipefail", "-c"]
+set windows-shell := ["bash", "-eu", "-o", "pipefail", "-c"]
+set positional-arguments
+
+hatch_env := env("HATCH_ENV", "test.py3.12-optional")
+# Deliberately a different variable from HATCH_ENV: `just gpu` must not inherit a
+# CPU test environment that happens to be exported in the caller's shell, which
+# would run `pytest -m gpu` against an environment built without the gpu feature.
+gpu_env := env("GPU_HATCH_ENV", "gputest.py3.12")
+# Pinned so a prek release cannot change what CI lints without a commit here.
+prek_version := "0.5.3"
+# Documentation and changelog tooling resolves from uv.lock, not a hatch environment.
+# There is only ever one docs toolchain, so it can be locked and hash-verified, and
+# dependabot's uv ecosystem keeps it current. Hatch still owns the test environments,
+# which exist per interpreter and per dependency set and cannot live in one lockfile.
+docs_run := "uv run --frozen --group docs"
+# The hatch docs environment used to set these; they belong with the mkdocs calls now.
+mkdocs_env := "DISABLE_MKDOCS_2_WARNING=true NO_MKDOCS_2_WARNING=true"
+
+# List available recipes
+default:
+    @just --list
+
+# List available Python environments
+envs:
+    hatch env show
+
+# Create the selected Python environment and list its installed packages
+setup: && list-env
+    hatch env create {{ quote(hatch_env) }}
+
+# List packages in the selected Python environment
+list-env:
+    hatch run {{ quote(hatch_env) }}:pip list
+
+# Run unit tests; pass pytest arguments, e.g. just test -k 'array and resize'
+test *args:
+    hatch run {{ quote(hatch_env) }}:pytest --ignore tests/benchmarks "$@"
+
+# Run unit tests and write coverage.xml and junit.xml
+coverage *args:
+    hatch run {{ quote(hatch_env) }}:coverage run --source=src -m pytest --ignore tests/benchmarks --junitxml=junit.xml -o junit_family=legacy "$@"
+    hatch run {{ quote(hatch_env) }}:coverage xml
+
+# Run unit tests and generate an HTML coverage report
+coverage-html *args:
+    hatch run {{ quote(hatch_env) }}:coverage run --source=src -m pytest --ignore tests/benchmarks "$@"
+    hatch run {{ quote(hatch_env) }}:coverage html
+
+# Serve the HTML coverage report (default port 8000)
+coverage-serve *args:
+    hatch run {{ quote(hatch_env) }}:python -m http.server -d htmlcov "$@"
+
+# Run slow Hypothesis tests and write coverage.xml
+hypothesis *args:
+    hatch run {{ quote(hatch_env) }}:coverage run --source=src -m pytest -nauto --run-slow-hypothesis tests/test_properties.py tests/test_store/test_stateful* "$@"
+    hatch run {{ quote(hatch_env) }}:coverage xml
+
+# Validate executable documentation code blocks
+doctest *args:
+    hatch run doctest:pytest tests/test_docs.py -v "$@"
+
+# Run the benchmark suite
+benchmark *args:
+    hatch run {{ quote(hatch_env) }}:pytest --benchmark-enable tests/benchmarks "$@"
+
+# Run benchmarks under CodSpeed
+benchmark-codspeed *args:
+    hatch run {{ quote(hatch_env) }}:pytest tests/benchmarks --codspeed "$@"
+
+# Run GPU tests with coverage; select the environment with GPU_HATCH_ENV
+gpu *args:
+    HATCH_ENV={{ quote(gpu_env) }} just coverage -m gpu "$@"
+
+# Build documentation (warnings are errors)
+docs-build *args:
+    {{ mkdocs_env }} {{ docs_run }} mkdocs build --strict "$@"
+
+# Serve documentation with live reload
+docs-serve *args:
+    {{ mkdocs_env }} {{ docs_run }} mkdocs serve --watch src "$@"
+
+# Check that every public export has API documentation
+check-doc-exports *args:
+    {{ docs_run }} python ci/check_documented_exports.py docs/api "$@"
+
+# Check documentation source conventions
+lint-docs *args:
+    {{ docs_run }} python ci/lint_docs.py "$@"
+
+# Report unlinked types in built documentation
+check-doc-links *args:
+    {{ docs_run }} python ci/check_unlinked_types.py "$@"
+
+# Run source documentation checks followed by a strict build
+docs-check: check-doc-exports lint-docs docs-build
+
+# Run all pre-commit hooks (ruff, codespell, mypy, repo-review, ...)
+lint *args:
+    uvx prek@{{ prek_version }} run --show-diff-on-failure --color=always --all-files "$@"
+
+# Run hooks with a custom selection, e.g. just hooks run --last-commit
+hooks +args:
+    uvx prek@{{ prek_version }} "$@"
+
+# prek is installed as a persistent uv tool rather than run through uvx: the hook shim
+# prek writes into .git/hooks hard-codes the binary path it was installed from and falls
+# back to `prek` on PATH, and a uvx archive path stops existing at the next cache prune.
+# Install local pre-commit hooks
+hooks-install:
+    uv tool install prek=={{ prek_version }}
+    prek install
+
+# Type-check the library using the locked tooling environment
+typecheck *args:
+    uv run --frozen mypy "$@"
+
+# Check that uv.lock is in sync with pyproject.toml
+lock-check:
+    uv lock --check
+
+# Update the dependency lockfile
+lock *args:
+    uv lock "$@"
+
+# Build the source distribution and wheel
+build *args:
+    hatch build "$@"
+
+# Create a changelog fragment (interactive without arguments)
+changelog *args:
+    {{ docs_run }} towncrier create "$@"
+
+# Preview the next release's changelog
+changelog-draft *args:
+    {{ docs_run }} towncrier build --draft --version Unreleased "$@"
+
+# Build release notes; pass --version and --yes when preparing a release
+changelog-build *args:
+    {{ docs_run }} towncrier build "$@"
+
+# Check changelog filenames (default: changes/; accepts a package changes directory)
+check-changelogs *args:
+    uv run --no-project python ci/check_changelog_entries.py "$@"
+
+# Check recipe formatting of the root Justfile and every package justfile
+just-check:
+    just --fmt --check
+    shopt -s nullglob; for f in packages/*/justfile; do just --justfile "$f" --fmt --check; done
+
+# Run a zarr-metadata recipe, or list its recipes with no arguments
+zarr-metadata *args:
+    just --justfile packages/zarr-metadata/justfile "$@"
+
+# Run a zarr-indexing recipe, or list its recipes with no arguments
+zarr-indexing *args:
+    just --justfile packages/zarr-indexing/justfile "$@"
+
+# Run a zarr-http-server recipe, or list its recipes with no arguments
+zarr-http-server *args:
+    just --justfile packages/zarr-http-server/justfile "$@"
diff --git a/changes/3285.feature.md b/changes/3285.feature.md
deleted file mode 100644
index 35507ea26c..0000000000
--- a/changes/3285.feature.md
+++ /dev/null
@@ -1,13 +0,0 @@
-JSON metadata validation now delegates to ``msgspec.convert`` for the type
-coercions it supports (``Literal`` membership, ``int`` / ``bool`` strictness,
-list-to-tuple), replacing the per-field hand-written ``parse_*`` logic.
-User-defined attributes retain their existing JSON handling.
-A latent generator-exhaustion bug in
-``parse_storage_transformers`` is also fixed. See #3285.
-
-As a result some metadata inputs are now parsed more strictly. The previous
-per-field checks compared values with ``==``, which accepts any numerically
-equal object, so a float such as ``2.0`` was accepted as ``zarr_format``; it is
-now rejected because it is not an ``int``. Booleans are likewise no longer
-accepted where an ``int`` is expected, since ``bool`` is an ``int`` subclass.
-Metadata that conforms to the Zarr specification is unaffected.
diff --git a/changes/4149.doc.md b/changes/4149.doc.md
deleted file mode 100644
index 8a473acac9..0000000000
--- a/changes/4149.doc.md
+++ /dev/null
@@ -1 +0,0 @@
-Added a Roadmap page to the documentation outlining future plans and intended changes to the library.
diff --git a/changes/4174.bugfix.md b/changes/4174.bugfix.md
deleted file mode 100644
index 37dc10078c..0000000000
--- a/changes/4174.bugfix.md
+++ /dev/null
@@ -1,13 +0,0 @@
-Array creation is now O(1) in the number of chunks per dimension. Chunk
-normalization returns a `ChunkGrid` whose uniform dimensions are stored as a
-size + extent pair (`FixedDimension`) instead of being expanded to one entry
-per chunk, so creating arrays like
-`zarr.create_array(store, shape=(2**62,), chunks=(1,), dtype='int32')` succeeds
-instantly instead of raising `ValueError` or allocating gigabytes of memory.
-The intermediate `ChunksTuple` representation was removed in the process, and
-`ChunksLike` now admits per-dimension specs that mix a bare int (uniform chunk
-size) with explicit edge-length sequences, matching what the normalizer and
-the rectilinear grid spec already accepted.
-This fixes the array-creation half of #4174; the coordinate-selection
-allocation reported there is still tracked in that issue (#4172 fixed the
-related case of sorted 1-D coordinate selections).
diff --git a/changes/4189.bugfix.md b/changes/4189.bugfix.md
deleted file mode 100644
index 76ef7e7a5e..0000000000
--- a/changes/4189.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Allow `Group.require_array` to accept a `ZDType` for `dtype`, matching the other array creation methods. Previously an existing array could only be required with a string or NumPy dtype.
diff --git a/changes/4193.doc.md b/changes/4193.doc.md
deleted file mode 100644
index 0972e8be2c..0000000000
--- a/changes/4193.doc.md
+++ /dev/null
@@ -1,4 +0,0 @@
-Converted remaining reStructuredText-style double-backtick markup to Markdown
-single backticks in the docstrings of `zarr.api.asynchronous`,
-`zarr.api.synchronous`, `zarr.core.array`, `zarr.registry`, and
-`zarr.storage._common`. No functional changes.
diff --git a/changes/4213.misc.md b/changes/4213.misc.md
deleted file mode 100644
index 150e60b57b..0000000000
--- a/changes/4213.misc.md
+++ /dev/null
@@ -1 +0,0 @@
-Updated ruff to 0.16.0 and fixed the violations surfaced by its expanded default rule set: narrowed a blind `except Exception` in `StorePath.__eq__` to `AttributeError`, removed unnecessary `global` declarations in `zarr.core.sync`, made `subprocess.run` calls in tests pass `check=False` explicitly, and applied automatic fixes (`None` moved to the end of type unions, unused `noqa` directives removed).
diff --git a/changes/4227.bugfix.md b/changes/4227.bugfix.md
deleted file mode 100644
index 18293178bd..0000000000
--- a/changes/4227.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Consolidated metadata is now reconstructed independently of the order the keys appear in on disk. Previously, sibling subtrees whose keys were not adjacent in the persisted mapping lost their children, which made nodes unreachable through consolidated metadata -- most visibly for sibling groups whose names differ only by case.
diff --git a/changes/4236.doc.md b/changes/4236.doc.md
deleted file mode 100644
index 45f8a2c22c..0000000000
--- a/changes/4236.doc.md
+++ /dev/null
@@ -1 +0,0 @@
-Document how to reassign Read the Docs version slugs when publishing a subpackage release.
diff --git a/changes/4239.bugfix.md b/changes/4239.bugfix.md
deleted file mode 100644
index b5bc92f18b..0000000000
--- a/changes/4239.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-`FsspecStore.from_mapper` and `FsspecStore.from_url` no longer fail when converting a synchronous instance of an async-capable filesystem whose storage options contain objects that cannot be serialized to JSON (e.g. an `azure.identity.DefaultAzureCredential`). The async instance is now constructed from the original filesystem arguments instead of a JSON round-trip.
diff --git a/changes/4247.doc.md b/changes/4247.doc.md
deleted file mode 100644
index 6dbca1d3d6..0000000000
--- a/changes/4247.doc.md
+++ /dev/null
@@ -1,5 +0,0 @@
-Added a "Related Projects" page to the documentation listing the companion
-packages developed in this repository — `zarr-metadata` and `zarr-indexing` —
-and linked it from the landing page. Links to those packages now use the
-canonical `https://zarr.readthedocs.io/projects/...` URLs, and each companion
-package's documentation links back to the `zarr-python` docs.
diff --git a/changes/4257.bugfix.md b/changes/4257.bugfix.md
deleted file mode 100644
index f643cf31f0..0000000000
--- a/changes/4257.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Numpy integers are accepted as chunk sizes again. Since 3.3.0 a per-dimension chunk size that was a numpy integer (e.g. `chunks=(np.int64(2), np.int64(2))`, as produced by any computed chunk shape) raised `TypeError: 'numpy.int64' object is not iterable`, because the scalar chunk path narrowed on `int` while its caller dispatched on `numbers.Integral`. The same regression had broken numpy arrays as chunk specifications through the legacy `zarr.create` / `zarr.array` / `zarr.open_array` functions, which accepted them in 2.x and 3.2.x; those work again. (`zarr.create_array` and the functions built on it gain numpy-array support separately, in #4329.) A chunk specification that is neither an integer nor iterable now reports the offending value instead of failing with an opaque iteration error.
diff --git a/changes/4260.bugfix.md b/changes/4260.bugfix.md
deleted file mode 100644
index b703c47a35..0000000000
--- a/changes/4260.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-The `cast_value` codec now requires `cast-value-rs>=0.4.2`. Earlier versions of that backend silently corrupted data when handed an array that was not row-major — the layout the `transpose` codec produces — so a `cast_value` codec next to a `transpose` codec would either write transposed values with no error or fail with `ValueError: Input array must be contiguous`. The minimum version is enforced at runtime as well as in the package metadata, so an environment that already has an older `cast-value-rs` installed now raises `ImportError` when the codec is used, instead of corrupting data.
diff --git a/changes/4261.misc.md b/changes/4261.misc.md
deleted file mode 100644
index ca2a3fbb1e..0000000000
--- a/changes/4261.misc.md
+++ /dev/null
@@ -1 +0,0 @@
-The contents of the `zarr` source distribution are now defined by an explicit allowlist rather than a blocklist. Previously the sdist bundled the whole `packages/` tree — `zarr-indexing`, `zarr-metadata` and `zarr-http-server`, which are released as their own distributions — along with CI configuration and other repository files. The sdist also now ships `docs/`, so the test suite it carries can be collected and run from an unpacked sdist.
diff --git a/changes/4265.bugfix.md b/changes/4265.bugfix.md
deleted file mode 100644
index 6daf0fc7d0..0000000000
--- a/changes/4265.bugfix.md
+++ /dev/null
@@ -1,13 +0,0 @@
-Accept [universal-pathlib](https://github.com/fsspec/universal_pathlib) `UPath` objects wherever
-zarr accepts a `StoreLike` value. A remote `UPath` now creates an `FsspecStore` using the
-filesystem and storage options the `UPath` already carries, and a local `UPath` creates a
-`LocalStore`, so that `UPath('/data')` and `Path('/data')` behave the same.
-
-Previously this worked only by accident: in universal-pathlib < 0.3 every `UPath` subclassed
-`pathlib.Path` and implemented `__fspath__`, so remote paths were either converted to a URI string
-by the caller or wrapped in a `LocalStore` that happened to dispatch through fsspec. Since
-universal-pathlib 0.3 remote paths do neither, and passing one raised
-`TypeError: Unsupported type for store_like`.
-
-`FsspecStore.from_upath` also now converts the `UPath`'s filesystem to async mode, instead of
-raising `TypeError` for synchronous filesystems and warning for sync-mode instances of async ones.
diff --git a/changes/4272.bugfix.md b/changes/4272.bugfix.md
deleted file mode 100644
index 90616ca322..0000000000
--- a/changes/4272.bugfix.md
+++ /dev/null
@@ -1,38 +0,0 @@
-Explicit per-chunk size lists now always produce a rectilinear chunk grid,
-even when the sizes happen to describe a regular grid (all equal, or all equal
-with a smaller trailing chunk). Previously such input was silently collapsed to
-a regular grid, which changed resize semantics: a regular grid grows by
-extending the uniform pattern, while a rectilinear grid appends a new edge
-chunk — the behavior an append-oriented layout like `(168,) * 13 + (24,)`
-relies on. The grid kind now follows the input syntax, matching 3.2.x:
-scalar chunk sizes (including numpy integers and the `-1` sentinel) produce a
-regular grid, nested sequences produce a rectilinear grid. Rectilinear grids
-remain gated behind `zarr.config.set({"array.rectilinear_chunks": True})`.
-See #4174 for the accompanying O(1) chunk normalization change.
-
-One consequence for users who never enable rectilinear chunks: because a
-nested sequence now always requests a rectilinear grid, a per-dimension
-sequence of edge lengths that happens to be uniform — for example the
-`((4,), (4,))` or `[[3, 3, 1]]` form that a dask array's `.chunks` attribute
-produces — is no longer quietly accepted as a regular grid when the
-`array.rectilinear_chunks` option is off. Such input raises
-`ValueError: Rectilinear chunk grids are experimental and disabled by default`,
-exactly as it did in 3.2.x; the silent acceptance existed only in 3.3.0. Pass
-one integer per dimension (e.g. `chunks=(4, 4)`, or a dask array's
-`.chunksize`) to request a regular grid.
-
-`zarr.from_array` with the default `chunks="keep"` / `shards="keep"` now
-reproduces the source's stored grid exactly: a rectilinear grid is passed
-through in O(number of dimensions), with uniform dimensions keeping their
-bare-int shorthand; sharding under a rectilinear shard grid is preserved
-instead of being silently dropped; and the default `write_data=True` copy
-works for every grid kind. `Array.chunks` is now defined for any sharded array
-(the inner chunks of a shard are always regular), and for sharded arrays with
-a rectilinear shard grid `Array.info` no longer raises — it reports the shard
-shape as `<variable>` — while `Array.nchunks_initialized` counts the chunks of
-each initialized shard individually instead of raising.
-
-Apart from the nested-sequence input form noted above, everything described
-here concerns rectilinear chunk grids, which remain an experimental feature
-gated behind `zarr.config.set({"array.rectilinear_chunks": True})`; arrays
-with regular chunk grids are unaffected.
diff --git a/changes/4277.feature.md b/changes/4277.feature.md
deleted file mode 100644
index f5c247496d..0000000000
--- a/changes/4277.feature.md
+++ /dev/null
@@ -1,28 +0,0 @@
-`zarr.registry.get_codec_class` now raises `zarr.errors.UnknownCodecError` instead of `KeyError`
-when no implementation is registered for a codec, and `zarr.core.config.BadConfigError` instead of
-`KeyError` when the implementation named in `config["codecs"][name]` is not registered.
-`zarr.registry.get_numcodec` raises `UnknownCodecError` instead of the `ValueError` numcodecs
-raises for an unregistered Zarr format 2 codec id (`numcodecs.errors.UnknownCodecError` on
-numcodecs 0.15.1 and later). All of these are subclasses of `ValueError`, so `except ValueError`
-is unaffected, but `except KeyError` and `except numcodecs.errors.UnknownCodecError` are.
-
-These errors now name Python packages known to provide the codec, so that a user who cannot read
-an array learns what to install:
-
-```
-An implementation for codec 'wavpack' is not available. Register one explicitly using the codec
-registry (see ...), or install a Python package that registers a codec implementation with
-numcodecs. Known packages supporting this codec: wavpack-numcodecs.
-```
-
-The tables covering this live in `src/zarr/registry.py`, one per Zarr format, and include the
-codecs `numcodecs` gates behind its own optional dependencies (`zfpy`, `pcodec`, `crc32c`,
-`msgpack2`). Codec authors can add their published package to them.
-
-A codec whose `from_dict` raises `KeyError` on a malformed configuration now surfaces as
-`zarr.errors.MetadataValidationError` naming the codec and the missing key. Previously it was
-reported as `UnknownCodecError: Unknown codec: '<configuration key>'`, presenting a configuration
-key as though it were a codec name, and on the `zarr.open` path a bare `KeyError` could be
-swallowed by the array-then-group fallback and reported as an unrelated group error.
-
-`zarr.errors.UnknownCodecError` is now exported from `zarr.errors`.
diff --git a/changes/4279.bugfix.md b/changes/4279.bugfix.md
deleted file mode 100644
index 7d99a49ccf..0000000000
--- a/changes/4279.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-A `scale_offset` codec configured with a string-valued zero scale is now rejected. `scale` accepts strings, and no string is ever equal to `0`, so `"0"`, `"0.0"` and the hex form `"0x0000000000000000"` skipped the "scale must be non-zero" check that the numeric `0` triggers. On float data types the array was created, every chunk was written as zero and read back as `nan` with no error, and the zero scale was persisted to the metadata so reopening the store reproduced it; on integer data types the codec raised `ZeroDivisionError` instead of `ValueError`. The check now runs on the parsed scalar rather than the value as supplied.
diff --git a/changes/4284.bugfix.md b/changes/4284.bugfix.md
deleted file mode 100644
index 4ad1c456b4..0000000000
--- a/changes/4284.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a `ValueError` when setting an orthogonal selection on a sharded array where more than one dimension is indexed by an array. The sharding codec re-derives an indexer from the chunk selection it is handed, which turns such a selection into a coordinate selection addressing the value buffer flat, so the write failed on a shape mismatch. Both partial-encode paths are fixed, so the write works under either codec pipeline.
diff --git a/changes/4286.bugfix.md b/changes/4286.bugfix.md
deleted file mode 100644
index e1ebb0dee2..0000000000
--- a/changes/4286.bugfix.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Fixed integer array indexing with unsigned index dtypes. An unsorted index such as
-`np.array([3, 0], dtype="uint8")` spanning more than one chunk raised `IndexError`, because
-the order check used `np.diff`, which wraps on unsigned dtypes and misclassified a
-descending selection as increasing. Separately, a `uint64` index raised `IndexError` on both
-`array[...]` and `array.vindex[...]` — sorted or not — because `uint64` promotes to
-`float64` against a signed chunk offset. Index arrays are now cast to `intp`.
-
-Unsigned indices are bounds-checked before this conversion, so values such as
-`np.uint64(2**64 - 1)` are rejected rather than wrapping to a negative index and
-reading or overwriting an element at the end of the array.
-
-Negative-index normalization copies indices before modifying them, preserving
-caller-owned arrays and supporting read-only index arrays. Reusing one index
-array across axes of different lengths now normalizes each axis independently.
diff --git a/changes/4288.bugfix.md b/changes/4288.bugfix.md
deleted file mode 100644
index 4080c2b44c..0000000000
--- a/changes/4288.bugfix.md
+++ /dev/null
@@ -1,3 +0,0 @@
-`zarr.from_array` now defaults to the fill value and the attributes of the source array. Previously both were silently discarded: the array was created with the data type's default scalar and no attributes.
-
-An explicit `fill_value=None` now selects the data type's default scalar (Zarr format 3) or a null fill value (Zarr format 2), consistently with `create_array`, and an empty `attributes` dict creates the array with no attributes.
diff --git a/changes/4305.bugfix.md b/changes/4305.bugfix.md
deleted file mode 100644
index 13221d8e3b..0000000000
--- a/changes/4305.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Fixed an infinite loop when creating a 0-dimensional array with `shards="auto"` while the `array.target_shard_size_bytes` config option is set. Such arrays now resolve to `shards=()`, matching the behavior when no shard size target is configured.
diff --git a/changes/4307.bugfix.md b/changes/4307.bugfix.md
deleted file mode 100644
index b77c89cfa5..0000000000
--- a/changes/4307.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Fixed `chunks=-1` on a zero-length axis resolving to an invalid chunk size of 0, which caused a `ValueError`, `ZeroDivisionError`, or infinite loop depending on the sharding configuration. Such axes now get chunk size 1, matching `chunks="auto"`.
diff --git a/changes/4316.bugfix.md b/changes/4316.bugfix.md
deleted file mode 100644
index e4b9bd8d94..0000000000
--- a/changes/4316.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Fixed a `ValueError` when setting an orthogonal selection on a sharded array that mixes an integer index with two or more array indices, such as `a.oindex[[3, 1, 2], 1, [0, 2]] = value`. The fix for the array-only case in #4284 reshaped the value only when its shape matched the coordinate selection exactly; the sharding codec now also ravels a value that is the selection's shape minus the integer-indexed axes. Values of any other rank are left alone, so a write that is invalid on an unsharded array fails the same way on a sharded one. Both partial-encode paths share one helper for this.
diff --git a/changes/4324.bugfix.md b/changes/4324.bugfix.md
deleted file mode 100644
index d71f105ef8..0000000000
--- a/changes/4324.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Opening a Zarr format 3 array whose codec's ``from_dict`` raised a ``KeyError`` with no arguments used to fail with an unrelated ``IndexError: tuple index out of range`` while formatting the error message. Because that ``IndexError`` is not a ``ValueError``, it also escaped the array-then-group fallback in ``zarr.open`` and broke group operations such as ``Group.members()`` and ``"child" in group`` when any child array used such a codec. The ``KeyError`` is now always reported as a ``MetadataValidationError`` naming the codec, with the offending key included only when the ``KeyError`` carried one.
diff --git a/changes/4325.bugfix.md b/changes/4325.bugfix.md
deleted file mode 100644
index 19e1fc96aa..0000000000
--- a/changes/4325.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-`zarr.from_array` now deep-copies the source array's attributes instead of sharing nested dicts and lists between the source and the new array. Previously, mutating a nested attribute on the new array (for example ``dst.attrs["meta"]["tags"].append(...)``) silently changed the source array's in-memory attributes too. Deeply nested attributes can raise `RecursionError` during the copy even if they can be stored and reopened; the threshold depends on Python's recursion limit and call stack. Pass `attributes={}` to omit inherited attributes.
diff --git a/changes/4326.misc.md b/changes/4326.misc.md
deleted file mode 100644
index 500b4cdf8b..0000000000
--- a/changes/4326.misc.md
+++ /dev/null
@@ -1 +0,0 @@
-Removed the private test helper `_gzip_streams_equal_except_mtime` from `zarr.codecs.gzip`; it now lives in the test suite.
diff --git a/changes/4328.bugfix.md b/changes/4328.bugfix.md
deleted file mode 100644
index 2751dbd47f..0000000000
--- a/changes/4328.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-Fixed `chunks=False` on a zero-length axis resolving to a chunk size of 0, which raised a `ValueError` for Zarr format 3, raised a `ZeroDivisionError` with `shards="auto"`, and silently wrote invalid `chunks` metadata for Zarr format 2. `False` now takes the same path as `chunks=-1`, so such axes get chunk size 1, matching `chunks="auto"`.
diff --git a/changes/4329.feature.md b/changes/4329.feature.md
deleted file mode 100644
index 65b0bc598f..0000000000
--- a/changes/4329.feature.md
+++ /dev/null
@@ -1 +0,0 @@
-`zarr.create_array`, `Group.create_array`, `zarr.from_array`, and the entry points built on them now accept a numpy array as the `chunks` or `shards` specification, alongside ints, tuples, and numpy integer scalars. This is new for that API: it has never accepted numpy arrays in any 3.x release, because each entry point compared the specification to the `"auto"` or `"keep"` sentinel string before normalizing it, and for a numpy array that comparison raised numpy's ambiguous-truth-value `ValueError`. Those sentinel checks are now guarded so array-like specifications reach the normalizer, bringing this API in line with the legacy `zarr.create` / `zarr.array` / `zarr.open_array` functions, which have accepted numpy arrays since 2.x.
diff --git a/changes/4331.misc.md b/changes/4331.misc.md
deleted file mode 100644
index 949ebfffd3..0000000000
--- a/changes/4331.misc.md
+++ /dev/null
@@ -1 +0,0 @@
-Added `zarr.testing.strategies.sharded_arrays`, a Hypothesis strategy that always generates a sharded Zarr v3 array, drawing the chunk shape, shard shape, subchunk write order and inner codec chain, and — for half of its draws, or as selected by its `nested` argument — one level of recursive sharding, where the chunks are grouped into inner shards that are in turn grouped into the stored shards. The `test_oindex` and `test_vindex` property tests now draw it as a third arm alongside `simple_arrays` and `rectilinear_arrays`, so the sharding codec's write path for orthogonal selections with two or more array-indexed axes is exercised in tens of examples per run instead of about one.
diff --git a/changes/4335.bugfix.md b/changes/4335.bugfix.md
deleted file mode 100644
index 38e24f466b..0000000000
--- a/changes/4335.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-`from_array` preserves a Zarr source's explicit data type instead of trying to infer it from its NumPy dtype, allowing variable-length bytes arrays to be copied.
diff --git a/changes/4339.bugfix.md b/changes/4339.bugfix.md
deleted file mode 100644
index 0697e5d232..0000000000
--- a/changes/4339.bugfix.md
+++ /dev/null
@@ -1 +0,0 @@
-The documentation build and the documentation test suite no longer delete a `data/` directory relative to the current working directory. Two executable docs sessions opened with `shutil.rmtree('data', ignore_errors=True)` to make their examples re-runnable; because executed docs blocks run in the process working directory rather than the docs tree, `mkdocs build -f <repo>/mkdocs.yml` or `pytest tests/test_docs.py` started from any directory containing a `data/` folder — a project checkout, or `/` — silently emptied it. The sdist ships `docs/` and `tests/` and `testpaths` collects `docs/user-guide`, so this reached anyone running the shipped test suite, not only contributors. The deletions are gone; the on-disk examples in the quick start, arrays, groups, storage and performance guides now create with `overwrite=True` (or `zarr.save_array(..., mode="w")`), which is also what a reader re-running an example needs, and a new docs test rejects any executed block that calls a filesystem deletion.
diff --git a/changes/4363.bugfix.md b/changes/4363.bugfix.md
new file mode 100644
index 0000000000..fbccb109f4
--- /dev/null
+++ b/changes/4363.bugfix.md
@@ -0,0 +1,8 @@
+Removed every `assert` statement from runtime code and enabled ruff's `S101`
+rule to keep them out. Asserts are stripped under `python -O`, and two of them
+were load-bearing: `GroupMetadata.from_dict` asserted on `node_type` and the
+array-to-group fallback in `zarr.open` relied on catching the resulting
+`AssertionError`, and `make_store` asserted on `mode` before the real
+validation. Both now raise proper errors (`NodeTypeValidationError` and
+`ValueError`). Redundant asserts were deleted, type-narrowing asserts were
+restructured so mypy narrows without them, and the rest became explicit raises.
diff --git a/changes/4368.misc.md b/changes/4368.misc.md
new file mode 100644
index 0000000000..bdb87c70cf
--- /dev/null
+++ b/changes/4368.misc.md
@@ -0,0 +1 @@
+Prevent the downstream xarray CI job from replacing the branch version of Zarr with a PyPI release before reporting versions and running tests.
diff --git a/changes/4372.misc.md b/changes/4372.misc.md
new file mode 100644
index 0000000000..55a800a3f3
--- /dev/null
+++ b/changes/4372.misc.md
@@ -0,0 +1 @@
+Define development and CI commands in a root Justfile, with Hatch managing Python environments and documentation tooling resolving from `uv.lock`. The Hatch script tables are removed, so invocations like `hatch env run --env test.py3.12-optional run-coverage` become `just coverage`; see the contributing guide for the full set. Extracted from [#4096](https://github.com/zarr-developers/zarr-python/pull/4096).
diff --git a/docs/blog/posts/3.3.0-release.md b/docs/blog/posts/3.3.0-release.md
index 13368848ae..e64e9f7d85 100644
--- a/docs/blog/posts/3.3.0-release.md
+++ b/docs/blog/posts/3.3.0-release.md
@@ -167,3 +167,30 @@ We hope these new features are helpful, and we would appreciate any feedback tha
 The updates in this release are just the first step of a larger performance-oriented direction for Zarr-Python. Landing these two enhancements taught us a *lot* about the performance-sensitive areas of the library. We can and will invest more time in performance tuning, e.g. by adding or changing abstractions, writing code for special cases, etc.
 
 We plan to consider including compiled code that should enable significant performance improvements. The [`zarrs`](https://zarrs.dev/) project is an ecosystem of Zarr tools written in Rust, with [extremely high performance](https://book.zarrs.dev/#-zarrs-is-fast-). Is there a `zarrs` binding in Zarr-Python's future? I hope so! We are keenly observing development of [`zarrista`](https://developmentseed.org/zarrista/latest/) as a proof-of-concept for what a Python-`zarrs` binding layer might look like. Stay tuned!
+
+## Contributors
+
+Thanks to everyone who contributed to this release (`*` marks a first-time contributor to Zarr-Python):
+
+- [@aldenks](https://github.com/aldenks)
+- [@AMBRA7592](https://github.com/AMBRA7592) *
+- [@binggao1230](https://github.com/binggao1230) *
+- [@chuckwondo](https://github.com/chuckwondo) *
+- [@d-v-b](https://github.com/d-v-b)
+- [@DimitriPapadopoulos](https://github.com/DimitriPapadopoulos)
+- [@goutamadwant](https://github.com/goutamadwant) *
+- [@ilan-gold](https://github.com/ilan-gold)
+- [@jhamman](https://github.com/jhamman)
+- [@josh-ag2](https://github.com/josh-ag2) *
+- [@kabilar](https://github.com/kabilar) *
+- [@keewis](https://github.com/keewis)
+- [@lhoupert](https://github.com/lhoupert) *
+- [@maxrjones](https://github.com/maxrjones)
+- [@NIK-TIGER-BILL](https://github.com/NIK-TIGER-BILL) *
+- [@oldrobotdev](https://github.com/oldrobotdev) *
+- [@SAY-5](https://github.com/SAY-5) *
+- [@sehoffmann](https://github.com/sehoffmann) *
+- [@selmanozleyen](https://github.com/selmanozleyen) *
+- [@stibrew](https://github.com/stibrew) *
+- [@TomAugspurger](https://github.com/TomAugspurger)
+- [@zkoppert](https://github.com/zkoppert) *
diff --git a/docs/blog/posts/3.4.0-release.md b/docs/blog/posts/3.4.0-release.md
new file mode 100644
index 0000000000..7612838f3b
--- /dev/null
+++ b/docs/blog/posts/3.4.0-release.md
@@ -0,0 +1,120 @@
+---
+date: 2026-09-10
+authors:
+  - d-v-b
+categories:
+  - Release
+draft: false
+---
+
+# `zarr` 3.4.0
+
+`zarr` 3.4.0 is out! This post covers the highlights of the latest version of `zarr`. We will also introduce some new subpackages we are developing as part of an effort to make `zarr` more modular. See the full [release notes](../../release-notes.md) for the per-PR breakdown, or keep reading to catch the digested version.
+
+## Stackification
+
+This first item is not a new `zarr` feature. Rather, it's a **Zarr-Python** feature: Zarr-Python (the project) is becoming a *stack* of related Python packages, foremost among them `zarr`, the Python library. In the last few months Zarr-Python gained the following stand-alone Python packages:
+
+- [`zarr-metadata`](https://zarr-metadata.readthedocs.io/), a library narrowly scoped to modelling Zarr metadata documents (e.g., `zarr.json`), with precise type definitions and validation routines. Designed for anyone who wants type safety for Zarr V2 or V3 metadata without re-implementing the Zarr specs. `zarr-metadata` is very lightweight -- it does not depend on `zarr` -- so it should be a very cheap dependency for projects to add, either as a runtime or test dependency. We hope to replace most of the metadata logic in `zarr` with the contents of `zarr-metadata`.
+- [`zarr-indexing`](https://zarr-indexing.readthedocs.io/), a library concerned with data structures and algorithms for lazy, chunked array indexing routines based on Google's trailblazing [TensorStore](https://google.github.io/tensorstore/) library. We hope to replace the array indexing logic in `zarr` with routines defined in `zarr-indexing`, and we also want to use `zarr-indexing` to support new lazy indexing functionality for arrays in `zarr`.
+- [`zarr-http-server`](https://zarr-http-server.readthedocs.io/), a library that serves a `zarr` `Store`, `Array` or `Group` over HTTP via an ASGI app. This allows any array-like data to be dynamically exposed as Zarr. For example, you can take TIFF stacks, access them with `tifffile`, and use `tifffile`'s Zarr layer with `zarr-http-server` to expose the TIFF data as Zarr over HTTP for consumption by clients that don't know how to read TIFF. There are no plans for `zarr` to depend on this package.
+
+These three packages are just a start. We have in-flight PRs for defining packages for Zarr chunk key encodings ([PR 4298](https://github.com/zarr-developers/zarr-python/pull/4298)), stores ([PR 4318](https://github.com/zarr-developers/zarr-python/pull/4318)), and codecs ([PR 4319](https://github.com/zarr-developers/zarr-python/pull/4319)).
+
+All of these packages are pre-1.0 and changing rapidly; `zarr` does not yet depend on them. When the relevant APIs stabilize, we plan to gradually replace functionality defined in `zarr` today for the equivalent functionality in a subpackage. For example, the [store PR](https://github.com/zarr-developers/zarr-python/pull/4318) includes a `legacy` module that contains a verbatim copy of `zarr`'s current `Store` API, so that when `zarr` depends on `zarr-storage`, we can swap out functionality defined in `zarr` for identical functionality in `zarr-storage`, and users won't notice any difference beyond an additional installed package.
+
+The strategy here is to identify the logically separate parts of a Zarr implementation, and build a separate package around each part. This is not an original idea: the Rust [`zarrs`](https://zarrs.dev/) project is composed of many separate packages and this architecture has worked well for that project.
+
+Why are we doing this? Factoring `zarr` into separate packages may seem like a lot of churn with little upside beyond more maintenance. It's true that there will be new kinds of maintenance, and publishing gets a bit more complicated. But we see the following advantages to organizing Zarr-Python into subpackages:
+
+- **Modularity:** Installing `zarr` brings in `numcodecs` and other dependencies required for the full Zarr format. If a Python user only needs to parse Zarr metadata documents, e.g. because they are using [`zarrista`](https://developmentseed.org/zarrista/latest/) or [`tensorstore`](https://google.github.io/tensorstore/) to do IO, then the full set of `zarr` dependencies is wasteful. We want to make it as easy as possible for people to use Zarr correctly. That means it should be easy to install a package that defines the syntax and semantics of the Zarr metadata documents, without committing consumers of that package to a full runtime.
+- **Agility:** We believe that separate packages will enable more effective development of the Zarr stack. For example, we want to develop a new version of our storage APIs that formally separate sync and async stores. We could carry out this development inside `zarr`, but `zarr` releases would mix storage API developments with ordinary `zarr` development, and so changes to the store API itself would not be transparent to consumers, e.g. implementers of third-party storage backends. If the storage API is defined entirely in a separate package, then we can version that package exactly when the storage API changes, which makes the design history much more visible to consumers.
+- **Focus:** Functionality in `zarr` has a tendency to be as good as it needs to be for `zarr`'s needs. This is reasonable, but it can complicate the decision about when to make internal APIs public. For example, the core metadata APIs in `zarr` are not clearly marked public, which is unfortunate because the metadata is a really important part of Zarr! We hope that devoting an entire package to, e.g., Zarr metadata, makes it easier to define a public API surface that `zarr` and any other consumer can depend on. We want these subpackages to treat `zarr` as the main, but not sole, consumer, which means we can implement useful features even if `zarr` doesn't need them today.
+- **Packaging:** Defining core APIs in separate packages solves a packaging problem for `zarr`. If `zarr` defines core APIs like storage and codec interfaces internally, third-party packages must depend on `zarr` to access those APIs. This in turn means `zarr` cannot offer those third-party packages as optional dependencies without incurring a circular dependency. Introducing a common dependency for `zarr` and `third-party-zarr-package` removes the circular dependency issue entirely.
+
+For the full list of subpackages, see the "Related Projects" [page in our docs](../../subprojects.md).
+
+## Our Roadmap
+
+With the Zarr V2 -> V3 format transition largely settled, it's worth reflecting on how we want `zarr` to evolve. The previous section outlined one facet of that evolution -- defining `zarr` as the top of a stack of interlocking Zarr tools. There are other big changes ahead, foremost among them our goal of unlocking a vast performance improvement by wrapping the `zarrs` Rust crate via [PyO3](https://pyo3.rs/) bindings defined in [`zarrista`](https://developmentseed.org/zarrista/latest/). You can read more about this direction and other future plans in our new [roadmap document](../../roadmap.md), which is published as part of the 3.4.0 release.
+
+## Rectilinear Chunk Grid Improvements
+
+The experimental rectilinear (irregular) chunk grid support (opt in with `zarr.config.set({"array.rectilinear_chunks": True})`) got several API improvements and bug fixes, mostly in [#4218](https://github.com/zarr-developers/zarr-python/pull/4218) and [#4272](https://github.com/zarr-developers/zarr-python/pull/4272):
+
+- Chunk grid flavor (regular vs rectilinear) now consistently follows input syntax: a nested per-dimension list always requests a rectilinear grid, even when the edges happen to be uniform. This fixes a regression in 3.3.0, where uniform-plus-short-tail lists requested a regular grid, which changed resize semantics.
+- `zarr.from_array(..., chunks="keep")` reproduces a rectilinear source grid
+  exactly (in O(ndim)); sharding under a rectilinear shard grid is preserved
+  instead of dropped.
+- `Array.chunks` is defined for any sharded array; `Array.info` and
+  `Array.nchunks_initialized` work for rectilinear shard grids instead of
+  raising (`info` shows the shard shape as `<variable>`).
+- Zero-length axes: `chunks=-1` and `chunks=False` resolve to chunk size 1 ([#4307](https://github.com/zarr-developers/zarr-python/pull/4307), [#4328](https://github.com/zarr-developers/zarr-python/pull/4328)) instead of `ZeroDivisionError` / invalid metadata.
+
+## Useful Codec Errors
+
+`zarr` does not support every possible codec out of the box. Instead, we allow external packages to register their codec implementations with `zarr` at runtime, which broadens the palette of codecs we can support. When `zarr` reads an array with a codec it doesn't recognize, there's a good chance that the fix is to install the package that ships that codec implementation. But how should a user know which package they need?
+
+Previously, `zarr` handled an unknown codec with an opaque error, conveying only that `zarr` doesn't recognize the codec. Now, thanks to PRs [#4277](https://github.com/zarr-developers/zarr-python/pull/4277) and [#4351](https://github.com/zarr-developers/zarr-python/pull/4351), we maintain a table that relates the names of well-known codecs `zarr` doesn't ship with to packages that provide implementations. We use this table to provide a useful error message when an unknown codec is encountered. For example, opening an array whose metadata names the `imagecodecs_jpeg` codec, without any package that provides it installed:
+
+```python exec="true" session="codec-errors" source="above" result="ansi"
+import json
+
+import zarr
+from zarr.buffer.cpu import buffer_prototype
+
+metadata = {
+    "zarr_format": 3,
+    "node_type": "array",
+    "shape": [4, 4],
+    "data_type": "uint8",
+    "chunk_grid": {"name": "regular", "configuration": {"chunk_shape": [4, 4]}},
+    "chunk_key_encoding": {"name": "default"},
+    "fill_value": 0,
+    "codecs": [{"name": "bytes"}, {"name": "imagecodecs_jpeg"}],
+    "attributes": {},
+}
+store = {"zarr.json": buffer_prototype.buffer.from_bytes(json.dumps(metadata).encode())}
+
+try:
+    zarr.open_array(store, mode="r")
+except zarr.errors.UnknownCodecError as e:
+    print(e)
+```
+
+The table lives in [`zarr.registry`](../../api/zarr/registry.md); if you maintain a package that provides a codec, please add it there.
+
+## New Dependency: `msgspec`
+
+Zarr metadata is composed of JSON documents that must comply with various specification documents, e.g. the Zarr V2 and V3 specs. `zarr` should model these JSON documents in a way that's correct, so that we generate interoperable data, and useful for developers, so they can also generate interoperable data. To do that we need to define two things: precise types, and routines for coercing or narrowing input values with unknown shapes into our precise types.
+
+Writing types for JSON data structures has gotten a lot easier in Python with the development of `TypedDict` utility types, but writing a validation function that checks an unknown input against an arbitrary `TypedDict` is arbitrary work. This isn't a hard programming task; rather, it's one that's very easy to mess up, e.g. by omitting an important check, or failing to model a field as optional.
+
+Runtime validation libraries like `pydantic`, `beartype`, and `msgspec` use type annotations to generate runtime type checking routines. Using one of these libraries could spare us a lot of hand-written type checking code. We have long discussed adding a runtime type checker to `zarr`, and as of 3.4.0 we are now using [`msgspec`](https://github.com/msgspec/msgspec) in this capacity ([#4063](https://github.com/zarr-developers/zarr-python/pull/4063), resolving [#3285](https://github.com/zarr-developers/zarr-python/issues/3285)). We chose `msgspec` because of its performance and minimal dependency count, and we expect it to deliver big value whenever we introduce new codecs, chunk grids, or data types to `zarr`, as we can just define the type for the metadata and get a validation routine for free.
+
+## Tell us what you think
+
+As always, we would love any and all feedback about the work highlighted in this release! We would especially appreciate feedback from Python users who work with Zarr data and **don't** use the `zarr` package, since we are hoping to target their needs with our new family of subpackages.
+
+## Contributors
+
+Thanks to everyone who contributed to this release (`*` marks a first-time contributor to Zarr-Python):
+
+- [@arcusbuilds](https://github.com/arcusbuilds) *
+- [@cucuwang](https://github.com/cucuwang) *
+- [@d-v-b](https://github.com/d-v-b)
+- [@dylanpulver](https://github.com/dylanpulver) *
+- [@glaziermag](https://github.com/glaziermag) *
+- [@jhamman](https://github.com/jhamman)
+- [@JOhnsonKC201](https://github.com/JOhnsonKC201) *
+- [@paraseba](https://github.com/paraseba)
+- [@selmanozleyen](https://github.com/selmanozleyen)
+- [@sheikhayaan](https://github.com/sheikhayaan) *
+- [@Tomatokeftes](https://github.com/Tomatokeftes) *
+- [@vup903](https://github.com/vup903) *
+
+__Our [previous blog post](3.3.0-release.md) omitted the contributor list, so we've updated that post to include one.__
+
+!!! info "AI Usage Disclaimer"
+
+    The outline for this post was generated by Claude Fable after prompting with the set of unreleased changes since 3.3.0. That outline was then heavily expanded by @d-v-b, introducing a large number of typographical errors. Those errors were removed, code snippets added, and hyperlinks resolved, by Claude.
diff --git a/docs/contributing.md b/docs/contributing.md
index 369e60110a..45e401e064 100644
--- a/docs/contributing.md
+++ b/docs/contributing.md
@@ -80,19 +80,52 @@ git remote add upstream git@github.com:zarr-developers/zarr-python.git
 
 ### Creating a development environment
 
-To work with the Zarr source code, it is recommended to use [hatch](https://hatch.pypa.io/latest/index.html) to create and manage development environments. Hatch will automatically install all Zarr dependencies using the same versions as are used by the core developers and continuous integration services. Assuming you have a Python 3 interpreter already installed, and you have cloned the Zarr source code and your current working directory is the root of the repository, you can do something like the following:
+The root `Justfile` defines development and CI commands. [just](https://just.systems/)
+runs these commands, while [Hatch](https://hatch.pypa.io/latest/index.html) manages
+the Python environments declared in `pyproject.toml`. Install
+[uv](https://docs.astral.sh/uv/getting-started/installation/) first, then the two task
+tools. `uv tool install` puts them in their own environments, which a plain `pip install`
+cannot do on a Python that marks itself externally managed (Debian, Ubuntu, Homebrew):
 
 ```bash
-pip install hatch
-hatch env show  # list all available environments
+uv tool install hatch==1.16.5
+uv tool install rust-just==1.58.0   # or any option from https://just.systems/man/en/packages.html
+just                 # list available commands
+just envs            # list Python environments
+just setup           # create the default test environment
+just test
 ```
 
-To verify that your development environment is working, you can run the unit tests for one of the test environments, e.g.:
+Test recipes default to `test.py3.12-optional`. Set `HATCH_ENV` to select a different
+interpreter or dependency set, just as CI does. `just gpu` reads `GPU_HATCH_ENV`
+instead, so an exported `HATCH_ENV` cannot silently send GPU tests to an
+environment built without the `gpu` feature, and `just doctest` always runs in the
+`doctest` environment. On Windows, run these commands in
+Git Bash.
 
 ```bash
-hatch env run --env test.py3.12-optional run
+HATCH_ENV=test.py3.13-minimal just test
+HATCH_ENV=min_deps just coverage
+HATCH_ENV=upstream just coverage
+GPU_HATCH_ENV=gputest.py3.12 just gpu
+just test tests/test_array.py -k 'resize and not async'
 ```
 
+Arguments after the recipe name are forwarded to the underlying tool. Use
+`just --show test` to inspect a command. Package-specific commands live in the
+`justfile` inside each package directory. The root recipes delegate to these files,
+so you can also run package commands from the repository root:
+
+```bash
+just zarr-metadata              # list this package's recipes
+just zarr-metadata test
+just zarr-indexing test-tensorstore
+just zarr-http-server docs-check
+```
+
+The package justfile sets the working directory and defines the command and its
+environment. Root recipes forward arguments without duplicating those definitions.
+
 ### Creating a branch
 
 Before you do any new work or submit a pull request, please open an issue on GitHub to report the bug or propose the feature you'd like to add.
@@ -125,10 +158,10 @@ Again, any conflicts need to be resolved before submitting a pull request.
 
 ### Running the test suite
 
-Zarr includes a suite of unit tests. The simplest way to run the unit tests is to activate your development environment (see [creating a development environment](#creating-a-development-environment) above) and invoke:
+Zarr includes a suite of unit tests. The simplest way to run the unit tests is to invoke:
 
 ```bash
-hatch env run --env test.py3.12-optional run
+just test
 ```
 
 All tests are automatically run via GitHub Actions for every pull request and must pass before code can be accepted. Test coverage is also collected automatically via the Codecov service.
@@ -137,46 +170,36 @@ All tests are automatically run via GitHub Actions for every pull request and mu
 
 All code must conform to the PEP8 standard. Regarding line length, lines up to 100 characters are allowed, although please try to keep under 90 wherever possible.
 
-`Zarr` uses a set of git hooks managed by [`prek`](https://github.com/j178/prek), a fast, Rust-based pre-commit hook manager that is fully compatible with `.pre-commit-config.yaml` files. `prek` can be installed locally by running:
-
-```bash
-uv tool install prek
-```
-
-or:
-
-```bash
-pip install prek
-```
+`Zarr` uses a set of git hooks managed by [`prek`](https://github.com/j178/prek), a fast, Rust-based pre-commit hook manager compatible with `.pre-commit-config.yaml`. The recipes pin the prek version: `just lint` and `just hooks` run it through `uvx`, and `just hooks-install` installs it as a persistent `uv tool` so the git hook can find it on later commits.
 
 The hooks can be installed locally by running:
 
 ```bash
-prek install
+just hooks-install
 ```
 
 This will run the checks every time a commit is created locally. The checks will by default only run on the files modified by a commit, but the checks can be triggered for all the files by running:
 
 ```bash
-prek run --all-files
+just lint
 ```
 
 You can also run hooks only for files in a specific directory:
 
 ```bash
-prek run --directory src/zarr
+just hooks run --directory src/zarr
 ```
 
 Or run hooks for files changed in the last commit:
 
 ```bash
-prek run --last-commit
+just hooks run --last-commit
 ```
 
 To list all available hooks:
 
 ```bash
-prek list
+just hooks list
 ```
 
 If you would like to skip the failing checks and push the code for further discussion, use the `--no-verify` option with `git commit`.
@@ -188,7 +211,7 @@ If you would like to skip the failing checks and push the code for further discu
 Zarr strives to maintain 100% test coverage under the latest Python stable release. Both unit tests and docstring doctests are included when computing coverage. Running:
 
 ```bash
-hatch env run --env test.py3.12-optional run-coverage
+just coverage
 ```
 
 will automatically run the test suite with coverage and produce an XML coverage report. This should be 100% before code can be accepted into the main code base.
@@ -196,7 +219,7 @@ will automatically run the test suite with coverage and produce an XML coverage
 You can also generate an HTML coverage report by running:
 
 ```bash
-hatch env run --env test.py3.12-optional run-coverage-html
+just coverage-html
 ```
 
 When submitting a pull request, coverage will also be collected across all supported Python versions via the Codecov service, and will be reported back within the pull request. Codecov coverage must also be 100% before code can be accepted.
@@ -210,15 +233,17 @@ Zarr uses mkdocs for documentation, hosted on readthedocs.org. Documentation is
 The documentation can be built locally by running:
 
 ```bash
-hatch --env docs run build
+just docs-build
 ```
 
+`just docs-check` also runs the documentation source checks used in CI.
+
 The resulting built documentation will be available in the `site` folder.
 
-Hatch can also be used to serve continuously updating version of the documentation during development at [http://127.0.0.1:8000/](http://127.0.0.1:8000/). This can be done by running:
+`just docs-serve` serves a continuously updating version of the documentation during development at [http://127.0.0.1:8000/](http://127.0.0.1:8000/). This can be done by running:
 
 ```bash
-hatch --env docs run serve
+just docs-serve
 ```
 
 #### Adding executable code blocks in the documentation
@@ -320,10 +345,10 @@ Sometimes, you may want the documentation to build quicker. You can disable code
 
 ### Changelog
 
-zarr-python uses [towncrier](https://towncrier.readthedocs.io/en/stable/tutorial.html) to manage release notes. Most pull requests should include at least one news fragment describing the changes. To add a release note, you'll need the GitHub issue or pull request number and the type of your change (`feature`, `bugfix`, `doc`, `removal`, `misc`). With that, run `towncrier create` with your development environment, which will prompt you for the issue number, change type, and the news text:
+zarr-python uses [towncrier](https://towncrier.readthedocs.io/en/stable/tutorial.html) to manage release notes. Most pull requests should include at least one news fragment describing the changes. To add a release note, you'll need the GitHub issue or pull request number and the type of your change (`feature`, `bugfix`, `doc`, `removal`, `misc`). With that, run `just changelog`, which will prompt you for the issue number, change type, and the news text:
 
 ```bash
-towncrier create
+just changelog
 ```
 
 Alternatively, you can manually create the files in the `changes` directory using the naming convention `{issue-number}.{change-type}.md`.
@@ -437,6 +462,18 @@ Features in `zarr.experimental` carry no stability guarantees. They may be chang
 Zarr uses [pytest-benchmark](https://pytest-benchmark.readthedocs.io/en/latest/) for running
 performance benchmarks as part of our test suite. The benchmarks are found in `tests/benchmarks`.
 By default pytest is configured to run these benchmarks as plain tests (i.e., no benchmarking). To run
-a benchmark with timing measurements, use the `--benchmark-enable` when invoking `pytest`.
+a benchmark with timing measurements, run `just benchmark`. Pass pytest arguments
+to select benchmarks, for example `just benchmark -k test_morton_order`.
 
 The benchmarks are run as part of the continuous integration suite through [codspeed](https://app.codspeed.io/zarr-developers/zarr-python).
+
+## Building distributions and maintaining dependencies
+
+`just just-check` verifies that the root `Justfile` and each package `justfile` are
+formatted the way CI expects; `just --fmt` rewrites them in place if it complains.
+
+Run `just build` to produce a source distribution and wheel in `dist/`.
+Use `just lock-check` to check the dependency lockfile, or `just lock` to update it.
+`just typecheck` runs the type checker independently of the other lint hooks.
+Preview release notes with `just changelog-draft`; use `just check-changelogs`
+to validate fragment names, optionally passing a package's `changes/` directory.
diff --git a/docs/release-notes.md b/docs/release-notes.md
index 3b54ea993a..a00cc8b7d6 100644
--- a/docs/release-notes.md
+++ b/docs/release-notes.md
@@ -4,6 +4,188 @@
 
 <!-- towncrier release notes start -->
 
+## 3.4.0 (2026-09-15)
+
+### Features
+
+- JSON metadata validation now delegates to ``msgspec.convert`` for the type
+  coercions it supports (``Literal`` membership, ``int`` / ``bool`` strictness,
+  list-to-tuple), replacing the per-field hand-written ``parse_*`` logic.
+  User-defined attributes retain their existing JSON handling.
+  A latent generator-exhaustion bug in
+  ``parse_storage_transformers`` is also fixed. See #3285.
+
+    As a result some metadata inputs are now parsed more strictly. The previous
+    per-field checks compared values with ``==``, which accepts any numerically
+    equal object, so a float such as ``2.0`` was accepted as ``zarr_format``; it is
+    now rejected because it is not an ``int``. Booleans are likewise no longer
+    accepted where an ``int`` is expected, since ``bool`` is an ``int`` subclass.
+    Metadata that conforms to the Zarr specification is unaffected. ([#4063](https://github.com/zarr-developers/zarr-python/pull/4063))
+
+- `zarr.registry.get_codec_class` now raises `zarr.errors.UnknownCodecError` instead of `KeyError`
+  when no implementation is registered for a codec, and `zarr.core.config.BadConfigError` instead of
+  `KeyError` when the implementation named in `config["codecs"][name]` is not registered.
+  `zarr.registry.get_numcodec` raises `UnknownCodecError` instead of the `ValueError` numcodecs
+  raises for an unregistered Zarr format 2 codec id (`numcodecs.errors.UnknownCodecError` on
+  numcodecs 0.15.1 and later). All of these are subclasses of `ValueError`, so `except ValueError`
+  is unaffected, but `except KeyError` and `except numcodecs.errors.UnknownCodecError` are.
+
+    These errors now name Python packages known to provide the codec, so that a user who cannot read
+    an array learns what to install:
+
+    ```text
+    An implementation for codec 'wavpack' is not available. Register one explicitly using the codec
+    registry (see ...), or install a Python package that registers a codec implementation with
+    numcodecs. Known packages supporting this codec: wavpack-numcodecs.
+    ```
+
+    The tables covering this live in `src/zarr/registry.py`, one per Zarr format, and include the
+    codecs `numcodecs` gates behind its own optional dependencies (`zfpy`, `pcodec`, `crc32c`,
+    `msgpack2`). Codec authors can add their published package to them.
+
+    A codec whose `from_dict` raises `KeyError` on a malformed configuration now surfaces as
+    `zarr.errors.MetadataValidationError` naming the codec and the missing key. Previously it was
+    reported as `UnknownCodecError: Unknown codec: '<configuration key>'`, presenting a configuration
+    key as though it were a codec name, and on the `zarr.open` path a bare `KeyError` could be
+    swallowed by the array-then-group fallback and reported as an unrelated group error.
+
+    `zarr.errors.UnknownCodecError` is now exported from `zarr.errors`. ([#4277](https://github.com/zarr-developers/zarr-python/pull/4277))
+
+- `zarr.create_array`, `Group.create_array`, `zarr.from_array`, and the entry points built on them now accept a numpy array as the `chunks` or `shards` specification, alongside ints, tuples, and numpy integer scalars. This is new for that API: it has never accepted numpy arrays in any 3.x release, because each entry point compared the specification to the `"auto"` or `"keep"` sentinel string before normalizing it, and for a numpy array that comparison raised numpy's ambiguous-truth-value `ValueError`. Those sentinel checks are now guarded so array-like specifications reach the normalizer, bringing this API in line with the legacy `zarr.create` / `zarr.array` / `zarr.open_array` functions, which have accepted numpy arrays since 2.x. ([#4329](https://github.com/zarr-developers/zarr-python/pull/4329))
+
+### Bugfixes
+
+- Array creation is now O(1) in the number of chunks per dimension. Chunk
+  normalization returns a `ChunkGrid` whose uniform dimensions are stored as a
+  size + extent pair (`FixedDimension`) instead of being expanded to one entry
+  per chunk, so creating arrays like
+  `zarr.create_array(store, shape=(2**62,), chunks=(1,), dtype='int32')` succeeds
+  instantly instead of raising `ValueError` or allocating gigabytes of memory.
+  The intermediate `ChunksTuple` representation was removed in the process, and
+  `ChunksLike` now admits per-dimension specs that mix a bare int (uniform chunk
+  size) with explicit edge-length sequences, matching what the normalizer and
+  the rectilinear grid spec already accepted.
+  This fixes the array-creation half of #4174; the coordinate-selection
+  allocation reported there is still tracked in that issue (#4172 fixed the
+  related case of sorted 1-D coordinate selections). ([#4218](https://github.com/zarr-developers/zarr-python/pull/4218))
+- Allow `Group.require_array` to accept a `ZDType` for `dtype`, matching the other array creation methods. Previously an existing array could only be required with a string or NumPy dtype. ([#4189](https://github.com/zarr-developers/zarr-python/pull/4189))
+- Consolidated metadata is now reconstructed independently of the order the keys appear in on disk. Previously, sibling subtrees whose keys were not adjacent in the persisted mapping lost their children, which made nodes unreachable through consolidated metadata -- most visibly for sibling groups whose names differ only by case. ([#4227](https://github.com/zarr-developers/zarr-python/pull/4227))
+- `FsspecStore.from_mapper` and `FsspecStore.from_url` no longer fail when converting a synchronous instance of an async-capable filesystem whose storage options contain objects that cannot be serialized to JSON (e.g. an `azure.identity.DefaultAzureCredential`). The async instance is now constructed from the original filesystem arguments instead of a JSON round-trip. ([#4239](https://github.com/zarr-developers/zarr-python/pull/4239))
+- Numpy integers are accepted as chunk sizes again. Since 3.3.0 a per-dimension chunk size that was a numpy integer (e.g. `chunks=(np.int64(2), np.int64(2))`, as produced by any computed chunk shape) raised `TypeError: 'numpy.int64' object is not iterable`, because the scalar chunk path narrowed on `int` while its caller dispatched on `numbers.Integral`. The same regression had broken numpy arrays as chunk specifications through the legacy `zarr.create` / `zarr.array` / `zarr.open_array` functions, which accepted them in 2.x and 3.2.x; those work again. (`zarr.create_array` and the functions built on it gain numpy-array support separately, in #4329.) A chunk specification that is neither an integer nor iterable now reports the offending value instead of failing with an opaque iteration error. ([#4257](https://github.com/zarr-developers/zarr-python/pull/4257))
+- The `cast_value` codec now requires `cast-value-rs>=0.4.2`. Earlier versions of that backend silently corrupted data when handed an array that was not row-major — the layout the `transpose` codec produces — so a `cast_value` codec next to a `transpose` codec would either write transposed values with no error or fail with `ValueError: Input array must be contiguous`. The minimum version is enforced at runtime as well as in the package metadata, so an environment that already has an older `cast-value-rs` installed now raises `ImportError` when the codec is used, instead of corrupting data. ([#4260](https://github.com/zarr-developers/zarr-python/pull/4260))
+- Accept [universal-pathlib](https://github.com/fsspec/universal_pathlib) `UPath` objects wherever
+  zarr accepts a `StoreLike` value. A remote `UPath` now creates an `FsspecStore` using the
+  filesystem and storage options the `UPath` already carries, and a local `UPath` creates a
+  `LocalStore`, so that `UPath('/data')` and `Path('/data')` behave the same.
+
+    Previously this worked only by accident: in universal-pathlib < 0.3 every `UPath` subclassed
+    `pathlib.Path` and implemented `__fspath__`, so remote paths were either converted to a URI string
+    by the caller or wrapped in a `LocalStore` that happened to dispatch through fsspec. Since
+    universal-pathlib 0.3 remote paths do neither, and passing one raised
+    `TypeError: Unsupported type for store_like`.
+
+    `FsspecStore.from_upath` also now converts the `UPath`'s filesystem to async mode, instead of
+    raising `TypeError` for synchronous filesystems and warning for sync-mode instances of async ones. ([#4265](https://github.com/zarr-developers/zarr-python/pull/4265))
+
+- Explicit per-chunk size lists now always produce a rectilinear chunk grid,
+  even when the sizes happen to describe a regular grid (all equal, or all equal
+  with a smaller trailing chunk). Previously such input was silently collapsed to
+  a regular grid, which changed resize semantics: a regular grid grows by
+  extending the uniform pattern, while a rectilinear grid appends a new edge
+  chunk — the behavior an append-oriented layout like `(168,) * 13 + (24,)`
+  relies on. The grid kind now follows the input syntax, matching 3.2.x:
+  scalar chunk sizes (including numpy integers and the `-1` sentinel) produce a
+  regular grid, nested sequences produce a rectilinear grid. Rectilinear grids
+  remain gated behind `zarr.config.set({"array.rectilinear_chunks": True})`.
+  See #4174 for the accompanying O(1) chunk normalization change.
+
+    One consequence for users who never enable rectilinear chunks: because a
+    nested sequence now always requests a rectilinear grid, a per-dimension
+    sequence of edge lengths that happens to be uniform — for example the
+    `((4,), (4,))` or `[[3, 3, 1]]` form that a dask array's `.chunks` attribute
+    produces — is no longer quietly accepted as a regular grid when the
+    `array.rectilinear_chunks` option is off. Such input raises
+    `ValueError: Rectilinear chunk grids are experimental and disabled by default`,
+    exactly as it did in 3.2.x; the silent acceptance existed only in 3.3.0. Pass
+    one integer per dimension (e.g. `chunks=(4, 4)`, or a dask array's
+    `.chunksize`) to request a regular grid.
+
+    `zarr.from_array` with the default `chunks="keep"` / `shards="keep"` now
+    reproduces the source's stored grid exactly: a rectilinear grid is passed
+    through in O(number of dimensions), with uniform dimensions keeping their
+    bare-int shorthand; sharding under a rectilinear shard grid is preserved
+    instead of being silently dropped; and the default `write_data=True` copy
+    works for every grid kind. `Array.chunks` is now defined for any sharded array
+    (the inner chunks of a shard are always regular), and for sharded arrays with
+    a rectilinear shard grid `Array.info` no longer raises — it reports the shard
+    shape as `<variable>` — while `Array.nchunks_initialized` counts the chunks of
+    each initialized shard individually instead of raising.
+
+    Apart from the nested-sequence input form noted above, everything described
+    here concerns rectilinear chunk grids, which remain an experimental feature
+    gated behind `zarr.config.set({"array.rectilinear_chunks": True})`; arrays
+    with regular chunk grids are unaffected. ([#4218](https://github.com/zarr-developers/zarr-python/pull/4218))
+
+- A `scale_offset` codec configured with a string-valued zero scale is now rejected. `scale` accepts strings, and no string is ever equal to `0`, so `"0"`, `"0.0"` and the hex form `"0x0000000000000000"` skipped the "scale must be non-zero" check that the numeric `0` triggers. On float data types the array was created, every chunk was written as zero and read back as `nan` with no error, and the zero scale was persisted to the metadata so reopening the store reproduced it; on integer data types the codec raised `ZeroDivisionError` instead of `ValueError`. The check now runs on the parsed scalar rather than the value as supplied. ([#4279](https://github.com/zarr-developers/zarr-python/pull/4279))
+- Fixed a `ValueError` when setting an orthogonal selection on a sharded array where more than one dimension is indexed by an array. The sharding codec re-derives an indexer from the chunk selection it is handed, which turns such a selection into a coordinate selection addressing the value buffer flat, so the write failed on a shape mismatch. Both partial-encode paths are fixed, so the write works under either codec pipeline. ([#4284](https://github.com/zarr-developers/zarr-python/pull/4284))
+- Fixed integer array indexing with unsigned index dtypes. An unsorted index such as
+  `np.array([3, 0], dtype="uint8")` spanning more than one chunk raised `IndexError`, because
+  the order check used `np.diff`, which wraps on unsigned dtypes and misclassified a
+  descending selection as increasing. Separately, a `uint64` index raised `IndexError` on both
+  `array[...]` and `array.vindex[...]` — sorted or not — because `uint64` promotes to
+  `float64` against a signed chunk offset. Index arrays are now cast to `intp`.
+
+    Unsigned indices are bounds-checked before this conversion, so values such as
+    `np.uint64(2**64 - 1)` are rejected rather than wrapping to a negative index and
+    reading or overwriting an element at the end of the array.
+
+    Negative-index normalization copies indices before modifying them, preserving
+    caller-owned arrays and supporting read-only index arrays. Reusing one index
+    array across axes of different lengths now normalizes each axis independently. ([#4286](https://github.com/zarr-developers/zarr-python/pull/4286))
+
+- `zarr.from_array` now defaults to the fill value and the attributes of the source array. Previously both were silently discarded: the array was created with the data type's default scalar and no attributes.
+
+    An explicit `fill_value=None` now selects the data type's default scalar (Zarr format 3) or a null fill value (Zarr format 2), consistently with `create_array`, and an empty `attributes` dict creates the array with no attributes. ([#4288](https://github.com/zarr-developers/zarr-python/pull/4288))
+
+- Fixed an infinite loop when creating a 0-dimensional array with `shards="auto"` while the `array.target_shard_size_bytes` config option is set. Such arrays now resolve to `shards=()`, matching the behavior when no shard size target is configured. ([#4305](https://github.com/zarr-developers/zarr-python/pull/4305))
+- Fixed `chunks=-1` on a zero-length axis resolving to an invalid chunk size of 0, which caused a `ValueError`, `ZeroDivisionError`, or infinite loop depending on the sharding configuration. Such axes now get chunk size 1, matching `chunks="auto"`. ([#4307](https://github.com/zarr-developers/zarr-python/pull/4307))
+- Fixed a `ValueError` when setting an orthogonal selection on a sharded array that mixes an integer index with two or more array indices, such as `a.oindex[[3, 1, 2], 1, [0, 2]] = value`. The fix for the array-only case in #4284 reshaped the value only when its shape matched the coordinate selection exactly; the sharding codec now also ravels a value that is the selection's shape minus the integer-indexed axes. Values of any other rank are left alone, so a write that is invalid on an unsharded array fails the same way on a sharded one. Both partial-encode paths share one helper for this. ([#4316](https://github.com/zarr-developers/zarr-python/pull/4316))
+- Opening a Zarr format 3 array whose codec's ``from_dict`` raised a ``KeyError`` with no arguments used to fail with an unrelated ``IndexError: tuple index out of range`` while formatting the error message. Because that ``IndexError`` is not a ``ValueError``, it also escaped the array-then-group fallback in ``zarr.open`` and broke group operations such as ``Group.members()`` and ``"child" in group`` when any child array used such a codec. The ``KeyError`` is now always reported as a ``MetadataValidationError`` naming the codec, with the offending key included only when the ``KeyError`` carried one. ([#4324](https://github.com/zarr-developers/zarr-python/pull/4324))
+- `zarr.from_array` now deep-copies the source array's attributes instead of sharing nested dicts and lists between the source and the new array. Previously, mutating a nested attribute on the new array (for example ``dst.attrs["meta"]["tags"].append(...)``) silently changed the source array's in-memory attributes too. Deeply nested attributes can raise `RecursionError` during the copy even if they can be stored and reopened; the threshold depends on Python's recursion limit and call stack. Pass `attributes={}` to omit inherited attributes. ([#4325](https://github.com/zarr-developers/zarr-python/pull/4325))
+- Fixed `chunks=False` on a zero-length axis resolving to a chunk size of 0, which raised a `ValueError` for Zarr format 3, raised a `ZeroDivisionError` with `shards="auto"`, and silently wrote invalid `chunks` metadata for Zarr format 2. `False` now takes the same path as `chunks=-1`, so such axes get chunk size 1, matching `chunks="auto"`. ([#4328](https://github.com/zarr-developers/zarr-python/pull/4328))
+- `from_array` preserves a Zarr source's explicit data type instead of trying to infer it from its NumPy dtype, allowing variable-length bytes arrays to be copied. ([#4335](https://github.com/zarr-developers/zarr-python/pull/4335))
+- The documentation build and the documentation test suite no longer delete a `data/` directory relative to the current working directory. Two executable docs sessions opened with `shutil.rmtree('data', ignore_errors=True)` to make their examples re-runnable; because executed docs blocks run in the process working directory rather than the docs tree, `mkdocs build -f <repo>/mkdocs.yml` or `pytest tests/test_docs.py` started from any directory containing a `data/` folder — a project checkout, or `/` — silently emptied it. The sdist ships `docs/` and `tests/` and `testpaths` collects `docs/user-guide`, so this reached anyone running the shipped test suite, not only contributors. The deletions are gone; the on-disk examples in the quick start, arrays, groups, storage and performance guides now create with `overwrite=True` (or `zarr.save_array(..., mode="w")`), which is also what a reader re-running an example needs, and a new docs test rejects any executed block that calls a filesystem deletion. ([#4339](https://github.com/zarr-developers/zarr-python/pull/4339))
+- Missing Zarr format 3 imagecodecs now name `imagecodecs-zarr` as a known provider, alongside `virtual-tiff` where both packages register the codec. ([#4351](https://github.com/zarr-developers/zarr-python/pull/4351))
+- `LocalStore` now retries the rename that publishes a written file when Windows
+  reports the destination as transiently busy (`ERROR_ACCESS_DENIED` or
+  `ERROR_SHARING_VIOLATION`). Replacing a name that was itself replaced moments
+  earlier intermittently fails this way in a single process, which aborted
+  otherwise ordinary writes. The retry is bounded to well under a second, is a
+  no-op off Windows, and never retries the `FileExistsError` that the `exclusive`
+  path uses to report an existing node. This mitigates but does not fully resolve
+  #3522: a second process holding the destination open for longer than the retry
+  budget will still fail. Zarr v2 had the equivalent retry from #698 and it was
+  not carried over when atomic writes arrived in #3412. ([#4358](https://github.com/zarr-developers/zarr-python/pull/4358))
+
+### Improved Documentation
+
+- Added a Roadmap page to the documentation outlining future plans and intended changes to the library. ([#4149](https://github.com/zarr-developers/zarr-python/pull/4149))
+- Converted remaining reStructuredText-style double-backtick markup to Markdown
+  single backticks in the docstrings of `zarr.api.asynchronous`,
+  `zarr.api.synchronous`, `zarr.core.array`, `zarr.registry`, and
+  `zarr.storage._common`. No functional changes. ([#4193](https://github.com/zarr-developers/zarr-python/pull/4193))
+- Document how to reassign Read the Docs version slugs when publishing a subpackage release. ([#4236](https://github.com/zarr-developers/zarr-python/pull/4236))
+- Added a "Related Projects" page to the documentation listing the companion
+  packages developed in this repository — `zarr-metadata` and `zarr-indexing` —
+  and linked it from the landing page. Links to those packages now use the
+  canonical `https://zarr.readthedocs.io/projects/...` URLs, and each companion
+  package's documentation links back to the `zarr-python` docs. ([#4247](https://github.com/zarr-developers/zarr-python/pull/4247))
+
+### Misc
+
+- [#4213](https://github.com/zarr-developers/zarr-python/pull/4213), [#4261](https://github.com/zarr-developers/zarr-python/pull/4261), [#4326](https://github.com/zarr-developers/zarr-python/pull/4326), [#4331](https://github.com/zarr-developers/zarr-python/pull/4331)
+
+
 ## 3.3.0 (2026-07-30)
 
 ### Features
@@ -156,7 +338,7 @@
 - Clarify the difference between `zarr.load` and `zarr.open` in their docstrings.
   `load` eagerly reads data into an in-memory array, while `open` returns a
   lazy `Array` or `Group` backed by the store, with `See Also` cross-references
-  linking the two. ([#3984](https://github.com/zarr-developers/zarr-python/pull/3984))
+  linking the two. ([31817c68](https://github.com/zarr-developers/zarr-python/commit/31817c68))
 - Updated the custom dtype example in `examples/custom_dtype/custom_dtype.py` to
   use only the public API, eliminating all non-public imports, illustrating what
   users should do.
diff --git a/lychee.toml b/lychee.toml
index dccb3001dc..9bb9be5caf 100644
--- a/lychee.toml
+++ b/lychee.toml
@@ -16,7 +16,7 @@ exclude_path = [
 
 # URL patterns to ignore (regex, matched against the full URL).
 exclude = [
-  # Local docs preview server shown in the contributing guide ("hatch run serve"),
+  # Local docs preview server shown in the contributing guide ("just docs-serve"),
   # documentation of a command rather than a reachable link.
   '^https?://0\.0\.0\.0',
   '^https?://(localhost|127\.0\.0\.1)(:\d+)?',
diff --git a/packages/zarr-http-server/README.md b/packages/zarr-http-server/README.md
index 53df0d2f50..c68f2c9ed2 100644
--- a/packages/zarr-http-server/README.md
+++ b/packages/zarr-http-server/README.md
@@ -30,7 +30,7 @@ store = zarr.storage.MemoryStore()
 array = zarr.create_array(store, shape=(100,), chunks=(10,), dtype="float64")
 
 with serve_background(node_app(array)) as server:
-    print(server.url)   # e.g. http://127.0.0.1:8000
+    print(server.url)  # e.g. http://127.0.0.1:8000
 ```
 
 Building an app and running it are separate steps, and either app works with
diff --git a/packages/zarr-http-server/justfile b/packages/zarr-http-server/justfile
index d65b1b53b7..5daac00ebc 100644
--- a/packages/zarr-http-server/justfile
+++ b/packages/zarr-http-server/justfile
@@ -10,6 +10,9 @@
 # newest release: when ruff 0.16 began selecting BLE001 under the root
 # config's `B` prefix, this job failed on rules the pinned ruff never enforced,
 # with no code change to blame. Bump alongside the pre-commit rev.
+# Quoted arguments must survive delegation from the root Justfile.
+set positional-arguments
+
 ruff_version := "0.16.0"
 
 # List available recipes
@@ -21,7 +24,7 @@ default:
 # silently skipping.
 # Run the test suite; extra args are passed to pytest
 test *args:
-    uv run --group test --group examples pytest tests {{ args }}
+    uv run --group test --group examples pytest tests "$@"
 
 # Lint the package sources and tests
 lint:
diff --git a/packages/zarr-indexing/CONTRIBUTING.md b/packages/zarr-indexing/CONTRIBUTING.md
index 632e24929f..bcbe51c079 100644
--- a/packages/zarr-indexing/CONTRIBUTING.md
+++ b/packages/zarr-indexing/CONTRIBUTING.md
@@ -8,16 +8,16 @@ just test        # run the test suite (extra args go to pytest)
 just lint        # ruff, same invocation as CI
 just typecheck   # pyright, same invocation as CI
 just docs-check  # strict build of the docs site
-just check       # all of the above
+just check       # the checks above plus TensorStore parity
 just docs-serve  # serve the docs site locally
 ```
 
-Run them from this directory, or from anywhere in the repository as
+Run them from this directory, or from the repository root as
 `just packages/zarr-indexing/<recipe>`.
 
-The test recipe runs against the workspace-root environment, because the
-chunk-resolution tests exercise this package against `zarr`'s chunk grids and
-`zarr` is deliberately not a dependency of this package.
+The test recipe layers this package into the repository-root environment.
+Chunk-resolution tests use this package’s own grids; the Dask example also
+uses `zarr`, which is not a dependency of the base indexing package.
 
 ## License
 
diff --git a/packages/zarr-indexing/README.md b/packages/zarr-indexing/README.md
index 4328de1cc1..2d75402664 100644
--- a/packages/zarr-indexing/README.md
+++ b/packages/zarr-indexing/README.md
@@ -5,19 +5,22 @@ Composable, lazy coordinate transforms for Zarr array indexing.
 Documentation: <https://zarr-indexing.readthedocs.io/>
 
 This package implements TensorStore-inspired index transforms. The core idea:
-every indexing operation (slicing, fancy indexing, etc.) produces a coordinate
-mapping from user space to storage space. These mappings compose lazily — no
-I/O until you explicitly read or write.
+each supported indexing operation (slicing, fancy indexing, etc.) produces a coordinate
+mapping from user space to storage space. These mappings compose without reading selected source values. `LazyArray`
+materializes them on request; the transform algebra itself performs no source I/O.
 
 Key types:
 
-- `LazyArray` — wraps a system-memory/basic-indexing source and adds a `.lazy`
-  accessor: `LazyArray.from_numpy(numpy_array).lazy[10:50, ::2].lazy.oindex[[3, 1, 1], :]`
+- `LazyArray` — wraps a system-memory/basic-indexing source with lazy indexing:
+  `LazyArray.from_numpy(numpy_array)[10:50, ::2].oindex[[3, 1, 1], :]`.
+  The key's type picks the frame: NumPy keys are positions relative to the
+  view, while an `IndexDomain` or `IndexTransform` key addresses the view's
+  absolute domain, which every view keeps.
   composes a transform and returns a new view without reading data, and
   `result()` materializes it into owned system memory. `LazyArray(source)` uses
-  the conservative basic reader; `from_numpy` explicitly selects NumPy's
-  optimized reader. Device arrays require an explicit custom reader responsible
-  for transferring values into the supplied system-memory output buffer.
+  the basic reader; `from_numpy` selects `numpy_reader`, which currently uses
+  the same slab-and-gather implementation. Device sources that refuse NumPy
+  conversion need a custom reader to transfer values into the output buffer.
 - `Reader` — the explicit backend execution boundary: transforms say which
   values belong in the result, while readers say how a backend obtains them
 - `IndexDomain` — a rectangular region of integer coordinates
@@ -32,9 +35,11 @@ Key types:
   dimension can depend on the input
 - `compose` — chain two transforms into one
 
-The package depends only on NumPy and the standard library; it does not import
-`zarr`. It is developed in the [zarr-python](https://github.com/zarr-developers/zarr-python)
-repository and consumed by `zarr` to resolve array indexing operations.
+The base package depends on NumPy and the standard library; its optional testing
+module also requires Hypothesis. The package does not import `zarr`. It is developed
+in the [zarr-python](https://github.com/zarr-developers/zarr-python) repository,
+and its examples include reading Zarr arrays through Dask. Installing it does not
+replace Zarr's indexing implementation.
 
 ## Installation
 
diff --git a/packages/zarr-indexing/benchmarks/README.md b/packages/zarr-indexing/benchmarks/README.md
index 28ef3e6a16..e5d39b1a89 100644
--- a/packages/zarr-indexing/benchmarks/README.md
+++ b/packages/zarr-indexing/benchmarks/README.md
@@ -22,6 +22,19 @@ whether input arrays and transform construction are included. Repeated local
 column access measures cache reuse, which trades allocation against retained
 memory. Bounded coordinate batches avoid constructing the full coordinate array.
 
+The current script reports `peak_mib` as the incremental peak tracked by
+`tracemalloc` during a separate invocation after the timed calls. It is not
+process RSS or total retained memory. Inputs and most transforms are constructed
+before measurement. The case walks construct plans and consume projections
+without retaining them; `all_coordinates` materializes the complete coordinate
+array. There is no bounded-batch coordinate workload in this script.
+
+`local_rows` reuses one prepared table: its first timed invocation populates the
+local-coordinate cache, while later timed invocations and the allocation probe
+reuse that cache. Its median mixes a cold first call with warm calls, and its
+reported peak excludes the already-retained cache. A separate fresh-table
+measurement would be needed to quantify cold cache construction.
+
 These scripts measure planning rather than codec or storage throughput. Repeat
 measurements with alternating operation order before interpreting small timing
 differences. Preserve raw benchmark output as an experiment artifact rather than
diff --git a/packages/zarr-indexing/benchmarks/chunk_planning.py b/packages/zarr-indexing/benchmarks/chunk_planning.py
index 934d68dcbc..d7eadf248d 100644
--- a/packages/zarr-indexing/benchmarks/chunk_planning.py
+++ b/packages/zarr-indexing/benchmarks/chunk_planning.py
@@ -25,6 +25,11 @@
 
 
 def measure(operation: Callable[[], Any], repeats: int) -> dict[str, float]:
+    """Time repeated calls, then trace one additional call's incremental peak.
+
+    State retained by earlier calls can affect the extra call; this is not a
+    measurement of process RSS or all memory owned by the operation's inputs.
+    """
     samples = []
     for _ in range(repeats):
         start = time.perf_counter()
@@ -84,6 +89,8 @@ def read_local_rows() -> None:
         for row in range(len(table)):
             table.local[table.run(row)]
 
+    # The first timed call fills table.local; later calls, including the traced
+    # allocation probe, reuse it. The table and retained cache are not re-created.
     results["local_rows"] = measure(read_local_rows, args.repeats)
     part = plan_chunks(
         IndexTransform.from_shape((100, 100, 100)),
diff --git a/packages/zarr-indexing/changes/4222.feature.2.md b/packages/zarr-indexing/changes/4222.feature.2.md
index 722f56db99..d89fb98134 100644
--- a/packages/zarr-indexing/changes/4222.feature.2.md
+++ b/packages/zarr-indexing/changes/4222.feature.2.md
@@ -1,13 +1,13 @@
 Added `LazyArray`, which grafts the full NumPy indexing dialect onto any source
 exposing `shape`, `dtype`, and basic integer/slice `__getitem__` — a chunked
-store, an FFI binding, an HTTP endpoint. `view.lazy[...]`, `.lazy.oindex[...]`
-and `.lazy.vindex[...]` each compose an `IndexTransform` and return a new view
-without reading anything; `result()` materializes. Selections use positional
-NumPy semantics (negatives wrap, scalars drop their axis, coordinate arrays keep
-order and duplicates), which the new `zarr_indexing.boundary` module translates
-into the algebra's literal coordinates. The wrapper describes reads only, and
-behaves as a duck array: eager `__getitem__` and `__array__` make it a
-`dask.array.from_array` source.
+store, an FFI binding, an HTTP endpoint. `view[...]`, `view.oindex[...]` and
+`view.vindex[...]` each compose an `IndexTransform` and return a new view
+without reading anything; `result()` and `numpy.asarray(view)` materialize.
+Selections use positional NumPy semantics (negatives wrap, scalars drop their
+axis, coordinate arrays keep order and duplicates), which the new
+`zarr_indexing.boundary` module translates into the algebra's literal
+coordinates. Consumers that need indexing to produce data, such as
+`dask.array.from_array`, wrap a view in `EagerArrayAdapter`.
 
 A read is divided along a **partitioning** — discovered from the wrapped array,
 or chosen with `with_parts` / `with_parts_per_axis` / `unpartitioned`.
diff --git a/packages/zarr-indexing/changes/4345.bugfix.md b/packages/zarr-indexing/changes/4345.bugfix.md
new file mode 100644
index 0000000000..928114728f
--- /dev/null
+++ b/packages/zarr-indexing/changes/4345.bugfix.md
@@ -0,0 +1 @@
+Reject invalid wire index-array values and unrepresentable normalized bounds/ranks, and raise an explicit error for unsupported intersections sharing an affine and lookup input axis instead of returning incorrect coordinates. Group negative chunk-coordinate tuples without merging distinct chunks.
diff --git a/packages/zarr-indexing/changes/4345.doc.md b/packages/zarr-indexing/changes/4345.doc.md
new file mode 100644
index 0000000000..562e114e4e
--- /dev/null
+++ b/packages/zarr-indexing/changes/4345.doc.md
@@ -0,0 +1,3 @@
+Correct indexing, reader, serialization, cache, and integration descriptions to match supported behavior; qualify NumPy/TensorStore compatibility and performance claims.
+
+Describe current contracts in source and test docstrings instead of narrating prior implementations. Clarify that immutable index coordinates do not snapshot source values.
diff --git a/packages/zarr-indexing/changes/4346.misc.md b/packages/zarr-indexing/changes/4346.misc.md
new file mode 100644
index 0000000000..05886fa863
--- /dev/null
+++ b/packages/zarr-indexing/changes/4346.misc.md
@@ -0,0 +1 @@
+Expand planner property tests across signed origins and chunk IDs, custom grids, mixed affine and lookup dependencies, duplicate coordinates, and empty domains. Verify exact request coverage and storage mapping with an independent pointwise oracle.
diff --git a/packages/zarr-indexing/changes/4347.bugfix.md b/packages/zarr-indexing/changes/4347.bugfix.md
new file mode 100644
index 0000000000..b2eea6c071
--- /dev/null
+++ b/packages/zarr-indexing/changes/4347.bugfix.md
@@ -0,0 +1 @@
+Validate inclusive `index_array_bounds` against all raw index values when loading transforms and output maps from JSON. Accept valid finite and one-sided constraints, and reject out-of-bounds values eagerly before offset, stride, or map simplification. Validated immutable maps need not retain the constraints; message normalization preserves the original bounds.
diff --git a/packages/zarr-indexing/changes/4348.bugfix.md b/packages/zarr-indexing/changes/4348.bugfix.md
new file mode 100644
index 0000000000..69a7daf9bc
--- /dev/null
+++ b/packages/zarr-indexing/changes/4348.bugfix.md
@@ -0,0 +1 @@
+Delegate LazyArray source tokenization to Dask, honoring its registered normalizers, source hooks, and deterministic-token requirements. Remove local content-hashing and UUID fallbacks. Dask remains optional for indexing and reading.
diff --git a/packages/zarr-indexing/changes/4349.feature.md b/packages/zarr-indexing/changes/4349.feature.md
new file mode 100644
index 0000000000..7234374987
--- /dev/null
+++ b/packages/zarr-indexing/changes/4349.feature.md
@@ -0,0 +1 @@
+Make every `LazyArray` read supply a chunk projection, including unpartitioned reads and independently executed partition views. Partition views retain the source grid and full source base shape, so indexing and repartitioning use the same coordinate frame as other views.
diff --git a/packages/zarr-indexing/changes/4350.feature.md b/packages/zarr-indexing/changes/4350.feature.md
new file mode 100644
index 0000000000..7b740e9712
--- /dev/null
+++ b/packages/zarr-indexing/changes/4350.feature.md
@@ -0,0 +1,20 @@
+Make `LazyArray` indexing lazy by default: use `view[...]`, `view.oindex[...]`,
+and `view.vindex[...]` directly, without a `.lazy` accessor. Iteration yields
+lazy views, so arithmetic over iterated elements no longer works on values;
+`result()` and NumPy conversion materialize. Add synchronous `write(values)`
+and assignment through composed views, and an explicit `EagerArrayAdapter` for
+consumers such as Dask that require eager indexing.
+
+Writes are planned against the source's write grid, discovered from
+`write_chunk_sizes` or `chunks`: an affine selection is one basic assignment,
+and any other selection reads, updates, and rewrites each touched cell once,
+so storage round trips scale with touched chunks rather than selected
+elements. A source with no advertised grid is written one element at a time.
+Writes bypass the reader, so a caching reader is not invalidated.
+
+Views keep their literal domain instead of re-zeroing after every selection:
+`a[10:20]` has domain `[10, 20)` and `a[10:20][2:5]` has domain `[12, 15)`,
+as in TensorStore, while NumPy keys stay positional. An `IndexDomain` key
+restricts a view to literal coordinates and an `IndexTransform` key composes
+onto it. Box partitions keep the request's coordinates, so a part view's
+domain is a sub-domain of its parent's.
diff --git a/packages/zarr-indexing/changes/4364.misc.md b/packages/zarr-indexing/changes/4364.misc.md
new file mode 100644
index 0000000000..0ae29424bc
--- /dev/null
+++ b/packages/zarr-indexing/changes/4364.misc.md
@@ -0,0 +1,7 @@
+Removed every `assert` statement from the package's runtime code and dropped
+the `zarr-indexing` exemption from the repo-wide ruff `S101` rule, so none can
+return. Asserts are stripped under `python -O`; the ones here narrowed types
+or guarded internal invariants rather than validating input, so most were
+restructured away (branching on the map type, carrying the narrowed value in a
+local) and the remainder became explicit `RuntimeError`s for states the
+public API cannot reach. No user-visible behavior changes.
diff --git a/packages/zarr-indexing/docs/api/eager.md b/packages/zarr-indexing/docs/api/eager.md
new file mode 100644
index 0000000000..e3b10998d8
--- /dev/null
+++ b/packages/zarr-indexing/docs/api/eager.md
@@ -0,0 +1,12 @@
+---
+title: Eager adapter
+---
+
+# Eager adapter
+
+`LazyArray` indexing returns views. Consumers that require indexing to
+produce data, such as `dask.array.from_array`, wrap a view in
+`EagerArrayAdapter`: the adapter reads each indexed block through the view's
+reader and partitioning, while the view itself keeps lazy indexing.
+
+::: zarr_indexing.eager
diff --git a/packages/zarr-indexing/docs/api/grid.md b/packages/zarr-indexing/docs/api/grid.md
index b7c376eb85..012c9df6dc 100644
--- a/packages/zarr-indexing/docs/api/grid.md
+++ b/packages/zarr-indexing/docs/api/grid.md
@@ -11,8 +11,9 @@ objects whose `shape` is the valid data size and whose `codec_shape` preserves
 the full codec-buffer size at a regular-grid boundary.
 
 `dimension_grids_from_chunks` returns these compact dimensions: integer chunk
-shapes become `FixedDimension` instances and explicit per-axis edge sequences
-become `VaryingDimension` instances. `DimensionGridLike` remains the narrow
+shapes become `FixedDimension` instances and positive per-axis edge sequences
+become `VaryingDimension` instances. An empty-axis sequence of zeros (including
+an empty sequence) becomes `FixedDimension(size=0, extent=0)`. `DimensionGridLike` remains the narrow
 protocol used by the chunk planner, while `EdgeDimensionGrid` is kept for
 explicit edge-based and coordinate-origin examples.
 
diff --git a/packages/zarr-indexing/docs/api/index.md b/packages/zarr-indexing/docs/api/index.md
index a5b7163bbd..a5c5498e8d 100644
--- a/packages/zarr-indexing/docs/api/index.md
+++ b/packages/zarr-indexing/docs/api/index.md
@@ -25,12 +25,11 @@ and the wire format built on top of it.
 - [`zarr_indexing.domain`](domain.md) — `IndexDomain`, a rectangular region of
   integer coordinates with an explicit (possibly non-zero) origin
 - [`zarr_indexing.output_map`](output_map.md) — `ConstantMap`, `DimensionMap`,
-  and `ArrayMap`: three representations of a set of integer coordinates, one
-  per storage dimension
+  and `ArrayMap`: three coordinate mappings that preserve order and duplicates,
+  one per storage dimension
 - [`zarr_indexing.transform`](transform.md) — `IndexTransform`, which pairs a
   domain with output maps, plus the indexing (`[...]`, `.oindex`, `.vindex`),
-  `intersect`, and `translate` operations, and `selection_to_transform`
-  transforms into one
+  `intersect`, `translate`, and `compose` operations, and `selection_to_transform`
 
 **Chunk resolution**
 
@@ -49,7 +48,7 @@ and the wire format built on top of it.
 **Lazy arrays**
 
 - [`zarr_indexing.lazy_array`](lazy_array.md) — `LazyArray`, a wrapper for
-  system-memory/basic-indexing sources that adds a `.lazy` accessor for
+  system-memory/basic-indexing sources with lazy indexing for
   TensorStore-style deferred indexing, plus `Partition` and `parts()` /
   `with_parts()`, which determine the boxes a read is broken into. Device
   sources require an explicit custom reader that transfers into the supplied
diff --git a/packages/zarr-indexing/docs/api/lazy_array.md b/packages/zarr-indexing/docs/api/lazy_array.md
index f855511d46..44175476ab 100644
--- a/packages/zarr-indexing/docs/api/lazy_array.md
+++ b/packages/zarr-indexing/docs/api/lazy_array.md
@@ -2,26 +2,46 @@
 title: lazy_array
 ---
 
-`LazyArray.lazy[...]` is metadata-only: every derived view keeps the same
+`LazyArray[...]` is metadata-only: every derived view keeps the same
 reader and composes its transform without reading data. `result()` allocates
 owned system memory, then calls that reader once for each projected part.
 Rectangular parts write directly into their final slices; advanced placement
 may first use an owned dense temporary. `LazyArray(source)` assumes only basic
-indexing, while `LazyArray.from_numpy(array)` explicitly selects NumPy's
-optimized reader.
+indexing, while `LazyArray.from_numpy(array)` selects `numpy_reader`. Both
+currently use the same slab-and-gather implementation.
 
 The built-in readers lower through NumPy system memory and support sources
-whose basic reads can be converted there. They do not implicitly transfer
-device arrays; a device source needs an explicit custom reader that transfers
-into the supplied system-memory output. Derived views and parts share their
+whose basic reads can be converted there. A device source that refuses NumPy
+conversion needs a custom reader that transfers into the output buffer. Derived views and parts share their
 reader and part views may be materialized concurrently, so stateful readers
 must synchronize their own mutable state.
 
-Every public `Partition.view.transform` directly maps that view's zero-origin
+The key's type picks the frame: NumPy keys are relative positions, `IndexDomain`
+and `IndexTransform` keys are absolute, and every view keeps its absolute
+domain. See [the guide](../guide/index.md#the-keys-type-picks-the-frame).
+
+Every public `Partition.view.transform` directly maps that view's own domain
 coordinates into its raw `Partition.view.array`, including for non-first
-partitions. `Partition.projection.chunk_transform` intentionally stays local to
-the selected chunk. During materialization the reader receives both frames in
-one `ReadContext`: the public global transform in `context.transform` and the
-same local plan in `context.projection`.
+partitions; a box part's domain is a sub-domain of the parent view's literal
+domain. `Partition.projection.chunk_transform` intentionally stays local to
+the selected chunk. During parent materialization (`view.result(parts=parts)`) the reader receives
+both frames in one `ReadContext`: the public global transform in `context.transform` and the
+local plan in `context.projection`. Every view retains the source grid and plans
+its reads, so `part.view.result()` also supplies both frames. Its projection's
+result placement is relative to that part view, rather than the parent output.
+Further indexing and repartitioning use the same source-global coordinate frame.
+Even `unpartitioned()` reads carry a projection for the single source-wide cell.
+
+`view[key]`, `view.oindex[key]`, and `view.vindex[key]` return lazy views,
+and iteration yields lazy first-axis views. `result()` and `numpy.asarray(view)`
+materialize values. `view.write(values)` synchronously writes to the original
+source through the composed transform and returns `None`; `view[key] = values`
+writes a selected sub-view. Writes require a writable source.
+
+For consumers requiring eager indexing, import `EagerArrayAdapter` from
+`zarr_indexing` and wrap the view. The adapter delegates shape, rank, dtype,
+NumPy conversion, and tokenization to the view, but materializes each
+`adapter[key]`. Use it with `dask.array.from_array`; direct lazy indexing
+is not a reliable Dask block-read interface.
 
 ::: zarr_indexing.lazy_array
diff --git a/packages/zarr-indexing/docs/api/reader.md b/packages/zarr-indexing/docs/api/reader.md
index 39129c4d47..6cb49afacd 100644
--- a/packages/zarr-indexing/docs/api/reader.md
+++ b/packages/zarr-indexing/docs/api/reader.md
@@ -11,9 +11,14 @@ ownership.
 
 `Reader.read_into(source, context, out)` receives a `ReadContext` whose
 `transform` maps zero-origin output-buffer coordinates to global coordinates in
-`source`, with `context.transform.domain.shape == out.shape`. Its optional
-`projection` is the existing plan for a partitioned read. The projection's
-`chunk_transform` remains chunk-local, its `cell_transform` describes result
+`source`, with `context.transform.domain.shape == out.shape`. A view's
+transform keeps its literal domain; `ReadContext` re-bases it to origin zero on
+construction, so readers never see a view's coordinates. Its optional
+`projection` describes one planned read. `LazyArray.result()` always supplies
+it, including for partition views and unpartitioned reads. Direct callers of
+the reader protocol may omit it when their reader supports that. The projection's
+`chunk_transform` remains chunk-local, its `cell_transform` places cells in the
+zero-origin result buffer of the view that planned the read, which is what result
 placement, and its `chunk_domain` describes the grid cell. The global read
 transform and the projection's chunk transform deliberately use different
 coordinate frames.
@@ -34,7 +39,7 @@ class RecordingReader:
         self.calls = []
 
     def read_into(self, source, context, out, /):
-        self.calls.append((source, context, out))
+        self.calls.append((source, context, out.shape, out.dtype))
         self.inner.read_into(source, context, out)
 
 
@@ -44,7 +49,8 @@ view = LazyArray.from_numpy(array).with_reader(outer)
 values = view.result()
 ```
 
-Both wrappers observe the same three objects, in outer-to-inner order. This
+Both wrappers observe the same arguments, in outer-to-inner order, and log
+output metadata without retaining the output buffer. This
 delegation pattern supports policies such as logging and caching without
 library-defined wrapper primitives.
 
diff --git a/packages/zarr-indexing/docs/api/writer.md b/packages/zarr-indexing/docs/api/writer.md
new file mode 100644
index 0000000000..a8eb365954
--- /dev/null
+++ b/packages/zarr-indexing/docs/api/writer.md
@@ -0,0 +1,16 @@
+---
+title: Writers
+---
+
+# Writers
+
+`LazyArray.write(values)` and assignment through a view are implemented by
+`write_into`, which writes through a transform using only basic integer/slice
+assignment on the source. Independent affine selections become one basic
+assignment. Other selections are scattered against the source's write grid:
+each touched cell is read once, updated in memory, and written back, so
+storage round trips are bounded by touched cells rather than selected
+elements. NumPy sources receive one fancy assignment instead, and a source
+that advertises no grid is written one element at a time without reading.
+
+::: zarr_indexing.writer
diff --git a/packages/zarr-indexing/docs/design-notes.md b/packages/zarr-indexing/docs/design-notes.md
index 59eef4dacd..9efed99769 100644
--- a/packages/zarr-indexing/docs/design-notes.md
+++ b/packages/zarr-indexing/docs/design-notes.md
@@ -16,7 +16,7 @@ visual guide owns the mechanics of
 ## Relationship to TensorStore
 
 The core is [TensorStore's](https://google.github.io/tensorstore/index_space.html)
-index-transform model, reimplemented in Python against NumPy. The visual guide
+index-transform model, implemented here in Python against NumPy. The visual guide
 introduces the shared model in
 [Coordinates are addresses](guide/index.md#coordinates-are-addresses) and
 [Lazy views compose](guide/index.md#lazy-views-compose); the comparison here is
@@ -28,13 +28,14 @@ about the deliberately matching semantics:
 - **Slice semantics.** Slice bounds are literal domain coordinates: no
   clamping, no negative wrapping, non-empty intervals must be contained in the
   domain, and a strided slice's domain origin is `trunc(start/step)` rounded
-  toward zero. Every one of those rules was executed against tensorstore 0.1.84
-  and is pinned in `tests/test_tensorstore_parity.py`.
-- **The wire format.** A canonical [ndsel](ndsel.md) transform body is,
-  field-for-field, a TensorStore `IndexTransform` minus the `kind`
-  discriminator, and `tests/test_ndsel_tensorstore.py` loads our bodies into
-  `tensorstore.IndexTransform(json=...)` and round-trips them back through our
-  engine layer.
+  toward zero. `tests/test_tensorstore_parity.py` compares the enumerated cases with
+  TensorStore when that optional dependency is installed.
+- **The wire format.** [ndsel](ndsel.md) uses TensorStore's domain and
+  output-map field names for transform bodies, with an additional `kind`
+  discriminator. `tests/test_ndsel_tensorstore.py` checks interoperability for
+  the tested cases. Their validation rules differ, and loading and
+  re-emitting a message through the engine can normalize or discard metadata;
+  see [lowering to a transform](ndsel.md#lowering-to-a-transform).
 - **Chunk partitioning.** Both factor a transform over a grid before visiting
   any cell, rather than intersecting the whole transform with each chunk.
   TensorStore's `IndexTransformGridPartition` holds strided sets and index
@@ -47,17 +48,19 @@ about the deliberately matching semantics:
   components within a mixed request. Both derive the per-chunk transforms
   from the partition ([the guide](guide/index.md#a-plan-is-a-product-of-per-axis-tables)
   shows the tables). TensorStore keeps strided sets implicit, while this
-  library materializes their per-axis rows for vectorized consumers. Diagonals are rejected here; supporting them needs a strided set per
-  *input* dimension spanning every storage axis that reads it, TensorStore's
-  representation.
+  library materializes their per-axis rows for vectorized consumers. Pure
+  affine diagonals need grouping by input dimension; mixed affine/index-array
+  dependencies need joint partitioning. TensorStore classifies a connected
+  component containing index-array edges as an index-array set
+  ([source](https://github.com/google/tensorstore/blob/66b2ce5290fa2ec5c8019682391421062ce767a2/tensorstore/internal/grid_partition.h#L58-L67)).
 
 Four deliberate differences:
 
 | | TensorStore | `zarr-indexing` |
 | --- | --- | --- |
-| Dialect | One strict dialect everywhere: literal coordinates, no negative wrapping | The algebra keeps that dialect; each public boundary picks its own. [`LazyArray`](api/lazy_array.md) speaks positional NumPy, `zarr.Array.lazy` speaks literal. [`zarr_indexing.boundary`](api/boundary.md) is the translation |
+| Dialect | Coordinate indices are literal; negative coordinates do not wrap | The algebra keeps that dialect; each public boundary picks its own. [`LazyArray`](api/lazy_array.md) speaks positional NumPy, `IndexTransform` speaks literal. [`zarr_indexing.boundary`](api/boundary.md) is the translation |
 | Scheduling | An internal C++ scheduler owns concurrency and chunk ordering | [`parts()`](api/lazy_array.md) exposes the partition structure so the caller's own scheduler — dask, a thread pool, a task queue — drives it |
-| Wire format | Implementation-defined JSON, specified by what the implementation accepts | [ndsel](ndsel.md) is spec-first, with a vendored language-agnostic conformance corpus every implementation runs |
+| Wire format | [Documented JSON schema](https://google.github.io/tensorstore/index_space.html#index-transform) | [ndsel](ndsel.md) is spec-first, with a vendored conformance corpus exercised by this implementation |
 | Backends | A driver ecosystem (zarr, N5, neuroglancer, GCS, …) built into the library | No drivers. The default reader needs `shape`, `dtype`, basic integer/slice indexing, and selected slabs convertible to NumPy system memory; other backends use explicit custom readers. A device reader owns transfer into the supplied system-memory output |
 
 The mechanics of a
@@ -74,19 +77,18 @@ and caller-supplied grid; it does not own reads, writes, buffers, locks, or
 scheduling. Zarr can therefore plan reads against an inner codec-chunk grid and
 writes against an atomic shard grid; napari or dask can turn the same
 projections into tasks without putting a dask dependency in this package.
-`coverage` is relative to that selected grid: `full` proves a blind replacement
-safe, `partial` proves it is not, and `unknown` conservatively covers fancy
-selections whose duplicates would require additional work to classify.
-
-The comparison also runs the other way. TensorStore is a mature, heavily
-optimized C++ system whose performance this library cannot approach. Independent strided planning
-here is per axis, but each materialized `ChunkProjection` is
-Python-level bookkeeping over NumPy — two domains, two transforms and the
-projection itself — so the per-part overhead of the object view is
-significant; a consumer that reads the partition's tables directly pays no
-per-chunk object construction. This library is small and depends on nothing beyond
-NumPy, so the algebra can be adopted by a Python project that wants the model
-without the C++ runtime.
+`coverage` describes selection coverage relative to that grid. A `full`
+classification can help a writer avoid reading old values, but does not by
+itself prove that a write is safe: encoding requirements, conflicts, duplicate
+semantics, and concurrency remain consumer responsibilities. `unknown` means
+the planner has not established complete or partial coverage.
+
+This implementation performs Python-level bookkeeping over NumPy. This page
+provides no benchmark establishing a general performance ordering against
+TensorStore; costs depend on the selection and execution backend.
+
+The partition tables can be consumed without constructing a `ChunkProjection`
+for each chunk. Materializing projections adds Python object construction.
 
 ## Bounding-box selections vs query selections
 
@@ -102,11 +104,11 @@ and the coordinates it touches form a regular lattice. Basic indexing produces
 one, and composing basic indexing with basic indexing keeps one.
 
 **A query** is a transform with at least one `ArrayMap` — an explicit lookup
-table of coordinates. It costs `O(n)` to store, it has no locality (the
-coordinates may repeat, reverse, or scatter arbitrarily), and intersecting it
-with a region means scanning it. `oindex`, `vindex`, and boolean masks all
-produce one, and once an axis is a query, subsequent basic indexing cannot make
-it a box again. A second query composes onto any axis of an existing one —
+table of coordinates. Its stored coordinate arrays cost space proportional to their stored size.
+Coordinates may repeat or scatter, but can also be contiguous and local.
+Current query-resolution paths inspect these arrays. Fancy indexing can produce
+a query, but singleton or constant selections can collapse to `ConstantMap`;
+subsequent indexing can therefore make a query affine again. A second query composes onto any axis of an existing one —
 including the axes it merely broadcasts along — by evaluating the existing
 lookup tables at the new coordinates.
 
@@ -116,9 +118,10 @@ planning and materialization.
 
 [ndsel](ndsel.md) encodes the same split in its message kinds: `point`, `box`,
 and `slice` desugar to constant and affine output maps and are always boxes;
-`points` desugars to `index_array` maps, and a `transform` body is a box
-exactly when none of its output maps carries an `index_array`. A consumer can
-therefore classify a selection off the wire without materializing anything:
+`points` desugars to `index_array` maps. A transform without index-array maps
+is a box in the engine’s structural classification. Loading can further
+simplify degenerate index arrays to constants, so an arbitrary incoming body
+with `index_array` fields need not remain a query. For example:
 
 ```python
 from zarr_indexing import IndexTransform
@@ -134,16 +137,13 @@ gather.to_json()["output"][0]
 #  'index_array_bounds': ['-inf', '+inf']}
 ```
 
-The distinction matters to consumers of a selection. A box can be tiled into
-rectangular dask chunks or passed to a viewer or tile server that only accepts
-rectangles; a query cannot, and has to be resolved into a gather. A box can also
-be served as a single strided slab read, but the read has to be strided: reading
-its bounding box and discarding the rest transfers proportionally more data as
-soon as any stride exceeds 1. The two also behave differently under
-partitioning: a box touches a regularly-spaced run of parts, in increasing
-order, each at most once — a stride larger than a part's extent skips parts
-outright, so the run is not contiguous — while a query can touch any subset of
-them, in any order, more than once.
+The representation helps a consumer choose a lowering strategy. Independent
+affine axes can often be read with slices plus reversal, permutation, or
+broadcasting. Arbitrary affine maps can also express diagonals, so the absence
+of `ArrayMap` alone is not proof of a rectangular slab. Queries may be lowered
+through gathers or covers, and can sometimes simplify to slices. Chunk plans
+group selected coordinates by chunk while preserving result placement; repeated
+coordinates do not imply repeated visits to the same chunk.
 
 [`LazyArray`](api/lazy_array.md) exposes the category directly:
 
@@ -157,13 +157,13 @@ arr = zarr.create_array({}, shape=(100, 80), chunks=(30, 40), dtype="int32")
 arr[:] = np.arange(8000).reshape(100, 80)
 lazy = LazyArray(arr)
 
-slab = lazy.lazy[10:50, ::4]
+slab = lazy[10:50, ::4]
 slab.is_box            # True
 slab.bounding_box()    # ((10, 50), (0, 77))
 slab.strides()         # (1, 4)
 slab.shape             # (40, 20)
 
-gather = lazy.lazy.oindex[[90, 3, 3], :]
+gather = lazy.oindex[[90, 3, 3], :]
 gather.is_box          # False
 gather.bounding_box()  # ((3, 91), (0, 80))
 gather.strides()       # None
@@ -173,16 +173,20 @@ gather.shape           # (3, 80)
 `bounding_box()` is defined for both: it is the hull, the smallest interval per
 storage dimension containing every coordinate the selection reaches.
 `strides()` is defined only for a box and gives the step per dimension.
-Together the two describe a box selection completely.
-
-Both are needed, because a box is dense in its hull only when every stride is
-1. The slab above spans a 40x77 hull over the 40x20 cells it selects, so a
+These summaries omit traversal direction, input-axis correspondence, and
+result layout. For example, forward and reversed views have identical bounds
+and stride magnitudes but different ordered results. Use the transform for the
+complete selection.
+
+For independent axes with multiple selected coordinates, a stride magnitude
+greater than one leaves gaps in the hull. Singleton axes are an exception,
+and a query can also cover every cell of its hull. The slab above spans a 40x77 hull over the 40x20 cells it selects, so a
 consumer that issued one rectangular read of the hull and discarded the rest
 would transfer 3.85x the data. A query's hull is looser still and carries no
 stride at all: 88 rows of hull over three selected rows. An empty *box* touches
 no coordinate to report an interval around, so `bounding_box()` is `None` while
 `strides()` still answers — the step is a property of the selection's shape, not
-of the region it reaches. Only a query returns `None` from both.
+of the region it reaches. An empty query returns `None` from both.
 
 There is deliberately no separate `BoxView` type today. A statically-typed
 rectangular-only view is a plausible next step, but it should be introduced by
@@ -248,8 +252,8 @@ could accept and finishing the rest elsewhere. A reader lowers the complete
 transform and can compose through delegation instead. This resembles
 [zarrita.js store extensions](https://zarrita.dev/packages/zarrita.html), where
 storage-specific behavior is an explicit extension point rather than an
-inferred array capability. The implementation remains independently authored:
-no code is shared with TensorStore, xarray, or zarrita.js.
+inferred array capability. This is an architectural analogy, not a claim of API or implementation
+compatibility.
 
 ## Current scope
 
@@ -259,43 +263,41 @@ than a silently empty selection. One consequence: a negative step normally
 produces a negative domain origin. Reversing a length-20 zero-origin axis gives
 the domain `[-19, 1)`, because the result stays anchored to the source
 coordinate frame and a reversing map traverses that frame backwards. `LazyArray`
-re-bases every view to origin 0, so the positional dialect never exposes it; a
-caller working with `IndexTransform` directly will see it, and re-bases
-explicitly with `translate_domain_to` for NumPy-shaped coordinates.
+views keep that literal domain, so `view.transform.domain` shows it; positional
+keys are normalized against the domain's origin, so the NumPy dialect never
+requires typing it. A caller wanting zero-origin coordinates re-bases
+explicitly with `translate_domain_to`.
 
-Fancy selections compose without restriction: a second `oindex`/`vindex`/mask
+Supported fancy selections compose across already-fancy views: a second `oindex`/`vindex`/mask
 step may land on any axis of an already-fancy view, including axes an existing
 index array merely broadcasts along, so
-`lazy.oindex[[2, 0], :].lazy.oindex[:, [1, 3]]` selects the outer product it
+`lazy.oindex[[2, 0], :].oindex[:, [1, 3]]` selects the outer product it
 spells. An array-carrying transform is composed — the new selection is applied
 to an identity transform over the current domain and chained on with `compose`,
 which evaluates the existing lookup tables at the new coordinates — rather than
 rewritten in place. Resolution classifies the result by structure
 (`index_array_structure`): pure per-axis outer products keep the orthogonal
 resolvers, and everything else — correlated maps, mixtures, index arrays
-sharing an input axis (a diagonal gather, reachable only by hand-building a
-transform) — takes the general reader/intersection path. Chunk planning
+sharing an input axis (as in paired vectorized coordinates) — takes the general reader/intersection path. Chunk planning
 factors index arrays into connected dependency components before flattening,
 so independent groups do not expand one another. Vectorized selection preserves
 broadcast singletons to retain those dependencies.
 
-Three limits remain, all intentional and all expected to be lifted:
+Some current limits are:
 
-- **Affine diagonals.** A hand-built transform in which two output maps read
-  one input dimension — two slice maps, or a slice map and an orthogonal index
-  array — is rejected at planning with `ValueError`; a correlated index array
-  varying over a dimension a slice map also reads is rejected with
-  `NotImplementedError`. No selection dialect produces either. Supporting them
-  needs a strided set per *input* dimension spanning all dependent storage
-  axes, TensorStore's connected-component representation. *Planned.*
+- **Shared affine dependencies.** Planning rejects two affine output maps
+  sharing an input axis with `ValueError`. An index array sharing a varying
+  input axis with an affine map takes the general classification and raises
+  `NotImplementedError`. Pure affine diagonals would need grouping dependent
+  storage axes by input dimension; mixed components need joint partitioning.
 - **Finite explicit bounds only.** `IndexDomain` has no implicit or unbounded
   dimensions; the message layer will normalize a body with `"-inf"`/`"+inf"`
   bounds, but the engine layer refuses to lower one into a transform.
-  TensorStore supports both. *Planned.*
+  TensorStore supports both.
 - **Labels are carried, not propagated.** `IndexDomain` holds optional
   dimension labels and the wire format round-trips them, but indexing
   operations build new domains without them, so a label does not survive a
-  slice. *Planned.*
+  slice.
 
 ## Selection to chunk operations
 
diff --git a/packages/zarr-indexing/docs/guide/index.md b/packages/zarr-indexing/docs/guide/index.md
index 68192f58cb..f227ca1ac4 100644
--- a/packages/zarr-indexing/docs/guide/index.md
+++ b/packages/zarr-indexing/docs/guide/index.md
@@ -1,6 +1,6 @@
 # Visual guide
 
-The whole model in one sentence: indexing through `LazyArray.lazy` builds a
+The whole model in one sentence: indexing through `LazyArray` builds a
 view, chunk planning partitions its coordinates, and `result()` materializes
 the view. This page follows one familiar NumPy selection, `source[2:5]`,
 through those stages.
@@ -38,7 +38,7 @@ make the correspondence explicit: those result coordinates receive values
 `12`, `13`, and `14` from source coordinates `2`, `3`, and `4`.
 
 The wrapper below gives the same familiar selection a lazy spelling. Indexing
-through `.lazy` creates `view`; the last line asks for its values and checks the
+with `[...]` creates `view`; the last line asks for its values and checks the
 observable NumPy result.
 
 ```python
@@ -105,11 +105,40 @@ different questions:
 | Surface | Meaning of an integer index | Meaning of `-1` |
 | --- | --- | --- |
 | `IndexDomain` and `IndexTransform` | A literal coordinate in the current domain | The actual address `-1`, if the domain contains it |
-| `LazyArray.lazy` | A NumPy-style position in the current view | The last position, normalized before it reaches the transform algebra |
+| `LazyArray` with a NumPy key | A NumPy-style position in the current view | The last position, normalized against the domain's origin before it reaches the transform algebra |
+| `LazyArray` with an `IndexDomain` or `IndexTransform` key | A literal coordinate in the view's domain | The actual address `-1`, if the domain contains it |
 
-`LazyArray` uses positions because it is an array-like wrapper: each derived
-view starts at position zero and negative indices wrap exactly as they do in
-NumPy. The lower-level domain and transform types keep literal coordinates.
+`LazyArray` reads NumPy keys as positions because it is an array-like wrapper:
+negative indices wrap exactly as they do in NumPy. The view itself keeps its
+literal domain, as a TensorStore view does: `source[10:20]` has domain
+`[10, 20)`, and a further `[2:5]` on it has domain `[12, 15)`. A domain or
+transform key addresses those literal coordinates directly.
+
+### The key's type picks the frame {#the-keys-type-picks-the-frame}
+
+**The type of a key decides whether it is relative or absolute.** This is the
+one rule to remember about indexing a `LazyArray`:
+
+| Key type | Read as | Example |
+| --- | --- | --- |
+| slice, integer, `...`, `None`, index array, mask | **Relative**: positions in the current view, NumPy-style | `view[2:5]`, `view[-1]`, `view.oindex[[3, 1]]` |
+| `IndexDomain` | **Absolute**: coordinates of the view's domain, restricted to a box | `view[IndexDomain((12,), (15,))]` |
+| `IndexTransform` | **Absolute**: composed onto the view; the key's domain becomes the new view's domain | `view[IndexTransform.identity(view.transform.domain)[12:15]]` |
+
+No key type is valid in both readings, so a key never has two meanings. That is
+the property pandas lost with value-based `ix` dispatch and removed in favor of
+`loc` and `iloc`; TensorStore keeps it by giving each key type one fixed
+reading, and so does this wrapper. The only difference from TensorStore is
+which reading the NumPy key gets: absolute there, relative here.
+
+Whichever key produced a view, **its domain is always absolute**:
+`view.transform.domain` reports literal coordinates after `view[2:5]` exactly as
+it does after `view[IndexDomain(...)]`. The relative reading exists only at the
+moment a NumPy key is interpreted, so relative and absolute steps compose freely.
+
+```python
+--8<-- "snippets/key_types.py:key-types"
+```
 
 ### A transform points from the request to the source
 
@@ -209,28 +238,35 @@ metadata is ready to inspect:
 | Available without reading | Value in this example |
 | --- | --- |
 | `composed.shape` | `(2,)` |
-| `composed.transform` | One transform mapping request `i` to source `3 - i` |
+| `composed.transform` | One transform over the literal domain `[-3, -1)`, mapping request `i` to source `-i` |
 
 Neither property needs source values. Composition works only on the coordinate
 description; the assertion's call to `result()` is the first operation in the
 example that materializes the selected data.
 
 !!! warning "Stop here: the materialization boundary"
-    Indexing through `.lazy[...]` never reads. These do:
+    Indexing through `[...]` composes a selection without reading source values.
+    These operations request values:
 
     - `result()`
-    - eager indexing of the wrapper: `view[...]`
-    - `numpy.asarray(view)`, or passing the view to any NumPy function
-      (`numpy.add(view, 1)` converts, and therefore materializes, the view)
+    - `numpy.asarray(view)` and NumPy operations that convert the view
+      (`numpy.add(view, 1)` does so; `numpy.shape(view)` and `numpy.ndim(view)`
+      can use metadata without reading values)
+
+    Dask tokenization may also inspect values, depending on the wrapped source
+    and tokenization path.
 
     Python arithmetic such as `view + 1` raises `TypeError` instead: this
     wrapper defers indexing, not a general compute graph.
 
-    Nor does it write. There is no `__setitem__`, so `view[...] = values`
-    raises `TypeError` too, and a wrapped source needs no `__setitem__` of
-    its own. A consumer that writes plans the selection with `plan_chunks`
-    and performs its own read-modify-write, keeping chunk atomicity and
-    concurrent-writer policy on the backend's side of the boundary.
+    Iteration yields lazy first-axis views; call `result()` on each to read it.
+
+    `view.write(values)` writes through the composed transform to the original
+    writable source, synchronously, and returns `None`. `view[key] = values`
+    writes the selected sub-view in the same way. These calls do not create
+    futures or transactions. Read-only sources remain usable for reads;
+    writes require source assignment support. Storage atomicity and concurrent
+    writer coordination remain the backend's responsibility.
 
 ## An index defines a result array {#an-index-defines-a-result-array}
 
@@ -384,8 +420,11 @@ each bundles a sub-view of the request (`.view`), that chunk's projection
 Within one `Partition`, the frames divide: `Partition.view.transform` is a
 different, global transform — it maps the part view directly into the raw
 wrapped source — while only `Partition.projection.chunk_transform` uses
-zero-origin chunk-local coordinates. Readers receive both so the global
-source address and the local planning frame cannot be confused.
+zero-origin chunk-local coordinates. Parent assembly passes both frames to
+the reader. Independently scheduled `part.view.result()` calls plan against the
+same source grid and supply both frames too. Their result placement is relative
+to the part view being read. A partition view can be indexed or repartitioned
+like any other view; its base shape remains the full source shape.
 
 | Projection field | What its output coordinates mean |
 | --- | --- |
@@ -399,7 +438,7 @@ rank one and source rank two.
 
 ### Order and duplicates need the request-side projection
 
-Orthogonal indexing (`.lazy.oindex`) applies each axis's indexer
+Orthogonal indexing (`.oindex`) applies each axis's indexer
 independently, like `numpy.ix_` — an outer product; the
 [pattern reference](patterns.md) develops the dialects. It can visit source
 cells in an order that does not match chunk order, and it can visit one
diff --git a/packages/zarr-indexing/docs/guide/integrations.md b/packages/zarr-indexing/docs/guide/integrations.md
index f787d11f6c..c96dcf91a5 100644
--- a/packages/zarr-indexing/docs/guide/integrations.md
+++ b/packages/zarr-indexing/docs/guide/integrations.md
@@ -3,8 +3,9 @@
 For the complete path from indexing syntax to chunk coordinates, local selectors,
 and result positions, start with [From a selection to chunk operations](selection-flow.md).
 
-This package supplies indexing plans. It does **not** supply scheduling,
-caching, codecs, or async orchestration. A consumer decides when projections
+The core package supplies indexing plans and synchronous readers. It does not
+provide a general scheduler, codec pipeline, or async execution engine. A
+synchronous cache is included as an example. A consumer decides when projections
 run, how decoded chunks are obtained, and where completed values are retained.
 An `IndexTransform` says which source values belong in a result; a `Reader`
 lowers that complete transform for one backend. The reader does not choose
@@ -61,21 +62,21 @@ afterward, so accessing a row does not recalculate every point.
 
 ## One slab read or many part reads
 
-A backend with its own native subset read — a Rust or C zarr implementation,
-a database, an HTTP range endpoint — resolves a **dense box** (`is_box` with
-every stride 1) best as a single read: hand it the whole selection and let it
-dispatch to chunks, decode in parallel, and partial-decode shards on its own
-side of the boundary. Splitting that read along this library's partitioning
-only adds round-trips. Every **other** selection — a strided box, an `oindex`
-or `vindex` gather — is where the partitioning earns its keep. The **cover**
-of a read is the smallest step-1 slab enclosing every coordinate it needs;
-partitioned, each part's cover is bounded by that part's box, so a sparse
-selection can never force one read of its whole bounding hull (the smallest
-rectangle containing every selected coordinate — a thousand rows for the two
-of `oindex[[0, 999]]`).
+A backend with an efficient native subset operation may benefit from receiving
+one complete dense selection so it can choose its own chunk dispatch. Other
+backends may benefit from partitioning, including for strided or fancy
+selections. The tradeoff depends on the backend, chunk layout, latency, memory,
+and selection; a single read is not universally fastest.
+
+A read's **cover** is the smallest unit-step slab enclosing its coordinates.
+With this package's basic readers, partitioning limits each source read to the
+part's selected cover. This may reduce over-reading, but a partition that spans
+the source can still require the entire hull. Custom readers choose their own
+source operations under the reader contract.
 
 The composed view carries enough to make that call at materialization time,
-and re-partitioning is a pure setter, so the policy is three lines:
+and `with_parts()` returns a view with a new partitioning. This example uses
+unit strides as a sufficient condition for its independently mapped selections:
 
 ```python
 --8<-- "snippets/integrations.py:dense-box-repartition"
@@ -87,20 +88,19 @@ the dense box becomes exactly one backend call. Both regimes go through
 
 ### Sources that accept only unit-step slices
 
-The default `basic_reader` pushes strided and descending selections down as
-positive-step slices, which reads the minimum but assumes the source accepts
-any step. Many backends do not: FFI bindings and range requests often
-support nothing but `slice(start, stop, 1)`. Select
-[`unit_step_reader`][zarr_indexing.reader.UnitStepReader] for such a source
-and every key it receives is an ascending unit-step slice per axis, with
+For affine selections, `basic_reader` uses positive-step slices and applies
+reversal or layout changes in memory. Fancy selections can require reading a
+cover containing unselected values. The source must accept the emitted steps.
+Use [`unit_step_reader`][zarr_indexing.reader.UnitStepReader] for a source that
+accepts only unit steps. Every key it receives is an ascending unit-step slice per axis, with
 strides, reversals, and gathers applied to the in-memory block instead:
 
 ```python
 view = LazyArray(source).with_reader(unit_step_reader)
 ```
 
-A strided selection then over-reads its cover by the stride factor, which the
-partitioning above bounds by one part.
+For strided selections, the ratio of cover cells to selected cells depends on
+stride, length, and endpoint alignment. Partitioning can reduce that cover.
 
 ## napari-like consumer
 
@@ -205,13 +205,12 @@ decoded chunks. Every read delta follows directly from the viewport request:
 | 4 | `image[1:5, 2]` | `(0, 0)` | `(0, 0)`, `(1, 0)` | The evicted chunk is reloaded while the required ready chunk is retained. |
 | 5 | `image[3:5, 4:6]` | `(1, 1)` fails; no repeated read; `(1, 1)` succeeds after retry | `(0, 0)`, `(1, 1)` | Failure is retained until explicit retry; the repaired source then returns `[[28, 29], [36, 37]]`. |
 
-Chunks required by an active request are pinned through assembly, so a request
-may temporarily span more chunks than the steady-state capacity. Capacity is
-counted in decoded chunks—not records or bytes—and eviction occurs only after
-all requested values have been placed. Because pinning and materialization use
-the same prepared tuple, those lifecycle decisions cannot drift from the parts
-that are actually read, and the cache never has to infer or reconstruct a
-projection.
+The example defers eviction until a successful outermost request finishes, so
+it can temporarily exceed capacity during assembly. Capacity counts decoded
+chunks, not bytes, event records, or temporary arrays. Failed requests skip
+that eviction step. The example assumes an unchanged source and one source/grid
+per reader; it does not implement invalidation or synchronization for concurrent
+requests. The prepared tuple supplies the projections used for each read.
 
 The event log makes the failure boundary equally explicit:
 
@@ -244,3 +243,20 @@ that implementation or reproduce its full worker/GPU lifecycle.
 ·
 **API:** [API reference](../api/index.md)
 </nav>
+
+## Dask tokenization
+
+`LazyArray.__dask_tokenize__()` combines Dask's token for the wrapped source
+with the serialized view transform. Dask owns source hashing, registered
+normalizers, custom source hooks, and deterministic-token requirements.
+Tokenization may read or hash source values. Dask is optional for indexing
+and reading, but required when requesting a Dask token.
+
+The reader and partitioning are omitted because they must preserve values.
+Changing a source after graph construction does not update existing Dask keys.
+
+For consumers that require eager indexing, such as `dask.array.from_array`,
+wrap the view in `EagerArrayAdapter` (importable from `zarr_indexing`). The
+adapter materializes each indexed block while the wrapped view keeps lazy
+indexing, and its token derives from the view's. See Dask's [from_array
+documentation](https://docs.dask.org/en/stable/generated/dask.array.from_array.html).
diff --git a/packages/zarr-indexing/docs/guide/patterns.md b/packages/zarr-indexing/docs/guide/patterns.md
index 9d22c4eb4e..df9a482c3e 100644
--- a/packages/zarr-indexing/docs/guide/patterns.md
+++ b/packages/zarr-indexing/docs/guide/patterns.md
@@ -302,17 +302,18 @@ so they equal the zero-origin models after `translate_domain_to`:
 --8<-- "snippets/indexing_patterns.py:indexing-patterns"
 ```
 
-`LazyArray` adds nothing to these semantics: it is a regular array-like API
-whose `.lazy`, `.lazy.oindex`, and `.lazy.vindex` accessors compile the same
-dialects to the same transforms — the only difference is the return type, a
-view instead of an array. The test suite holds the wrapper to this matrix.
+`LazyArray` exposes the transform machinery through a positional array-like
+API. Its `[...]`, `.oindex[...]`, and `.vindex[...]` operations return views and
+normalize positions before composition. This boundary differs from the literal
+coordinate semantics of `IndexTransform`, as the following table shows. The
+executable matrix checks the documented cases, not every possible NumPy expression.
 
 ## Positions vs literal coordinates
 
 | Surface | Meaning of an integer index | Meaning of `-1` |
 | --- | --- | --- |
 | `IndexDomain` and `IndexTransform` | A literal coordinate in the current domain | The address `-1`, when the domain contains it |
-| `LazyArray.lazy` | A NumPy-style position in the current view | The last position, normalized before transform composition |
+| `LazyArray` | A NumPy-style position in the current view | The last position, normalized before transform composition |
 
 The wrapper's three indexing modes all use positions in the current view. Each
 derived view begins at position zero, while the transform algebra underneath
diff --git a/packages/zarr-indexing/docs/guide/selection-flow.md b/packages/zarr-indexing/docs/guide/selection-flow.md
index 571baa3869..749a9c36ae 100644
--- a/packages/zarr-indexing/docs/guide/selection-flow.md
+++ b/packages/zarr-indexing/docs/guide/selection-flow.md
@@ -171,7 +171,7 @@ pairs:
 | `(0,)` | `[1]` | `[1]` |
 | `(1,)` | `[2, 2, 0]` | `[0, 2, 3]` |
 
-Chunk `(1,)` is fetched once, but its local value `2` contributes to two result
+Chunk `(1,)` is fetched once, but the value at local coordinate `2` contributes to two result
 positions. Chunk visitation order need not be result order; `out_selection`
 restores the requested arrangement.
 
@@ -188,6 +188,9 @@ than one. Repeated coverage is not full; fancy coverage remains conservative.
 
 Zarr's merge operation can skip a read for a full data-extent write and allocate
 a fill-valued codec buffer when the selected data is smaller than that buffer.
+That shortcut also requires the consumer's expected value layout and order;
+complete coverage by a reversal or reordered gather alone does not establish
+that the supplied buffer can be copied directly into codec order.
 Touching every chunk alone does not prove full coverage of each chunk.
 
 Planning does not fetch bytes, decode buffers, choose concurrency, or define
diff --git a/packages/zarr-indexing/docs/index.md b/packages/zarr-indexing/docs/index.md
index 87e5a4b7a1..03537493f2 100644
--- a/packages/zarr-indexing/docs/index.md
+++ b/packages/zarr-indexing/docs/index.md
@@ -5,8 +5,7 @@ the *declaration* of an array indexing expression from the result of that expres
 
 Developed for use in [`zarr`](https://zarr.readthedocs.io).
 
-Inspired by [TensorStore](https://google.github.io/tensorstore/), which pioneered
-the approach used here.
+Inspired by [TensorStore's index-transform model](https://google.github.io/tensorstore/index_space.html).
 
 
 ## Install
@@ -21,15 +20,16 @@ pip install zarr-indexing
 
 ## Quickstart
 
-Wrap an array, compose a lazy view through `.lazy`, and call `result()` when
+Wrap an array, compose a lazy view with `view[...]`, and call `result()` when
 you want its values:
 
 ```python
 --8<-- "snippets/canonical_slice.py:landing-quickstart"
 ```
 
-Nothing is read until the `result()` call, however many selections are
-composed. [Lazy views compose](guide/index.md#lazy-views-compose) shows how
+Composing these selections does not read source values; the example reads them
+at `result()`. Construction inspects source metadata, and Dask tokenization can
+inspect source values. [Lazy views compose](guide/index.md#lazy-views-compose) shows how
 the chain stays one description, and where the materialization boundary is.
 
 ## Learn more
diff --git a/packages/zarr-indexing/docs/ndsel.md b/packages/zarr-indexing/docs/ndsel.md
index 94971d49bf..3ba13176c1 100644
--- a/packages/zarr-indexing/docs/ndsel.md
+++ b/packages/zarr-indexing/docs/ndsel.md
@@ -14,11 +14,13 @@ before a transform is serialized. `zarr-indexing` implements ndsel in two layers
 
 | Layer | Module | Depends on | Job |
 | --- | --- | --- | --- |
-| Message | [`zarr_indexing.messages`](api/messages.md) | stdlib only | JSON in, canonical JSON out. Validates and desugars. Never rounds, clamps, or drops information. |
+| Message | [`zarr_indexing.messages`](api/messages.md) | stdlib only | Validates and desugars JSON, removing redundant constant-map fields. |
 | Engine | [`zarr_indexing.json`](api/json.md) | NumPy | Lowers a *canonical* body into an in-memory [`IndexTransform`](api/transform.md), and back. |
 
 Constraints that only make sense for a real array — finite bounds, index
-arrays as `ndarray`s — live in the engine layer and nowhere else. As a result,
+arrays as `ndarray`s — are checked during engine lowering. The message layer
+also limits input rank to 32 and checks affine input-dimension references.
+These checks are stricter than the draft's required message validation. As a result,
 `messages` normalizes a message with `"-inf"` bounds that
 `IndexTransform.from_json` refuses to lower.
 
@@ -47,9 +49,13 @@ normalize_ndsel({"kind": "box", "inclusive_min": [10, 5], "shape": [40, 1]})
 ```
 
 Normalization is idempotent: re-tag the output with `kind: "transform"` and
-normalizing it again returns the same body. Because the canonical body is
-field-for-field a TensorStore `IndexTransform` minus `kind`, a normalized
-message loads directly into `tensorstore.IndexTransform(json=...)`.
+normalizing it again returns the same body. The canonical body uses
+TensorStore's `IndexTransform` field vocabulary, but normalization does not
+guarantee acceptance by TensorStore. For example, the message layer leaves
+index-array content unchecked, whereas TensorStore validates it; TensorStore
+also requires unique nonempty labels and restricts finite index values to
+`[-(2**62 - 2), 2**62 - 2]`. See
+[TensorStore's index-space constraints](https://google.github.io/tensorstore/index_space.html).
 
 Both entry points raise
 [`NdselError`](api/messages.md#zarr_indexing.messages.NdselError), which
@@ -64,12 +70,13 @@ Four are shorthands; the fifth is the canonical form itself.
 | `kind` | Fields | Selects |
 | --- | --- | --- |
 | `point` | `coords` | A single element. Normalizes to rank 0 with one `constant` output map per dimension. |
-| `box` | `inclusive_min`, one of `exclusive_max` / `inclusive_max` / `shape`, `labels` | A rectangular region. Exactly one upper-bound spelling may appear. |
+| `box` | `inclusive_min`, one of `exclusive_max` / `inclusive_max` / `shape`, `labels` | A rectangular region. At most one upper-bound spelling may appear; omission gives implicit positive infinity. |
 | `slice` | `start`, `stop`, `step`, `labels` | A strided region, one Python-style slice per dimension. |
 | `points` | `coords` (a list of coordinate rows) | An explicit list of points — the `vindex` case. Normalizes to one `index_array` output map per dimension over a shared rank-1 input domain. |
 | `transform` | `input_rank`, `input_inclusive_min`, one of the three `input_*` upper bounds, `input_labels`, `output` | The full canonical form. |
 
-Value rules the message layer enforces throughout: every integer is a 64-bit
+Value rules for validated fields (excluding verbatim `index_array` payloads
+and discarded constant-map fields): every integer is a 64-bit
 signed value; JSON booleans are **not** integers (Python's
 `isinstance(True, int)` is guarded against explicitly); the `"-inf"` / `"+inf"`
 sentinels are legal only in bound positions; and an implicit bound is the
@@ -81,17 +88,35 @@ normalization intact.
 The engine layer converts between canonical bodies and `IndexTransform`s:
 
 ```python
-from zarr_indexing import IndexTransform
+from zarr_indexing import IndexTransform, normalize_ndsel
 
+canonical = normalize_ndsel({"kind": "box", "shape": [2, 3]})
 t = IndexTransform.from_json(canonical)
-t.to_json() == canonical
+assert t.to_json() == canonical
 ```
 
 `IndexDomain` carries the same pair for a bare domain body, and each output
 map kind has a `to_json`; `output_index_map_from_json` dispatches the wire's
-tagged union back to the right kind.
-
-Two engine constraints apply here and only here. A canonical body carrying a
+structurally discriminated union back to the right kind. Exact JSON equality
+in this example is not a general round-trip guarantee: implicit flags are
+removed and degenerate array maps are collapsed.
+
+`index_array_bounds` constrains raw index-array values before the map's offset
+and stride are applied. Both `IndexTransform.from_json` and
+`output_index_map_from_json` validate every supplied value against the inclusive
+bounds when loading. Finite and one-sided bounds are supported; omitted bounds
+and `["-inf", "+inf"]` impose no additional constraint. Values outside the
+bounds raise `NdselError("invalid_json", ...)`, including in singleton arrays
+and zero-stride maps. Empty arrays satisfy any well-formed, ordered bounds.
+
+Validation is eager: an invalid entry rejects the entire map even if a later
+selection would avoid that entry. After validation the engine owns immutable
+index coordinates, so it need not retain the bounds; serialization emits
+unbounded constraints for non-degenerate maps. Message normalization preserves
+the original bounds without checking array contents. This implementation does
+not defer bounds errors until individual positions are accessed.
+
+A canonical body carrying a
 `"-inf"` or `"+inf"` bound cannot be lowered — an `IndexDomain` addresses a
 finite array — so `IndexTransform.from_json` raises. And implicit bounds lower
 *by value*: the `[n]`-bracket flag is a message-layer concern, and the engine
@@ -102,21 +127,17 @@ keeps only the integer.
 ndsel and TensorStore both **reject** an output map that carries both
 `input_dimension` and `index_array`. The in-memory
 [`ArrayMap`](api/output_map.md#zarr_indexing.output_map.ArrayMap), though,
-records an `input_dimension` to pin the axis an orthogonal (`oindex`) array
-varies over. The serializer bridges that gap in both directions:
+records its dependency axes in its full-rank array shape, with no
+`input_dimension` field:
 
 - **On serialize**, a non-degenerate `index_array` map is emitted *without*
   `input_dimension`.
-- **On load**, the in-memory `input_dimension` is reconstructed from the
-  full-rank array's dependency axes — its non-singleton axes. An array that
-  solely owns a single non-singleton axis is orthogonal; arrays that share
-  non-singleton axes, or vary over several, are correlated (`vindex`), and get
-  `input_dimension = None`. A single 1-D array over a rank-1 domain is
-  inherently ambiguous between the two flavors and reconstructs as
-  orthogonal, which is behaviorally identical in that case.
-
-There is one deliberate exception, and it is the only place a round trip changes
-representation rather than preserving it. An all-singleton `index_array` — size
+- **On load**, dependency axes are the full-rank array's non-singleton axes.
+  Maps sharing these axes describe correlated coordinates. The engine also
+  accepts lower-rank nonempty arrays by prepending singleton axes; that
+  convenience is not a guarantee of compatibility with other ndsel consumers.
+
+An all-singleton `index_array` — size
 1 — selects the same coordinate regardless of the input, so it is collapsed to
 a `constant` map on serialize:
 
@@ -137,6 +158,11 @@ The transform is still valid and the output shape is unchanged. A length-1
 `oindex` selection therefore round-trips behaviorally (an `ArrayMap` comes back
 as a `ConstantMap`) rather than by object identity.
 
+Empty index arrays also serialize as constant maps with offset zero: the
+empty input domain carries the fact that no coordinates are selected. This
+avoids losing trailing shape information in JSON when an array has a leading
+zero-length axis.
+
 ## Conformance
 
 The package is checked against the language-agnostic ndsel conformance corpus,
@@ -145,8 +171,9 @@ vendored unmodified under
 — one JSON file per message kind plus `errors.json`, with the source commit
 recorded in `PROVENANCE.md`. Each fixture is either a *success* case
 (`input` + expected `normalized` body) or an *error* case (`input` + expected
-reason code), and an implementation is conformant iff `normalize` reproduces
-every one. `tests/test_conformance.py` runs the whole corpus as one
+reason code). Matching every fixture establishes corpus conformance; the
+fixtures do not prove correctness for every possible input or universal
+TensorStore compatibility. `tests/test_conformance.py` runs the whole corpus as one
 parametrized test per fixture, so a corpus update reports failures fixture by
 fixture rather than as a single opaque assertion.
 
diff --git a/packages/zarr-indexing/docs/release-notes.md b/packages/zarr-indexing/docs/release-notes.md
index 767cd56a84..d0687d8758 100644
--- a/packages/zarr-indexing/docs/release-notes.md
+++ b/packages/zarr-indexing/docs/release-notes.md
@@ -1,5 +1,6 @@
 <!-- CHANGELOG.md at the package root is the single source of truth: towncrier
-     writes releases into it, and PyPI and GitHub render it directly. This page
+     writes releases into it, and GitHub renders the repository file. PyPI's
+     project description uses README.md, with a link to the changelog. This page
      includes it so each docs build shows the release notes for its own version.
      The page is not named changelog.md on purpose: on a case-insensitive
      filesystem that name shadows CHANGELOG.md and the include resolves to the
diff --git a/packages/zarr-indexing/docs/snippets/axis_manipulation.py b/packages/zarr-indexing/docs/snippets/axis_manipulation.py
index 1d1369fd87..8f35b1718c 100644
--- a/packages/zarr-indexing/docs/snippets/axis_manipulation.py
+++ b/packages/zarr-indexing/docs/snippets/axis_manipulation.py
@@ -8,8 +8,8 @@
 image = np.arange(12).reshape(3, 4)
 lazy = LazyArray.from_numpy(image)
 
-integer_view = lazy.lazy[1, :]
-slice_view = lazy.lazy[1:2, :]
+integer_view = lazy[1, :]
+slice_view = lazy[1:2, :]
 
 INTEGER_RESULT = integer_view.result()
 SLICE_RESULT = slice_view.result()
@@ -21,7 +21,7 @@
 # --8<-- [end:axis-shape-comparison]
 
 # --8<-- [start:axis-insertion]
-inserted_view = lazy.lazy[1, :, None]
+inserted_view = lazy[1, :, None]
 INSERTED_RESULT = inserted_view.result()
 
 assert INSERTED_RESULT.tolist() == [[4], [5], [6], [7]]
diff --git a/packages/zarr-indexing/docs/snippets/canonical_slice.py b/packages/zarr-indexing/docs/snippets/canonical_slice.py
index fc4417f641..8d9fa387a8 100644
--- a/packages/zarr-indexing/docs/snippets/canonical_slice.py
+++ b/packages/zarr-indexing/docs/snippets/canonical_slice.py
@@ -11,7 +11,7 @@
 from zarr_indexing import LazyArray
 
 source = np.array([10, 11, 12, 13, 14, 15])
-view = LazyArray.from_numpy(source).lazy[2:5]
+view = LazyArray.from_numpy(source)[2:5]
 
 view.result()
 # array([12, 13, 14])
@@ -24,7 +24,7 @@
 # --8<-- [start:canonical-slice]
 source = np.array([10, 11, 12, 13, 14, 15])
 lazy = LazyArray.from_numpy(source)
-view = lazy.lazy[2:5]
+view = lazy[2:5]
 
 assert view.result().tolist() == [12, 13, 14]
 # --8<-- [end:canonical-slice]
diff --git a/packages/zarr-indexing/docs/snippets/chunk_projection.py b/packages/zarr-indexing/docs/snippets/chunk_projection.py
index 5c56aafbbd..e6c7394540 100644
--- a/packages/zarr-indexing/docs/snippets/chunk_projection.py
+++ b/packages/zarr-indexing/docs/snippets/chunk_projection.py
@@ -46,7 +46,7 @@ def indices_to_chunks(self, indices: NDArray[np.intp]) -> NDArray[np.intp]:
 
 # --8<-- [start:advanced-projection]
 image = np.arange(48).reshape(6, 8)
-advanced = LazyArray.from_numpy(image).with_parts((3, 4)).lazy.oindex[[4, 1, 1], 2:6]
+advanced = LazyArray.from_numpy(image).with_parts((3, 4)).oindex[[4, 1, 1], 2:6]
 
 ADVANCED_EXPECTED = image[[4, 1, 1]][:, 2:6]
 ADVANCED_RESULT = np.empty_like(ADVANCED_EXPECTED)
diff --git a/packages/zarr-indexing/docs/snippets/coordinate_origins.py b/packages/zarr-indexing/docs/snippets/coordinate_origins.py
index 724312e5e8..aef3605379 100644
--- a/packages/zarr-indexing/docs/snippets/coordinate_origins.py
+++ b/packages/zarr-indexing/docs/snippets/coordinate_origins.py
@@ -19,7 +19,7 @@
 assert domain.narrow(-1).inclusive_min == (-1,)
 
 values = np.array([10, 20, 30, 40, 50])
-assert LazyArray.from_numpy(values).lazy[-1:].result().tolist() == [50]
+assert LazyArray.from_numpy(values)[-1:].result().tolist() == [50]
 # --8<-- [end:coordinate-origin]
 
 
diff --git a/packages/zarr-indexing/docs/snippets/grid_partition.py b/packages/zarr-indexing/docs/snippets/grid_partition.py
index 84879da0de..ab7f1ee38d 100644
--- a/packages/zarr-indexing/docs/snippets/grid_partition.py
+++ b/packages/zarr-indexing/docs/snippets/grid_partition.py
@@ -60,9 +60,9 @@ def read_box_through_tables(
 ) -> tuple[np.ndarray[Any, Any], list[tuple[int, ...]]]:
     """Assemble a box selection from the per-axis tables, one slice per chunk.
 
-    No projection is materialized: every column read here is a NumPy array of
-    the table, and the only per-chunk Python work is building the two selector
-    tuples the copy needs.
+    No paired projection objects are materialized. The consumer reads table
+    columns, constructs selectors, and assembles each chunk contribution,
+    including axis permutation and expansion where needed.
     """
     partition = plan_chunks(
         transform, dimension_grids_from_chunks(chunks, shape=source.shape)
diff --git a/packages/zarr-indexing/docs/snippets/integrations.py b/packages/zarr-indexing/docs/snippets/integrations.py
index 5699c0d319..8608c506e6 100644
--- a/packages/zarr-indexing/docs/snippets/integrations.py
+++ b/packages/zarr-indexing/docs/snippets/integrations.py
@@ -56,7 +56,7 @@ def _gather_and_scatter(
     for chunk_column in range(2)
 }
 zarr_source = RecordingChunkSource(zarr_chunks)
-zarr_view = LazyArray.from_numpy(zarr_image).with_parts((2, 2)).lazy[1, 0:4]
+zarr_view = LazyArray.from_numpy(zarr_image).with_parts((2, 2))[1, 0:4]
 ZARR_RESULT = np.empty(zarr_view.shape, dtype=zarr_image.dtype)
 shared_domains: list[tuple[IndexDomain, IndexDomain]] = []
 chunk_local_coords: list[tuple[tuple[int, ...], ...]] = []
@@ -123,7 +123,7 @@ def __getitem__(self, key: tuple[slice, ...]) -> np.ndarray[Any, Any]:
 
 
 viewport_source = RecordingArray(np.arange(12).reshape(3, 4), chunks=(2, 2))
-viewport = LazyArray(viewport_source).lazy[1, 0:4]
+viewport = LazyArray(viewport_source)[1, 0:4]
 VIEWPORT_READS_BEFORE_RESULT = tuple(viewport_source.keys)
 assert VIEWPORT_READS_BEFORE_RESULT == ()
 assert viewport.result().tolist() == [4, 5, 6, 7]
@@ -152,12 +152,12 @@ def materialize(view: LazyArray) -> Any:
 slab_source = RecordingArray(np.arange(100).reshape(10, 10), chunks=(4, 4))
 slab = LazyArray(slab_source)
 
-dense = slab.lazy[2:9, 1:8]  # a dense box: every stride 1
+dense = slab[2:9, 1:8]  # a dense box: every stride 1
 assert materialize(dense).shape == (7, 7)
 assert len(slab_source.keys) == 1  # one slab read; the source dispatches
 
 slab_source.keys.clear()
-gather = slab.lazy.oindex[[0, 9], [0, 9]]  # a query: keep the chunk parts
+gather = slab.oindex[[0, 9], [0, 9]]  # a query: keep the chunk parts
 assert materialize(gather).tolist() == [[0, 9], [90, 99]]
 assert len(slab_source.keys) == 4  # four covers, each inside one chunk
 assert all(
diff --git a/packages/zarr-indexing/docs/snippets/key_types.py b/packages/zarr-indexing/docs/snippets/key_types.py
new file mode 100644
index 0000000000..7917fc5eab
--- /dev/null
+++ b/packages/zarr-indexing/docs/snippets/key_types.py
@@ -0,0 +1,30 @@
+"""The type of a key decides whether it is read relative to the view or as absolute coordinates."""
+
+import numpy as np
+
+from zarr_indexing import IndexDomain, IndexTransform, LazyArray
+
+source = np.arange(30)
+
+# --8<-- [start:key-types]
+view = LazyArray(source)[10:20]
+assert view.transform.domain == IndexDomain((10,), (20,))
+
+# NumPy keys are positions relative to the view: 0 is its first element.
+relative = view[2:5]
+assert relative.result().tolist() == [12, 13, 14]
+assert view[-1].result() == 19
+
+# An IndexDomain key names absolute coordinates of the view's domain.
+absolute = view[IndexDomain((12,), (15,))]
+assert absolute.result().tolist() == [12, 13, 14]
+
+# An IndexTransform key composes onto the view; index the identity over the
+# view's domain to spell any selection in absolute coordinates.
+literal = IndexTransform.identity(view.transform.domain)
+assert view[literal[12:15]].result().tolist() == [12, 13, 14]
+assert view[literal[::-1]].result().tolist()[:2] == [19, 18]
+
+# Whichever key produced a view, its domain is absolute.
+assert relative.transform.domain == absolute.transform.domain == IndexDomain((12,), (15,))
+# --8<-- [end:key-types]
diff --git a/packages/zarr-indexing/docs/snippets/lazy_composition.py b/packages/zarr-indexing/docs/snippets/lazy_composition.py
index a4d9884b2b..88551d0023 100644
--- a/packages/zarr-indexing/docs/snippets/lazy_composition.py
+++ b/packages/zarr-indexing/docs/snippets/lazy_composition.py
@@ -7,8 +7,8 @@
 
 # --8<-- [start:lazy-composition]
 source = np.array([10, 11, 12, 13, 14, 15])
-view = LazyArray.from_numpy(source).lazy[2:5]
-composed = view.lazy[::-1].lazy[1:]
+view = LazyArray.from_numpy(source)[2:5]
+composed = view[::-1][1:]
 
 assert composed.result().tolist() == source[2:5][::-1][1:].tolist()
 # --8<-- [end:lazy-composition]
diff --git a/packages/zarr-indexing/docs/snippets/output_maps.py b/packages/zarr-indexing/docs/snippets/output_maps.py
index a78fc73b50..7daed4b63e 100644
--- a/packages/zarr-indexing/docs/snippets/output_maps.py
+++ b/packages/zarr-indexing/docs/snippets/output_maps.py
@@ -54,11 +54,9 @@ def resolve(transform: IndexTransform, values: np.ndarray[Any, Any]) -> np.ndarr
 # --8<-- [end:array-map]
 
 # --8<-- [start:constant-map]
-# ConstantMap reads one source coordinate for every request cell. No NumPy
-# selection spells this operation: source[0] drops the axis, and a repeated
-# fancy index source[[0, 0, 0, 0]] matches the values but degrades the
-# description to a coordinate list. The value-faithful counterpart is a
-# broadcast.
+# ConstantMap reads one source coordinate for every request cell. NumPy can
+# express the same values with source[[0, 0, 0, 0]] or with a broadcast.
+# The constant map represents the repeated coordinate without storing a list.
 repeat = IndexTransform(
     domain=IndexDomain.from_shape((4,)),
     output=(ConstantMap(offset=0),),
diff --git a/packages/zarr-indexing/examples/lazy_indexing_dask/README.md b/packages/zarr-indexing/examples/lazy_indexing_dask/README.md
index c9edb903ef..e8d5ab5d88 100644
--- a/packages/zarr-indexing/examples/lazy_indexing_dask/README.md
+++ b/packages/zarr-indexing/examples/lazy_indexing_dask/README.md
@@ -1,39 +1,45 @@
 # Lazy Indexing with Dask
 
 This example demonstrates how to use `zarr_indexing.LazyArray` with Dask, both as
-an array Dask can wrap and as a source of independent tasks, and compares the two
+an explicitly adapted array Dask can wrap and as a source of independent tasks, and compares the two
 ways of deferring an indexing operation.
 
 The example shows how to:
 
-- Pass a `LazyArray` — over a Zarr array or over a view of one — to
-  `dask.array.from_array`
+- Wrap a `LazyArray` — over a Zarr array or over a view of one — in
+  `EagerArrayAdapter` and pass the adapter to `dask.array.from_array`
 - Build one Dask task per partition from `parts()`, compute them in parallel, and
   place each result with the partition's `out_selection`
-- Read `is_complete` to tell which partitions cover a stored chunk completely
-- Rely on `__dask_tokenize__`, so that equal selections produce equal tokens and
-  Dask can cache and deduplicate the work
+- Read `is_complete` to inspect coverage of a partition cell
+- Inspect `__dask_tokenize__` for the example's equal source/selection pairs;
+  token equality can support task deduplication but does not promise persistent caching
 - Measure what a task graph costs for indexing-only work, against composing the
   same selections into one transform
 
-A `LazyArray` exposes no `chunks` attribute, so `dask.array.from_array` chooses
+The adapter exposes no `chunks` attribute, so `dask.array.from_array` chooses
 its own block size unless one is given. The partitioning that `parts()` reports
 is discovered from the wrapped array and is independent of Dask's blocks.
 
+`LazyArray[...]` returns another lazy view. `EagerArrayAdapter(view)[...]`
+returns materialized values, providing the block reads Dask expects. Import
+both classes from `zarr_indexing`. Use the adapter for `from_array`; passing
+a lazy view directly is not a reliable integration.
+
 ## Choosing Between Them
 
 If Dask is doing arithmetic across chunks, reductions, rechunking, or distributed
 execution, it is the right tool, and its task graph is what makes that work.
 
-If Dask is used *only* to defer indexing — take a view now, read it later, with
-no computation in between — then the graph is overhead. Dask slices the chunk
-grid on every indexing operation and records another layer, so composing
-selections costs time proportional to both the depth of the chain and the number
-of chunks in the array, and reading walks what was accumulated. `LazyArray`
-composes each selection into the single transform it already holds, so composing
-is independent of the depth of the chain, and reading enumerates only the
-partitions the selection touches. The last test in this example prints both, and
-the gap widens with the number of chunks and the number of selections.
+For indexing-only workloads, graph construction and scheduling can be an
+additional cost. The example measures repeated leading slices and reports graph
+layers and timings for the selected Dask version. It does not establish general
+complexity bounds or a guaranteed speedup: Dask can optimize graphs, and costs
+depend on the selection, chunk layout, and scheduler.
+
+`LazyArray` stores one composed transform rather than retaining a wrapper for
+each prior selection. Applying a chain still costs work for every operation;
+index-array composition may process arrays whose size depends on earlier
+selections. Reading also incurs partition planning and source I/O.
 
 ## Running the Example
 
diff --git a/packages/zarr-indexing/examples/lazy_indexing_dask/lazy_indexing_dask.py b/packages/zarr-indexing/examples/lazy_indexing_dask/lazy_indexing_dask.py
index d6ed43f322..891bd44472 100644
--- a/packages/zarr-indexing/examples/lazy_indexing_dask/lazy_indexing_dask.py
+++ b/packages/zarr-indexing/examples/lazy_indexing_dask/lazy_indexing_dask.py
@@ -24,7 +24,7 @@
 import zarr
 from dask.base import tokenize
 
-from zarr_indexing import LazyArray
+from zarr_indexing import EagerArrayAdapter, LazyArray
 
 
 @pytest.fixture
@@ -36,25 +36,25 @@ def source() -> zarr.Array:
 
 
 def test_from_array(source: zarr.Array) -> None:
-    """Hand a LazyArray to `dask.array.from_array`."""
+    """Adapt lazy selections for `dask.array.from_array`."""
     lazy = LazyArray(source)
 
-    # `from_array` needs `shape`, `dtype`, and `__getitem__`, which the wrapper
-    # provides. Each Dask block reads its own region through the wrapper.
-    array = da.from_array(lazy, chunks=(10, 10))
+    # `from_array` expects eager block indexing, which `EagerArrayAdapter`
+    # provides. Each Dask block reads its own region through the adapter.
+    array = da.from_array(EagerArrayAdapter(lazy), chunks=(10, 10))
     print(array)
     assert np.array_equal(array.compute(scheduler="threads"), source[:])
 
     # A view works the same way, and its shape is the shape of the selection.
-    view = LazyArray(source).lazy[5:35, 3:27]
-    array = da.from_array(view, chunks=(10, 10))
+    view = LazyArray(source)[5:35, 3:27]
+    array = da.from_array(EagerArrayAdapter(view), chunks=(10, 10))
     assert array.shape == (30, 24)
     assert np.array_equal(array.compute(scheduler="threads"), source[5:35, 3:27])
 
 
 def test_parts_as_tasks(source: zarr.Array) -> None:
     """Build one task per partition and compute them in parallel."""
-    view = LazyArray(source).lazy[5:35, 3:27]
+    view = LazyArray(source)[5:35, 3:27]
 
     # The partitioning is discovered from the wrapped array's chunks, so each
     # partition of the view lies within one stored chunk.
@@ -62,7 +62,8 @@ def test_parts_as_tasks(source: zarr.Array) -> None:
     print(f"{len(parts)} parts for a {view.shape} view of a {source.shape} array")
 
     # A partition carries a sub-view to resolve and where its result belongs, so
-    # the reads are independent and the placement needs no coordination.
+    # reads can run concurrently with this source and reader; assembly below
+    # places the returned blocks sequentially.
     @dask.delayed
     def read(part: object) -> np.ndarray:
         return part.view.result()
@@ -75,38 +76,35 @@ def read(part: object) -> np.ndarray:
     assert np.array_equal(result, source[5:35, 3:27])
 
     # `is_complete` reports whether a partition covers its whole partition of
-    # the base array, which a writer uses to choose between overwriting a chunk
-    # and reading it first.
+    # the base array. A writer also needs storage-unit alignment, value-order,
+    # and concurrency checks before using coverage to skip a read.
     complete = [part.box for part in parts if part.is_complete]
     print(f"{len(complete)} of {len(parts)} parts cover their chunk completely")
 
 
 def test_tokenize(source: zarr.Array) -> None:
-    """Deterministic tokens let Dask cache and deduplicate work."""
+    """Check token equality for these unchanged source and selection pairs."""
     lazy = LazyArray(source)
 
-    # Two wrappers over the same array and the same selection are the same task
-    # to Dask, whether or not they are the same Python object.
+    # These wrappers have equal tokens despite being different Python objects.
+    # Source mutation and token hooks affect whether cached results remain valid.
     assert tokenize(lazy) == tokenize(LazyArray(source))
-    assert tokenize(lazy.lazy[0:10]) == tokenize(LazyArray(source).lazy[0:10])
+    assert tokenize(lazy[0:10]) == tokenize(LazyArray(source)[0:10])
 
     # Different selections are different tasks.
-    assert tokenize(lazy.lazy[0:10]) != tokenize(lazy.lazy[10:20])
+    assert tokenize(lazy[0:10]) != tokenize(lazy[10:20])
 
-    # Selections that describe the same region are the same task, however they
-    # were composed.
-    assert tokenize(lazy.lazy[0:20].lazy[5:10]) == tokenize(lazy.lazy[5:10])
+    # These two slice chains serialize to the same transform and token.
+    assert tokenize(lazy[0:20][5:10]) == tokenize(lazy[5:10])
 
 
 def test_indexing_only_workload() -> None:
     """Compare an accumulating task graph with a fused transform.
 
-    Dask records each indexing operation as another graph layer, and slices the
-    chunk grid to build it, so composing selections costs time proportional to
-    the number of selections and the number of chunks. `LazyArray` composes each
-    selection into the single transform it already holds, so the cost of
-    composing does not grow with the depth of the chain, and reading resolves
-    that one transform rather than walking a graph.
+    This measures repeated leading slices at several depths. LazyArray retains
+    one composed transform, but the loop still performs each selection. Dask's
+    graph construction and execution costs depend on graph optimizations and
+    chunk layout; these measurements do not establish general complexity bounds.
 
     Timings are printed rather than asserted, since they depend on the machine.
     """
@@ -121,13 +119,13 @@ def dask_chain(depth: int) -> da.Array:
     def lazy_chain(depth: int) -> LazyArray:
         view = LazyArray.from_numpy(data)
         for _ in range(depth):
-            view = view.lazy[1:]
+            view = view[1:]
         return view
 
     # Read once through each path first, so the timings below exclude the cost
     # of importing and initializing the machinery.
     dask_chain(1)[:2].compute(scheduler="synchronous")
-    lazy_chain(1).lazy[:2].result()
+    lazy_chain(1)[:2].result()
 
     header = (
         f"{'selections':>10} {'dask compose':>13} {'dask read':>10} {'layers':>7}"
@@ -148,7 +146,7 @@ def lazy_chain(depth: int) -> LazyArray:
         lazy_compose = time.perf_counter() - start
 
         start = time.perf_counter()
-        from_lazy = view.lazy[:2].result()
+        from_lazy = view[:2].result()
         lazy_read = time.perf_counter() - start
 
         # Both paths describe the same selection, so they read the same data.
diff --git a/packages/zarr-indexing/examples/lazy_indexing_numpy/README.md b/packages/zarr-indexing/examples/lazy_indexing_numpy/README.md
index e76e065047..5da2eebc0a 100644
--- a/packages/zarr-indexing/examples/lazy_indexing_numpy/README.md
+++ b/packages/zarr-indexing/examples/lazy_indexing_numpy/README.md
@@ -6,16 +6,19 @@ index it without reading data.
 The example shows how to:
 
 - Wrap a NumPy array and read the forwarded `shape`, `dtype`, and `ndim`
-- Compose selections through `.lazy[...]`, `.lazy.oindex[...]`, and
-  `.lazy.vindex[...]`, and materialize the composed view once with `result()`
+- Compose selections through `[...]`, `.oindex[...]`, and
+  `.vindex[...]`, and materialize the composed view once with `result()`
+- Iterate lazy row views and write through a composed view with `write(values)`
+  or indexed assignment; writes finish synchronously on the original source
 - Tell a box selection (slices and integers, described by an interval and a step
   per dimension) from a query selection (points gathered through an index array)
   using `is_box`, `bounding_box()`, and `strides()`
 - Declare a partitioning with `with_parts()`, iterate it with `parts()`, and
   assemble a result from the partitions
 
-`LazyArray` wraps any object exposing `shape`, `dtype`, and `__getitem__`, so the
-same API applies to a Zarr array, and the partitioning is then discovered from
+`LazyArray` wraps compatible sources exposing `shape`, `dtype`, and basic
+slicing whose results can be converted to NumPy system memory. This includes
+a Zarr array, and the partitioning is then discovered from
 the array's chunks. The Dask example covers that case.
 
 ## Running the Example
diff --git a/packages/zarr-indexing/examples/lazy_indexing_numpy/lazy_indexing_numpy.py b/packages/zarr-indexing/examples/lazy_indexing_numpy/lazy_indexing_numpy.py
index ae29a7fc51..7c734d66f4 100644
--- a/packages/zarr-indexing/examples/lazy_indexing_numpy/lazy_indexing_numpy.py
+++ b/packages/zarr-indexing/examples/lazy_indexing_numpy/lazy_indexing_numpy.py
@@ -30,43 +30,56 @@ def test_wrap_and_compose() -> None:
     assert lazy.dtype == data.dtype
     assert lazy.ndim == 2
 
-    # `.lazy[...]` returns another LazyArray. No element of `data` is read.
-    view = lazy.lazy[2:10, ::2]
+    # `[...]` returns another LazyArray. No element of `data` is read.
+    view = lazy[2:10, ::2]
     print(view)
     assert view.shape == (8, 4)
 
     # Selections compose. Each step narrows the view; still nothing is read.
-    smaller = view.lazy[1:5, 1:3]
+    smaller = view[1:5, 1:3]
 
     # `result()` performs the read. NumPy is the reference for the whole chain.
     assert np.array_equal(smaller.result(), data[2:10, ::2][1:5, 1:3])
 
     # Selections use positional NumPy semantics: indices count from zero within
     # the current view, and negative indices count from the end.
-    assert np.array_equal(lazy.lazy[-1].result(), data[-1])
-    assert np.array_equal(lazy.lazy[::-1].result(), data[::-1])
+    assert np.array_equal(lazy[-1].result(), data[-1])
+    assert np.array_equal(lazy[::-1].result(), data[::-1])
 
-    # Orthogonal and vectorized indexing are available under the same accessor.
+    # Orthogonal and vectorized indexing also return lazy views.
     rows = np.array([9, 1, 4])
-    assert np.array_equal(lazy.lazy.oindex[rows, :].result(), data[rows, :])
+    assert np.array_equal(lazy.oindex[rows, :].result(), data[rows, :])
     cols = np.array([0, 3, 7])
-    assert np.array_equal(lazy.lazy.vindex[rows, cols].result(), data[rows, cols])
+    assert np.array_equal(lazy.vindex[rows, cols].result(), data[rows, cols])
 
-    # A LazyArray is also an ordinary duck array: __getitem__ reads immediately,
-    # and np.asarray materializes the view.
-    assert np.array_equal(lazy[2:4, 0], data[2:4, 0])
+    # Indexing remains lazy; np.asarray explicitly materializes the view.
+    assert isinstance(lazy[2:4, 0], LazyArray)
     assert np.array_equal(np.asarray(view), data[2:10, ::2])
 
 
+def test_iteration_and_writes() -> None:
+    """Iterate lazy rows and synchronously write through a composed view."""
+    data = np.arange(24).reshape(6, 4)
+    view = LazyArray.from_numpy(data)[1:5][::2]
+    rows = list(view)
+    assert all(isinstance(row, LazyArray) for row in rows)
+    np.testing.assert_array_equal(rows[1].result(), data[3])
+
+    assert view[:, 1:3].write(-1) is None
+    np.testing.assert_array_equal(data[[1, 3], 1:3], np.full((2, 2), -1))
+    view[1, 0] = 99
+    assert data[3, 0] == 99
+
+
 def test_box_and_query_selections() -> None:
     """Distinguish selections that describe a region from selections that gather points."""
     data = np.arange(12 * 8).reshape(12, 8)
     lazy = LazyArray.from_numpy(data)
 
-    # A box selection is built from slices and integers alone. It is described
+    # This box selection is built from slices and integers. It is described
     # completely by an interval and a step per dimension, so a consumer can
     # serve it as one strided read.
-    box = lazy.lazy[2:10, ::2]
+    box = lazy[2:10, ::2]
     print(f"box: is_box={box.is_box} bounding_box={box.bounding_box()} strides={box.strides()}")
     assert box.is_box
     assert box.bounding_box() == ((2, 10), (0, 7))
@@ -75,14 +88,15 @@ def test_box_and_query_selections() -> None:
     # A query selection gathers points through an index array. Its coordinates
     # are a lookup table, so `strides()` is undefined and `bounding_box()` is
     # the hull of the points rather than an exact description.
-    query = lazy.lazy.oindex[np.array([9, 1, 4]), :]
+    query = lazy.oindex[np.array([9, 1, 4]), :]
     print(f"query: is_box={query.is_box} bounding_box={query.bounding_box()}")
     assert not query.is_box
     assert query.strides() is None
     assert query.bounding_box() == ((1, 10), (0, 8))
 
-    # Composing a box onto a query keeps it a query.
-    assert not query.lazy[0:2, 0:2].is_box
+    # This slice retains an index-array map, so this particular view stays a query.
+    # Singleton gathers and later scalar indexing can instead collapse to a box.
+    assert not query[0:2, 0:2].is_box
 
 
 def test_parts() -> None:
@@ -92,7 +106,7 @@ def test_parts() -> None:
     # A plain NumPy array declares no partitioning, so `with_parts` states one.
     # Partitioning changes the granularity of reads, never the result.
     lazy = LazyArray.from_numpy(data).with_parts((4, 4))
-    view = lazy.lazy[2:10, ::2]
+    view = lazy[2:10, ::2]
 
     parts = list(view.parts())
     print(f"{len(parts)} parts")
@@ -109,7 +123,7 @@ def test_parts() -> None:
 
     # The partitioning is a read strategy, so a different one gives the same data.
     assert np.array_equal(
-        LazyArray.from_numpy(data).with_parts((5, 3)).lazy[2:10, ::2].result(), assembled
+        LazyArray.from_numpy(data).with_parts((5, 3))[2:10, ::2].result(), assembled
     )
 
 
diff --git a/packages/zarr-indexing/examples/system_memory_chunk_cache/README.md b/packages/zarr-indexing/examples/system_memory_chunk_cache/README.md
index d6271f9401..0369f290fb 100644
--- a/packages/zarr-indexing/examples/system_memory_chunk_cache/README.md
+++ b/packages/zarr-indexing/examples/system_memory_chunk_cache/README.md
@@ -23,7 +23,7 @@ explicit retry. The reader owns cache state and source reads, but not result
 shape or assembly.
 
 Each request calls `view.parts()` once and keeps the resulting tuple. The cache
-pins the tuple's chunk coordinates, then materializes with
+queues the tuple's chunk coordinates and defers eviction, then materializes with
 `view.result(parts=parts)`, so scheduling and assembly reuse one plan. Every
 reader call consumes the exact projection attached to its `ReadContext`; the
 reader does not invoke the chunk planner again.
@@ -34,6 +34,12 @@ a retained failure that does not retry implicitly, and an explicit retry after
 the source is repaired. The integration guide contains the detailed request
 table.
 
+Capacity counts resident chunks, not bytes, and is enforced after a successful
+request. A request can temporarily exceed it; a failed request skips that eviction
+step. Records, event history, and output/coordinate buffers are outside this count.
+The example assumes an unchanged source and one source/grid per reader; it has no
+cache invalidation for source mutation, and its mutable state is not thread-safe.
+
 This is synchronous system-memory reference architecture, not a
 production-ready cache, scheduler, renderer, or complete napari integration.
 Its types are intentionally not exported by `zarr_indexing`.
diff --git a/packages/zarr-indexing/examples/system_memory_chunk_cache/system_memory_chunk_cache.py b/packages/zarr-indexing/examples/system_memory_chunk_cache/system_memory_chunk_cache.py
index 1645d89b2c..92a9417309 100644
--- a/packages/zarr-indexing/examples/system_memory_chunk_cache/system_memory_chunk_cache.py
+++ b/packages/zarr-indexing/examples/system_memory_chunk_cache/system_memory_chunk_cache.py
@@ -182,7 +182,7 @@ def retry(self, chunk_coords: ChunkCoords) -> None:
 
     @contextmanager
     def request(self, required: tuple[ChunkCoords, ...]) -> Iterator[None]:
-        """Prepare every part and defer eviction until one request completes."""
+        """Prepare parts; evict after the outermost request succeeds, not on failure."""
         self._prepare(required)
         self._requests += 1
         try:
@@ -329,9 +329,10 @@ def __getitem__(self, key: Any) -> np.ndarray[Any, Any]:
 
     def _read(self, key: Any, *, orthogonal: bool) -> np.ndarray[Any, Any]:
         self.reader.projection_uses.clear()
-        lazy = self._lazy.lazy
+        lazy = self._lazy
         view = lazy.oindex[key] if orthogonal else lazy[key]
-        # One prepared tuple is the request plan: pin from it, then hand the
+        # One prepared tuple is the request plan: queue its chunks and defer
+        # eviction during the request, then hand the
         # same owned parts back to LazyArray for assembly without replanning.
         parts = tuple(view.parts())
         required = tuple(dict.fromkeys(part.base_coords for part in parts))
diff --git a/packages/zarr-indexing/justfile b/packages/zarr-indexing/justfile
index 44874bc0be..29f6ce885f 100644
--- a/packages/zarr-indexing/justfile
+++ b/packages/zarr-indexing/justfile
@@ -2,16 +2,18 @@
 # directory as the working directory regardless of where `just` is invoked.
 
 # List available recipes
+# Quoted arguments must survive delegation from the root Justfile.
+set positional-arguments
+
 default:
     @just --list
 
-# Nothing here imports `zarr`; the suite runs against the repo-root
-# environment so it shares the parent project's pinned test toolchain
-# (hypothesis, ruff, pyright). The repo is not a uv workspace, so this package
-# is layered in as an editable overlay — the same invocation CI uses.
+# The suite runs against the root test environment, which also supplies
+# Zarr for the Dask example. This package is layered in as an editable
+# overlay, using the same test invocation as CI.
 # Run the test suite; extra args are passed to pytest
 test *args:
-    uv run --project ../.. --group test --with-editable . python -m pytest tests src/zarr_indexing {{ args }}
+    uv run --project ../.. --group test --with-editable . python -m pytest tests src/zarr_indexing "$@"
 
 # TensorStore is the oracle for the parity suites, which skip without it. It
 # ships binary wheels only, so it rides in as a run-time overlay rather than
@@ -19,10 +21,10 @@ test *args:
 # gate the CI job that calls this on the matrix version.
 # Run the tensorstore parity suites; extra args are passed to pytest
 test-tensorstore *args:
-    uv run --project ../.. --group test --with-editable . --with 'tensorstore>=0.1.84' python -m pytest tests/test_ndsel_tensorstore.py tests/test_tensorstore_parity.py {{ args }}
+    uv run --project ../.. --group test --with-editable . --with 'tensorstore>=0.1.84' python -m pytest tests/test_ndsel_tensorstore.py tests/test_tensorstore_parity.py "$@"
 
 # Lint with the same invocation CI uses. Ruff is pinned to the repo-wide
-# version (see pyproject.toml [dependency-groups] docs); bump together.
+# version in the root .pre-commit-config.yaml; bump together.
 lint:
     uvx ruff@0.16.0 check .
 
@@ -30,7 +32,8 @@ lint:
 typecheck:
     uv run --group test --with pyright pyright
 
-# Run everything CI runs for this package
+# Run these checks with the locally selected interpreter and dependencies;
+# CI also exercises its configured Python-version matrix
 check: lint typecheck test test-tensorstore docs-check
 
 # Preview the changelog that the next release would generate
diff --git a/packages/zarr-indexing/mkdocs.yml b/packages/zarr-indexing/mkdocs.yml
index a541e5d599..0f8b8ffa4e 100644
--- a/packages/zarr-indexing/mkdocs.yml
+++ b/packages/zarr-indexing/mkdocs.yml
@@ -51,6 +51,8 @@ nav:
       - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.grid</code>': api/grid.md
       - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.lazy_array</code>': api/lazy_array.md
       - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.reader</code>': api/reader.md
+      - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.writer</code>': api/writer.md
+      - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.eager</code>': api/eager.md
       - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.boundary</code>': api/boundary.md
       - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.json</code>': api/json.md
       - '<code class="doc-symbol doc-symbol-toc doc-symbol-module"></code> <code>zarr_indexing.messages</code>': api/messages.md
@@ -151,7 +153,7 @@ markdown_extensions:
   - pymdownx.snippets:
       # The package root is last so docs/release-notes.md can include the
       # towncrier-managed CHANGELOG.md without moving it out of the package
-      # root, where PyPI and GitHub readers expect it.
+      # root, where it is distributed and linked from the package metadata.
       base_path: [docs, examples, .]
       # Fail the build on an unresolvable include or missing region instead
       # of silently rendering nothing. tests/test_doc_examples.py mirrors
diff --git a/packages/zarr-indexing/pyproject.toml b/packages/zarr-indexing/pyproject.toml
index 953a432f07..f9dff85ac8 100644
--- a/packages/zarr-indexing/pyproject.toml
+++ b/packages/zarr-indexing/pyproject.toml
@@ -48,19 +48,14 @@ Changelog = "https://github.com/zarr-developers/zarr-python/blob/main/packages/z
 Documentation = "https://zarr-indexing.readthedocs.io/"
 
 [dependency-groups]
-# The package and its tests import nothing from `zarr`: chunk resolution
-# consumes the `DimensionGridLike` protocol and the tests use this package's
-# own grids (`zarr_indexing.grid`). The suite is nevertheless run from the
-# repo-root environment (`just test`, the invocation CI uses) so that it sees
-# the same pinned toolchain — hypothesis, ruff, pyright — as the parent
-# project; the repo is not a uv workspace, so this package is layered in as an
-# editable overlay. `hypothesis` arrives via the `testing` extra, which is
-# what `zarr_indexing.testing` needs; the repo-root `test` group pins the
-# exact version CI runs against. Bump the two together.
+# Package tests use the local grid protocol and grid implementations. The
+# repository recipes layer this package into the root test environment.
+# This test group and the optional testing extra both declare Hypothesis;
+# keep their supported minimum versions aligned.
 test = ["pytest", "hypothesis>=6.160.0"]
 docs = [
-    # Pins match the zarr-python docs environment in the repo-root
-    # pyproject.toml so the two sites render with the same toolchain.
+    # Documentation tooling for this package. These pins are maintained here
+    # and can differ from the parent project's tooling versions.
     "mkdocs-material==9.7.7",
     "mkdocs==1.6.1",
     "mkdocstrings==1.0.6",
@@ -83,7 +78,7 @@ packages = ["src/zarr_indexing"]
 
 # An allowlist, so nothing that merely happens to sit in the package directory
 # — a scratch script, a stray notebook — can ride along in a release. The list
-# keeps an sdist self-testing: `tests/` carries the vendored ndsel conformance
+# includes test assets in the sdist: `tests/` carries the vendored ndsel conformance
 # corpus, and `tests/test_doc_examples.py` executes `docs/snippets/*.py` and
 # `examples/*/*.py`, so those are part of the suite rather than decoration.
 # `pyproject.toml`, `README.md` and `LICENSE.txt` are added by hatchling itself.
@@ -104,17 +99,17 @@ extend = "../../pyproject.toml"
 target-version = "py312"
 
 [tool.ruff.lint.per-file-ignores]
-# Chunk discovery and __dask_tokenize__ deliberately catch Exception: a
-# foreign source's attributes may fail arbitrarily and discovery must degrade
-# to "no information"; a token call must never raise. Configured here (not as
-# noqa comments) because the pinned pre-commit ruff and the floating CI ruff
-# disagree on whether these rules fire, and RUF100 strips the comments.
+# Chunk discovery deliberately catches Exception: a foreign source's
+# attributes may fail, so this path provides fallback metadata. Configured here (not as
+# noqa comments) because different ruff versions
+# have differed on whether these rules fire; RUF100 can remove unused noqa comments.
 "src/zarr_indexing/lazy_array.py" = ["BLE001", "S110"]
 
 [tool.pytest.ini_options]
 minversion = "7"
 # src is collected for its doctests: every public object's Examples section
-# executes under --doctest-modules, so the documented examples cannot rot.
+# is eligible for --doctest-modules. Passing examples do not verify all prose
+# contracts or optional-dependency paths.
 testpaths = ["tests", "src/zarr_indexing"]
 pythonpath = ["."]
 xfail_strict = true
@@ -137,13 +132,8 @@ include = [
 enableExperimentalFeatures = true
 typeCheckingMode = "strict"
 pythonVersion = "3.12"
-# This strict config was written for zarr-metadata's JSON/dataclass-shaped
-# code. zarr-indexing is numpy-heavy, and numpy's stubs return partially
-# unknown types (e.g. `ndarray[Unknown, Unknown]`, `dtype[Unknown]`) even for
-# fully-typed call sites, so the reportUnknown* family below cannot reasonably
-# be satisfied here. Downgraded to warnings (not silenced) rather than
-# disabled outright, and CI (which only fails the pyright job on errors, not
-# warnings) still surfaces them for visibility.
+# Partially unknown types from NumPy stubs are reported as warnings. CI's
+# pyright invocation fails on errors, while retaining these warnings in its output.
 reportUnknownVariableType = "warning"
 reportUnknownArgumentType = "warning"
 reportUnknownMemberType = "warning"
diff --git a/packages/zarr-indexing/src/zarr_indexing/__init__.py b/packages/zarr-indexing/src/zarr_indexing/__init__.py
index b44c6d2a9c..866630b5c0 100644
--- a/packages/zarr-indexing/src/zarr_indexing/__init__.py
+++ b/packages/zarr-indexing/src/zarr_indexing/__init__.py
@@ -14,7 +14,7 @@
 - `IndexTransform.compose` — chain two transforms into one
 
 `LazyArray` wraps a system-memory/basic-indexing source and gives it deferred
-indexing through `.lazy[...]`, yielding its reads as `Partition`s. Other
+indexing through `view[...]`, yielding its reads as `Partition`s. Other
 backends use an explicit `Reader` adapter.
 
 `plan_chunks` projects a transform through a caller-selected chunk grid without
@@ -39,6 +39,7 @@
     plan_chunks,
 )
 from zarr_indexing.domain import IndexDomain
+from zarr_indexing.eager import EagerArrayAdapter
 from zarr_indexing.errors import BoundsCheckError, VindexInvalidSelectionError
 from zarr_indexing.grid import (
     ChunkGrid,
@@ -93,6 +94,7 @@
     "DimensionGrid",
     "DimensionGridLike",
     "DimensionMap",
+    "EagerArrayAdapter",
     "EdgeDimensionGrid",
     "FixedDimension",
     "GridPartition",
diff --git a/packages/zarr-indexing/src/zarr_indexing/_composition.py b/packages/zarr-indexing/src/zarr_indexing/_composition.py
index f90ea26fa7..ab92ce45bf 100644
--- a/packages/zarr-indexing/src/zarr_indexing/_composition.py
+++ b/packages/zarr-indexing/src/zarr_indexing/_composition.py
@@ -15,7 +15,8 @@
   composing it with an outer `ArrayMap` leaves the index array alone and
   rescales around it.
 - An `ArrayMap` inner map must be *evaluated* at the coordinates the outer
-  transform produces, which is the only case that touches array data.
+  transform produces. This case gathers from the inner lookup table; other
+  cases can still inspect or copy index arrays during validation/construction.
 """
 
 from __future__ import annotations
@@ -43,7 +44,10 @@ def compose(outer: IndexTransform, inner: IndexTransform) -> IndexTransform:
     `inner` maps intermediate coords (rank n) to output coords (rank p).
     The result maps user coords (rank m) to output coords (rank p).
 
-    Precondition: `outer.output_rank == inner.domain.ndim`.
+    The output rank of `outer` must equal the input rank of `inner`, and every
+    coordinate produced by a nonempty `outer` must lie in `inner.domain`.
+    A rank mismatch raises `ValueError`; out-of-domain coordinates raise
+    `BoundsCheckError`.
 
     Examples
     --------
diff --git a/packages/zarr-indexing/src/zarr_indexing/_wire.py b/packages/zarr-indexing/src/zarr_indexing/_wire.py
index c3e6fd82b6..75f6db8e4a 100644
--- a/packages/zarr-indexing/src/zarr_indexing/_wire.py
+++ b/packages/zarr-indexing/src/zarr_indexing/_wire.py
@@ -2,9 +2,9 @@
 
 Package-private: the types that serialize themselves (`IndexDomain`,
 `IndexTransform`, the output map kinds) all need these, so they cannot live in
-any one of them, and they are not API. The three engine constraints named in
-[`zarr_indexing.json`][zarr_indexing.json] — finite bounds, implicit bounds
-lowering by value, integer `index_array` content — are enforced here.
+any one of them, and they are not API. Domain bounds, index-array bounds,
+implicit bounds lowering by value, and integer `index_array` content are
+handled here, as described in [`zarr_indexing.json`][zarr_indexing.json].
 """
 
 from __future__ import annotations
@@ -13,13 +13,37 @@
 
 import numpy as np
 
-from zarr_indexing.messages import NdselError
+from zarr_indexing.messages import NdselError, validate_index_array_bounds
 
 if TYPE_CHECKING:
     from zarr_indexing.domain import IndexDomain
     from zarr_indexing.json import BoundJSON
 
 
+def check_index_array_bounds(array: np.ndarray[Any, Any], bounds: Any, where: str) -> None:
+    """Validate every raw index value against an inclusive interval.
+
+    Validate interval syntax even for empty arrays. Once checked, immutable
+    index coordinates need no retained constraint. Use Python integer extrema
+    to avoid overflow or floating-point rounding at integer limits.
+    """
+    lo, hi = validate_index_array_bounds(bounds, where)
+    if array.size == 0 or (lo == "-inf" and hi == "+inf"):
+        return
+    minimum, maximum = int(array.min()), int(array.max())
+    if (
+        lo == "+inf"
+        or hi == "-inf"
+        or (isinstance(lo, int) and minimum < lo)
+        or (isinstance(hi, int) and maximum > hi)
+    ):
+        raise NdselError(
+            "invalid_json",
+            f"{where}.index_array values [{minimum}, {maximum}] are outside "
+            f"index_array_bounds {bounds!r}",
+        )
+
+
 def lower_bound(bound: BoundJSON, where: str) -> int:
     """Lower a canonical bound to a finite integer, rejecting infinities.
 
@@ -47,12 +71,28 @@ def lower_index_array(raw: Any, where: str) -> np.ndarray[Any, np.dtype[np.intp]
     and 0. Strings raise here rather than leaking NumPy's own conversion error.
     """
     if not isinstance(raw, list):
-        # A bare integer would become a rank-0 array and then be widened into a
-        # length-1 map, so a document that names no cells would select one.
+        # The wire representation requires a nested array, not a scalar.
         raise NdselError(
             "invalid_json",
             f"{where} must be an array of integers, got {raw!r}",
         )
+    # Validate before NumPy inference can coerce mixed booleans to integers or
+    # conversion to intp can wrap unsigned coordinates.
+    limits = np.iinfo(np.intp)
+    pending = [raw]
+    while pending:
+        for value in pending.pop():
+            if isinstance(value, list):
+                pending.append(value)
+            elif isinstance(value, (bool, np.bool_)) or not isinstance(value, (int, np.integer)):
+                dtype = np.asarray(value).dtype.name
+                raise NdselError(
+                    "invalid_json", f"{where} must hold integers, got {dtype}: {value!r}"
+                )
+            elif not limits.min <= value <= limits.max:
+                raise NdselError(
+                    "invalid_json", f"{where} coordinate {value} is outside intp range"
+                )
     try:
         arr = np.asarray(raw)
     except (TypeError, ValueError) as exc:
@@ -88,16 +128,17 @@ def full_rank_index_array(
 ) -> np.ndarray[Any, np.dtype[np.intp]]:
     """Give an incoming `index_array` the input rank the engine requires.
 
-    ndsel leaves index-array rank unvalidated, so a conformant producer may send
-    an array of lower rank that broadcasts against the domain. A non-empty one
-    is aligned to the *trailing* input dimensions, which is how NumPy broadcasts
-    and how a producer omitting leading singletons means it to be read.
+    ndsel intends index arrays to have the input rank, but defers validating
+    that constraint. This engine also accepts lower-rank arrays, aligning them
+    to the *trailing* input dimensions as in NumPy broadcasting. This extension
+    does not imply other ndsel consumers accept the same document.
 
     An empty array is a different matter: `[]` is the only spelling of every
     empty shape once the leading axis is the zero-length one, so the axis it
-    varies over cannot be read off it. It is recovered from the domain, which
-    can only be empty on the axis in question — and rejected when the domain
-    leaves that ambiguous. This package never emits such a document (an empty
+    varies over cannot be read off it. When ranks differ, this engine recovers
+    a shape with the domain's single empty axis and singleton axes elsewhere;
+    it rejects recovery if the domain has zero or multiple empty axes.
+    This package never emits such a document (an empty
     map is degenerate and collapses to a constant, as TensorStore's does), so
     this path exists for external producers alone.
     """
diff --git a/packages/zarr-indexing/src/zarr_indexing/boundary.py b/packages/zarr-indexing/src/zarr_indexing/boundary.py
index c4831715c4..6574bded3f 100644
--- a/packages/zarr-indexing/src/zarr_indexing/boundary.py
+++ b/packages/zarr-indexing/src/zarr_indexing/boundary.py
@@ -13,11 +13,9 @@
 
 Note
 ----
-`zarr.Array` currently carries its own copy of this normalization, tuned to a
-different boundary contract (`Array.lazy[...]` deliberately exposes the literal
-dialect, so a view's coordinates keep their meaning across composition). This
-module is the generic, zarr-free version used by `LazyArray`; consolidating
-zarr's copy onto it is left to a follow-up.
+This module provides the positional boundary used by `LazyArray`, independently
+of Zarr's own array indexers. Direct `IndexTransform` indexing continues to use
+literal coordinates.
 """
 
 from __future__ import annotations
@@ -132,8 +130,8 @@ def _expanded_axis_walk(entries: tuple[Any, ...], ndim: int, mode: SelectionMode
     """The starting axis each entry addresses, with an ellipsis expanded.
 
     The returned list has one entry per element of `entries`; the value for an
-    `Ellipsis` (or a `newaxis`) is the axis it starts at, which is also the axis
-    the following entry resumes from once the skipped axes are accounted for.
+    `Ellipsis` (or a `newaxis`) is the axis it starts at. The following entry
+    advances past the ellipsis's skipped axes; a `newaxis` consumes no axis.
     """
     for sel in entries:
         if is_bool_scalar(sel):
@@ -210,11 +208,9 @@ def split_scalar_axes(
     scalar with the advanced indices for the purpose of placing the broadcast
     result, so the two disagree when a scalar and an index array are separated:
     `a[0, ..., [1, 2]]` has shape `(2, 3)` for a `(2, 3, 4)` array, where
-    `a[0][..., [1, 2]]` has shape `(3, 2)`. The earlier claim here that they
-    always agree rested on `a[0, [1, 2], :]`, where the indices are adjacent and
-    they happen to. Scalar-first is the documented dialect (see the `lazy_array`
-    module docstring) — the divergence is deliberate, and this note exists so
-    that the correct end is not "fixed" later.
+    `a[0][..., [1, 2]]` has shape `(3, 2)`. Scalar-first processing is the
+    wrapper's indexing dialect; it does not implement NumPy's full advanced-axis
+    placement rules.
 
     Parameters
     ----------
diff --git a/packages/zarr-indexing/src/zarr_indexing/chunk_resolution.py b/packages/zarr-indexing/src/zarr_indexing/chunk_resolution.py
index 6d14f0d2f6..01383b8e34 100644
--- a/packages/zarr-indexing/src/zarr_indexing/chunk_resolution.py
+++ b/packages/zarr-indexing/src/zarr_indexing/chunk_resolution.py
@@ -26,13 +26,14 @@
 - `JointSet` — one connected index-array component. Arrays sharing input
   axes are grouped together; independent components remain separate tables.
 
-A projection is one row of each table combined. Building the tables costs the
-sum of the touched chunks per axis rather than their product, rows are
-materialized only on request, and a consumer may read the tables directly
-instead. Two output maps that read one input axis through a `DimensionMap`
-(a diagonal, which no selection produces) have no factored form and are
-rejected with `ValueError`; a correlated index array varying over an axis a
-`DimensionMap` also reads is rejected with `NotImplementedError`.
+A projection is one row of each table combined. Independent strided tables
+resolve each axis separately rather than walking their Cartesian product.
+Index-array tables also scan and group lookup points, sorting them when
+needed. Projection rows are materialized only on request, and a consumer may
+read the tables directly instead. This planner does not support affine maps
+sharing input axes: two affine maps sharing an axis raise `ValueError`, while
+an index array varying over an axis also read by an affine map raises
+`NotImplementedError`.
 """
 
 from __future__ import annotations
@@ -89,7 +90,9 @@ class ChunkProjection:
         Mapping from the shared synthetic domain to request coordinates.
     coverage
         Whether the request is proven to cover the whole grid cell exactly
-        once. Fancy selections are conservatively ``"unknown"``.
+        once. Projections retaining ArrayMaps or survivor arrays are
+        conservatively ``"unknown"``. A singleton fancy selection can simplify
+        to a ConstantMap and receive a proven ``"full"`` or ``"partial"`` result.
 
     Examples
     --------
@@ -634,7 +637,14 @@ def _strided_set(
 
 def _indexed_set(out_dim: int, m: ArrayMap, dg: DimensionGridLike) -> IndexedSet:
     dependent = m.dependent_axis
-    assert dependent is not None
+    if dependent is None:
+        # `_partition_transform` sends every map that varies over no axis down
+        # the joint (general) path; an orthogonal map always has its one axis.
+        raise RuntimeError(
+            f"output dimension {out_dim} has an index array of shape "
+            f"{m.index_array.shape} that varies over no input axis; it cannot be "
+            "partitioned as an orthogonal map"
+        )
     flat = m.index_array.reshape(-1)
     n = int(flat.size)
     storage = checked_affine(m.offset, m.stride, flat)
@@ -678,12 +688,13 @@ def _chunk_keys(
     n = int(chunk_ids[0].size)
     if len(chunk_ids) == 1:
         return np.asarray(chunk_ids[0], dtype=np.intp)
-    # Mixed-radix key with the first dimension most significant.
+    # Mixed-radix key with the first dimension most significant. Negative
+    # chunk ids do not fit these zero-based digits; group their tuples directly.
     keys = np.zeros(n, dtype=np.intp)
     multiplier = 1
     for ids in reversed(chunk_ids):
         radix = int(ids.max()) + 1
-        if multiplier * radix >= 2**62:
+        if int(ids.min()) < 0 or multiplier * radix >= 2**62:
             stacked = np.stack([np.asarray(i, dtype=np.intp).ravel() for i in chunk_ids], axis=1)
             _, inverse = np.unique(stacked, axis=0, return_inverse=True)
             return np.asarray(inverse, dtype=np.intp).reshape(-1)
diff --git a/packages/zarr-indexing/src/zarr_indexing/domain.py b/packages/zarr-indexing/src/zarr_indexing/domain.py
index b42bd04ccc..67afcbaf6b 100644
--- a/packages/zarr-indexing/src/zarr_indexing/domain.py
+++ b/packages/zarr-indexing/src/zarr_indexing/domain.py
@@ -82,12 +82,10 @@ def __post_init__(self) -> None:
     def _unchecked(
         cls, inclusive_min: tuple[int, ...], exclusive_max: tuple[int, ...]
     ) -> IndexDomain:
-        """Build an unlabeled domain from bounds the caller has already established.
+        """Build an unlabeled domain from validated bounds.
 
-        Skips `__post_init__`. For internal producers that derive bounds from an
-        already-valid domain — chunk resolution builds two domains per chunk,
-        and re-validating them was a measurable share of a plan's cost.
-        """
+        Skip __post_init__; internal callers must ensure equal bound lengths
+        and inclusive_min <= exclusive_max in every dimension."""
         domain = object.__new__(cls)
         object.__setattr__(domain, "inclusive_min", inclusive_min)
         object.__setattr__(domain, "exclusive_max", exclusive_max)
@@ -139,10 +137,11 @@ def contains(self, index: tuple[int, ...]) -> bool:
         )
 
     def contains_domain(self, other: IndexDomain) -> bool:
-        """Whether every coordinate of `other` lies inside this domain.
+        """Whether `other` has the same rank and bounds enclosed by this domain.
 
-        An empty `other` within this domain's bounds is contained. A rank
-        mismatch returns `False` rather than raising.
+        Empty domains are still checked by their bounds: an empty `other`
+        located outside this domain returns `False`, unlike empty-set
+        containment. A rank mismatch returns `False` rather than raising.
         """
         if other.ndim != self.ndim:
             return False
@@ -209,13 +208,9 @@ def narrow(self, selection: Any) -> IndexDomain:
         Raises
         ------
         BoundsCheckError
-            If a bound lies outside this domain. A slice bound used to be
-            clamped instead, so `narrow(slice(-3, None))` on `[0, 10)` quietly
-            returned the whole axis — reading as the NumPy spelling of "the last
-            three" and answering with something else — and `narrow(slice(20,
-            30))` returned a domain its own parent did not contain. The rest of
-            the algebra states no clamping and no negative wrapping as an
-            invariant and enforces it; this is the one place that did not.
+            If an integer index or explicit slice bound lies outside this domain.
+            Bounds are checked as literal coordinates, without clamping or
+            negative-index wrapping.
         """
         normalized = _normalize_selection(selection, self.ndim)
         new_inclusive_min: list[int] = []
diff --git a/packages/zarr-indexing/src/zarr_indexing/eager.py b/packages/zarr-indexing/src/zarr_indexing/eager.py
new file mode 100644
index 0000000000..16aad1eb65
--- /dev/null
+++ b/packages/zarr-indexing/src/zarr_indexing/eager.py
@@ -0,0 +1,57 @@
+"""Explicit eager indexing for consumers such as Dask's ``from_array``."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from zarr_indexing.lazy_array import LazyArray
+
+
+class EagerArrayAdapter:
+    """Expose an eager array interface over a lazy view.
+
+    Constructing the adapter does not read source values. Indexing materializes
+    the selected view in fresh memory, using its existing reader and partitioning.
+    Tokenization delegates to the view's source-token contract and may read data.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from zarr_indexing import LazyArray
+    >>> view = LazyArray(np.arange(8))[1::2]
+    >>> EagerArrayAdapter(view)[1:3]
+    array([3, 5])
+    """
+
+    __slots__ = ("_view",)
+
+    def __init__(self, view: LazyArray) -> None:
+        self._view = view
+
+    @property
+    def shape(self) -> tuple[int, ...]:
+        """Shape of the selected view."""
+        return self._view.shape
+
+    @property
+    def ndim(self) -> int:
+        """Number of dimensions of the selected view."""
+        return self._view.ndim
+
+    @property
+    def dtype(self) -> Any:
+        """Data type reported by the source."""
+        return self._view.dtype
+
+    def __getitem__(self, selection: Any) -> Any:
+        """Read a basic selection into fresh memory."""
+        return self._view[selection].result()
+
+    def __array__(self, dtype: Any = None, copy: bool | None = None) -> Any:
+        """Materialize using the view's NumPy conversion contract."""
+        return self._view.__array__(dtype=dtype, copy=copy)
+
+    def __dask_tokenize__(self) -> tuple[Any, ...]:
+        """Distinguish eager tasks while preserving the source identity contract."""
+        return (type(self).__qualname__, self._view.__dask_tokenize__())
diff --git a/packages/zarr-indexing/src/zarr_indexing/errors.py b/packages/zarr-indexing/src/zarr_indexing/errors.py
index efd3b1ecd6..24fc6c6ba6 100644
--- a/packages/zarr-indexing/src/zarr_indexing/errors.py
+++ b/packages/zarr-indexing/src/zarr_indexing/errors.py
@@ -5,8 +5,8 @@
 
 `zarr.errors` defines classes of the same names, and they are *not* these
 objects: `zarr.errors.BoundsCheckError is BoundsCheckError` is false. Catching
-zarr's around a call into this package therefore catches nothing but their
-shared `IndexError` base. Import these from here.
+zarr's class does not catch this package's errors. Import these from here,
+or catch their shared built-in `IndexError` base to handle both libraries.
 """
 
 from __future__ import annotations
@@ -34,7 +34,7 @@ class VindexInvalidSelectionError(IndexError):
     >>> import numpy as np
     >>> from zarr_indexing import LazyArray
     >>> view = LazyArray.from_numpy(np.arange(12).reshape(3, 4))
-    >>> view.lazy.vindex[np.array([0, 2]), :]
+    >>> view.vindex[np.array([0, 2]), :]
     Traceback (most recent call last):
         ...
     zarr_indexing.errors.VindexInvalidSelectionError: ...
diff --git a/packages/zarr-indexing/src/zarr_indexing/grid.py b/packages/zarr-indexing/src/zarr_indexing/grid.py
index 20ad3f95c2..bd350eeebe 100644
--- a/packages/zarr-indexing/src/zarr_indexing/grid.py
+++ b/packages/zarr-indexing/src/zarr_indexing/grid.py
@@ -41,7 +41,9 @@ class DimensionGridLike(Protocol):
     def index_to_chunk(self, idx: int) -> int:
         """Map a global source index to the index of the chunk that contains it.
 
-        Implementers must raise `IndexError` when `idx` lies outside `[0, extent)`.
+        Raise `IndexError` outside the coordinates supported by the grid.
+        The built-in bounded grids use `[0, extent)`; custom grids may support
+        negative coordinates or an unbounded region.
         """
         ...
 
@@ -56,7 +58,8 @@ def chunk_size(self, chunk_ix: int) -> int:
     def indices_to_chunks(self, indices: npt.NDArray[np.intp]) -> npt.NDArray[np.intp]:
         """Vectorized `index_to_chunk`: map global source indices to chunk indices.
 
-        Implementers must raise `IndexError` if any index lies outside `[0, extent)`.
+        Raise `IndexError` if any index is outside the grid's supported region,
+        consistently with the scalar method.
         """
         ...
 
@@ -163,7 +166,10 @@ def with_extent(self, new_extent: int) -> FixedDimension:
         return FixedDimension(size=self.size, extent=new_extent)
 
     def resize(self, new_extent: int) -> FixedDimension:
-        """Return a copy resized to `new_extent`; the fixed chunk size covers any new extent."""
+        """Return a copy resized to `new_extent`, retaining the chunk size.
+
+        A zero chunk size is supported only for an empty extent and cannot grow.
+        """
         return FixedDimension(size=self.size, extent=new_extent)
 
     @property
@@ -351,8 +357,9 @@ def indices_to_chunks(self, indices: npt.NDArray[np.intp]) -> npt.NDArray[np.int
     def with_extent(self, new_extent: int) -> DimensionGrid:
         """Return a grid with the existing chunk layout re-clipped to `new_extent`.
 
-        Implementers must not invent new grid cells: raise `ValueError` when the declared
-        layout cannot cover `new_extent`.
+        Preserve the existing layout rule: a fixed positive chunk size can
+        cover a larger extent without changing its size; explicit edge lists
+        raise `ValueError` if their sum cannot cover `new_extent`.
         """
         ...
 
diff --git a/packages/zarr-indexing/src/zarr_indexing/json.py b/packages/zarr-indexing/src/zarr_indexing/json.py
index 8bf42c74a5..59d45d1678 100644
--- a/packages/zarr-indexing/src/zarr_indexing/json.py
+++ b/packages/zarr-indexing/src/zarr_indexing/json.py
@@ -1,7 +1,7 @@
 """The canonical ndsel wire vocabulary, and the rules for lowering it.
 
-This is the **engine layer**. Where `messages.py` is pure JSON→JSON and imposes
-no array constraints, this module holds the JSON shapes a canonical ndsel body
+This is the **engine layer**. Where `messages.py` is pure JSON→JSON,
+this module holds the JSON shapes a canonical ndsel body
 takes (spec section 4.3, as produced by `zarr_indexing.messages.normalize_ndsel`)
 together with the lowering rules that turn one into the numpy-backed engine
 representation.
@@ -10,10 +10,13 @@
 its one serialization: `IndexTransform.to_json` / `from_json`,
 `IndexDomain.to_json` / `from_json`, and `to_json` on each output map kind,
 with `output_index_map_from_json` in `zarr_indexing.output_map` dispatching the
-wire's tagged union back to the right kind. This module is what they share.
+wire's structurally discriminated union back to the right kind. This module is what they share.
 
-Three engine constraints live **here and only here**:
+The engine lowering rules include:
 
+- **Validated index arrays.** Raw index values must satisfy the inclusive
+  `index_array_bounds` before offset and stride are applied. Lowering checks
+  all supplied values eagerly; validated immutable maps need not retain bounds.
 - **Finite bounds.** An `IndexDomain` addresses a finite array, so a canonical
   body carrying a `"-inf"`/`"+inf"` bound cannot be lowered; `from_json` raises.
 - **Implicit bounds lower by value.** The `[n]`-bracket implicit/explicit flag
@@ -42,10 +45,10 @@
    dimension is — the full-rank invariant makes every axis either 1 or the
    domain's extent — so nothing is ever read through it and the emptiness is
    carried by the domain, which is emitted separately. TensorStore does the
-   same: `t[ts.d[0][[]]]` is `out[0] = 0`, emitted as `{}`. Emitting the array
-   instead would produce a document neither implementation could load, because
-   `ndarray.tolist()` renders every empty array as `[]` once the leading axis
-   is the zero-length one, and nested lists cannot spell the shape back —
+   same: `t[ts.d[0][[]]]` is `out[0] = 0`, emitted as `{}`. This avoids losing
+   trailing shape information: `ndarray.tolist()` renders every empty array as
+   `[]` once the leading axis is zero-length, and nested lists cannot spell
+   the shape back —
    `[[]]` is `(1, 0)` and nothing spells `(0, 1)`.
 3. Non-degenerate `index_array` maps are emitted with their array and bounds
    only.
@@ -130,7 +133,12 @@ class OutputIndexMapJSON(TypedDict, total=False):
     """Nested lists of output coordinates, one nesting level per input dimension."""
 
     index_array_bounds: list[IndexValueJSON]
-    """Bounds the `index_array` values are promised to lie in; `["-inf", "+inf"]` if unconstrained."""
+    """Wire bounds on index-array values; `["-inf", "+inf"]` if unconstrained.
+
+    The message layer preserves these inclusive constraints on raw index values.
+    Engine lowering validates all values eagerly before offset and stride.
+    Serialization emits unconstrained bounds for validated non-degenerate maps.
+    """
 
 
 class IndexTransformJSON(TypedDict, total=False):
diff --git a/packages/zarr-indexing/src/zarr_indexing/lazy_array.py b/packages/zarr-indexing/src/zarr_indexing/lazy_array.py
index cae10ba65c..43ffd5625f 100644
--- a/packages/zarr-indexing/src/zarr_indexing/lazy_array.py
+++ b/packages/zarr-indexing/src/zarr_indexing/lazy_array.py
@@ -2,18 +2,21 @@
 
 `LazyArray` wraps a source with `shape`, `dtype`, and basic integer/slice
 `__getitem__`, whose reads can be lowered through NumPy system memory. It adds
-a `.lazy` accessor whose indexing operations build up an
+indexing operations that build up an
 [`IndexTransform`](transform.md) instead of reading data:
 
 ```python
-view = LazyArray(source).lazy[10:50, ::2].lazy.oindex[[3, 1, 1], :]
+view = LazyArray(source)[10:50, ::2].oindex[[3, 1, 1], :]
 view.shape          # known without touching the data
 values = view.result()
 ```
 
-Nothing is read until `result()` (or `__array__`, or an eager `__getitem__`).
-Every `.lazy` operation is metadata-only. Composition does not accumulate
-layers: a view of a view is still a single transform and retains its reader.
+Selection construction does not read source values: `result()`, `__array__`,
+and scalar conversions perform reads. Source tokenization is delegated to
+Dask and may inspect source values. Indexing operations inspect
+selection metadata and may copy or process supplied index arrays. Composition
+does not accumulate wrapper layers: a view of a view is still a single transform
+and retains its reader.
 
 Parts
 -----
@@ -26,8 +29,11 @@
 into the final buffer or an owned temporary for fancy placement.
 
 The part view's transform directly addresses its raw wrapped array. The paired
-projection deliberately retains the chunk-local frame; both travel together in
-the `ReadContext` passed to the reader.
+projection deliberately retains the chunk-local frame. Parent materialization
+passes both in `ReadContext`. Every view retains the source's partitioning and
+plans its own reads, including views obtained from partitions. Calling
+`part.view.result()` therefore supplies the reader with the selected chunk's
+projection as well. Output placement is relative to the view being executed.
 
 The partitioning is discovered from the wrapped array at construction — first
 `read_chunk_sizes` (zarr's clipped per-axis sizes, sharding-aware), then
@@ -47,8 +53,9 @@
 
 Repartitioning changes how the read is divided, not what `result()` returns.
 Parts that do not align with the source's own boxes are permitted and can be
-useful (to bound peak memory, or to batch small reads); they cost extra I/O but
-do not affect correctness.
+useful for controlling per-read sizes or batching small reads. They can change
+I/O costs; the intended selected values remain the same for an unchanged source
+and a conforming reader. The full result buffer is still allocated.
 
 Readers
 -------
@@ -64,71 +71,73 @@
 parts. Consumers may materialize part views concurrently; `LazyArray` does not
 serialize calls, so a stateful reader must synchronize its own mutable state.
 
-Both built-in readers lower through NumPy system memory. They do not implicitly
-transfer device arrays. A device source requires an explicit custom reader that
-performs any needed transfer into the supplied system-memory output buffer.
+The built-in readers lower through NumPy system memory using NumPy conversion
+of source slices. Device arrays that refuse implicit conversion need a custom
+reader that explicitly transfers values into the output buffer.
 
 Boxes and queries
 -----------------
-A selection is either **rectangular** — an interval and a stride per dimension,
-which is what basic indexing composes to at any depth — or a **query**, an
-explicit list of coordinates, which is what `oindex`, `vindex`, and masks
-produce and which subsequent basic indexing cannot undo. `is_box` reports the
-category and `bounding_box()` reports the storage region touched: the exact
-interval per dimension for a box, a hull for a query. A box is only *dense* in
-that interval when every entry of `strides()` is 1. The distinction is
-structural rather than an optimization; [the design
-notes](../design-notes.md) describe why it matters to consumers of a selection.
-
-The positional dialect
-----------------------
-Selections on `LazyArray` are **positional, NumPy-style**: index 0 is the first
+`is_box` reports whether the current transform contains only constant and affine
+output maps. An index-array gather commonly produces a query, but singleton
+indices and later selections can remove its index-array maps and make it a box.
+`bounding_box()` gives a coordinate hull, and `strides()` gives stride magnitudes
+for a box. These describe storage coordinates, not the full result layout or
+traversal order. A query can fill its hull, and a singleton box can fill its hull
+even when its recorded stride exceeds one.
+
+Relative keys, absolute domain
+------------------------------
+**The type of a key decides whether it is relative or absolute.** NumPy keys
+(slices, integers, `...`, `None`, index arrays, masks) are positions relative to
+the current view. An `IndexDomain` key names absolute coordinates of the view's
+domain, and an `IndexTransform` key composes onto the view. No key type has two
+readings, and whichever key produced a view, `view.transform.domain` is
+absolute. See the guide section "The key's type picks the frame".
+
+Selections with NumPy keys are **positional, NumPy-style**: index 0 is the first
 element of the current view, `-1` is the last, boolean masks must match the
-view's shape, and every index is bounds-checked against the view.
-
-This differs deliberately from `zarr.Array.lazy[...]`, which exposes the
-**literal** TensorStore dialect: a zarr view keeps the coordinate system of the
-array it came from, so after `v = arr.lazy[10:50]` the first element of `v` is
-`v[10]` and a negative index is out of bounds rather than counted from the end.
-That dialect suits zarr, where a view's coordinates stay comparable with the
-parent array's. `LazyArray` is a duck array and has to behave like the array it
-wraps to be usable as a NumPy drop-in or as a dask source, so it re-zeroes its
-coordinates on every view and uses positions. `zarr_indexing.boundary` performs
-the translation between the two.
-
-Two more NumPy rules the dialect keeps, in every mode:
-
-- A scalar integer drops its axis. Any non-boolean object implementing Python's
-  `SupportsIndex` protocol is accepted as one, including in slice bounds and
-  steps; an `__int__` method alone is deliberately not enough. A scalar is a
-  basic index wherever it appears, applied before any advanced index rather
-  than broadcast against one. So
-  `lazy.oindex[0]` has the shape of `x[0]`, `lazy.oindex[0, [1, 2], :]` means
-  `x[0][numpy.ix_([1, 2], ...)]`, and `lazy.oindex[0, 1, 2]` and
-  `lazy.vindex[0, 1, 2]` are both zero-rank. Use a length-1 list to keep an
-  axis.
-- Advanced indices are placed as NumPy places them. For a `vindex` selection
-  that leaves some axes unindexed, the gathered dimensions sit where the
-  coordinate arrays sat when those arrays are adjacent, and lead when a slice
-  separates them — so `lazy.vindex[..., i, j]` has shape
-  `(x.shape[0], *broadcast)`, matching `x[..., i, j]`.
+view's shape, integer coordinates are bounds-checked, and slices are clipped
+to the view's extent.
+
+The dialect governs how a *key* is read, not what a view remembers. A derived
+view keeps its **literal domain**, as a TensorStore view does: `a[10:20]` has
+domain `[10, 20)` and `a[10:20][2:5]` has domain `[12, 15)`, while `a[10:20][0]`
+still names the first element because positional keys are normalized against
+the domain's origin. The literal frame is reachable through `view.transform`,
+and directly through the two literal keys: an `IndexDomain` restricts the view
+to those coordinates, and an `IndexTransform` composes onto it. A reversed view
+carries a negative origin, as in TensorStore, because a reversing map traverses
+the source frame backwards. The current main Zarr `Array` does not expose this
+wrapper as an `Array.lazy` attribute; use `LazyArray(array)` explicitly.
+
+Scalar integers drop axes. Non-boolean objects implementing `SupportsIndex`
+are accepted as scalar indices and in slice bounds; `__int__` alone is not enough.
+For orthogonal and vectorized modes this wrapper applies scalar indices first,
+then the remaining advanced selection. Orthogonal indices form an outer product.
+Vectorized indexing accepts coordinate arrays or a shape-matching boolean mask.
+An ellipsis can retain unindexed axes (`[..., i, j]`), but explicit slice entries
+in vectorized selections are currently rejected. Scalar-first processing can
+also differ from NumPy's advanced-axis placement: for shape `(2, 3, 4)`,
+`lazy.vindex[0, ..., [1, 2]]` has shape `(3, 2)`, whereas NumPy's same selection
+has shape `(2, 3)`. These modes do not implement every NumPy indexing form.
 
 Materializing on fallback
 -------------------------
 `LazyArray` implements `__array__` but deliberately implements neither
-`__array_ufunc__` nor `__array_function__`. A NumPy *function* given a view
-therefore materializes the whole thing through
-`__array__` and works on the resulting array: `numpy.sum(view)`,
+`__array_ufunc__` nor `__array_function__`. Many NumPy operations therefore materialize through `__array__` and work on
+the resulting array: `numpy.sum(view)`,
 `numpy.add(view, 1)` and `numpy.stack([view, view])` all do, and so does
 `numpy.ones(view.shape) + view`, where the ndarray on the left dispatches.
+Metadata queries such as `numpy.shape(view)` and `numpy.ndim(view)` can use the
+exposed attributes without materializing; other unsupported operations may fail.
 
 Python's arithmetic *operators* do not: `view + 1` raises `TypeError`, because
 the wrapper defines no arithmetic dunders and an `int` has nothing to dispatch
 to. Both facts follow from the same intent — laziness here applies to indexing,
 not to building a deferred compute graph — and a `LazyArray` is not a drop-in
-for arithmetic on a large array either way. Use `.lazy[...]` to narrow the view
-first, or pass the wrapper to `dask.array.from_array` so that dask owns the
-compute graph.
+for arithmetic on a large array either way. Use `[...]` to narrow the view
+first, or pass `EagerArrayAdapter(view)` to `dask.array.from_array` so that
+Dask owns the compute graph.
 
 Ownership
 ---------
@@ -143,9 +152,8 @@
 import json
 import math
 import operator
-import uuid
 from collections.abc import Sequence
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Any, Protocol, cast
 
 import numpy as np
@@ -159,6 +167,8 @@
     ChunkProjection,
     plan_chunks,
 )
+from zarr_indexing.domain import IndexDomain
+from zarr_indexing.errors import BoundsCheckError
 from zarr_indexing.grid import DimensionGrid, FixedDimension, dimension_grids_from_chunks
 from zarr_indexing.output_map import ArrayMap, ConstantMap, DimensionMap
 from zarr_indexing.reader import (
@@ -178,10 +188,6 @@
 
 __all__ = ["LazyArray", "Partition"]
 
-# Above this many bytes, the no-dask token fallback describes an array
-# structurally instead of digesting its contents. See `_wrapped_token`.
-_TOKEN_DIGEST_LIMIT = 1 << 20
-
 
 def _invoke_reader(
     reader: Reader,
@@ -244,8 +250,9 @@ def _discover_parts(array: Any, shape: tuple[int, ...]) -> tuple[DimensionGrid,
     Discovery parses external input: an attribute that does not describe a
     partitioning of `shape` means "this object does not advertise one I
     understand", and the array is treated as unpartitioned rather than rejected.
-    A partitioning is an I/O strategy, so reading the whole array is always a
-    correct fallback. `with_parts` is a public API and validates strictly.
+    With a compatible reader, resolving the view without partitioning preserves
+    its values, though it may require larger reads. `with_parts` is a public API
+    and validates strictly.
     """
     declared = _read_source_attribute(array, "read_chunk_sizes")
     if declared is None:
@@ -258,6 +265,25 @@ def _discover_parts(array: Any, shape: tuple[int, ...]) -> tuple[DimensionGrid,
         return None
 
 
+def _discover_write_grid(array: Any, shape: tuple[int, ...]) -> tuple[DimensionGrid, ...] | None:
+    """Resolve the grid `array` commits writes in, or None for one whole cell.
+
+    The write grid can be coarser than the read grid: a sharded zarr array
+    decodes inner chunks but replaces whole shards, so `write_chunk_sizes` is
+    consulted before `chunks`. As with read discovery, anything unusable
+    means "no advertised grid" rather than an error.
+    """
+    declared = _read_source_attribute(array, "write_chunk_sizes")
+    if declared is None:
+        declared = _read_source_attribute(array, "chunks")
+    if declared is None:
+        return None
+    try:
+        return dimension_grids_from_chunks(declared, shape)
+    except (ValueError, TypeError):
+        return None
+
+
 def _whole_array_grids(shape: tuple[int, ...]) -> tuple[DimensionGrid, ...]:
     """A partitioning with a single part covering the whole array."""
     return tuple(FixedDimension(size=extent, extent=extent) for extent in shape)
@@ -268,6 +294,20 @@ def _whole_array_grids(shape: tuple[int, ...]) -> tuple[DimensionGrid, ...]:
 # --------------------------------------------------------------------------- #
 
 
+def _pure_translation(transform: IndexTransform) -> tuple[int, ...] | None:
+    """The per-axis shift when `transform` only translates its zero-origin domain, else None."""
+    if transform.output_rank != transform.input_rank or any(
+        transform.domain.inclusive_min[i] != 0 for i in range(transform.input_rank)
+    ):
+        return None
+    shift: list[int] = []
+    for axis, m in enumerate(transform.output):
+        if not (isinstance(m, DimensionMap) and m.input_dimension == axis and m.stride == 1):
+            return None
+        shift.append(m.offset)
+    return tuple(shift)
+
+
 def _is_identity_transform(transform: IndexTransform, shape: tuple[int, ...]) -> bool:
     """True when `transform` maps every coordinate of `shape` to itself.
 
@@ -414,13 +454,15 @@ class Partition:
 
     Yielded by [`LazyArray.parts`][zarr_indexing.lazy_array.LazyArray.parts].
     The parts of a view tile it exactly and disjointly: assembling every
-    `view.result()` at its `out_selection` reproduces the whole view's
-    `result()`, and each part can be resolved independently and concurrently.
+    `part.view.result()` at its `out_selection` reproduces the whole view's
+    `result()`. Each view plans its reads using the retained source grid. Parts can be
+    resolved concurrently when the source and reader permit it.
     Derived parts retain the same reader object; a shared stateful reader owns
     synchronization for concurrent calls.
 
     A consumer that needs the plan before materialization can prepare it once
-    and reuse the same immutable parts for both scheduling and assembly:
+    and reuse the same part records for both scheduling and assembly. The frozen
+    records do not snapshot the mutable source or reader:
 
     ```python
     parts = tuple(view.parts())
@@ -438,9 +480,11 @@ class Partition:
     projection
         The source-independent description of this part. Its paired
         `chunk_transform` and `cell_transform` share one compact synthetic
-        domain, mapping each selected cell to chunk-local storage and request
-        coordinates respectively. This is the authoritative placement model;
-        `base_coords` and `is_complete` are conveniences derived from it.
+        domain, mapping each selected cell to chunk-local storage coordinates
+        and to positions in this view's zero-origin result buffer respectively.
+        (The planner's own projections place cells in the request's literal
+        domain; `parts()` re-bases them.) This is the authoritative placement
+        model; `base_coords` and `is_complete` are conveniences derived from it.
     base_coords
         Which box of the base partitioning this is, one coordinate per dimension
         of the wrapped array.
@@ -454,8 +498,12 @@ class Partition:
     view
         A `LazyArray` covering exactly the cells of the view that live in this
         box. Its transform directly addresses its raw wrapped `array`; only the
-        projection's `chunk_transform` is chunk-local. Resolving the view reads
-        the box once through its selected reader. Named `view` rather than
+        projection's `chunk_transform` is chunk-local. A box part keeps the
+        request's literal coordinates, so its domain is a sub-domain of the
+        parent view's; a part placed by index arrays has a fresh zero-origin
+        domain, and `out_selection` is the placement in both cases. The view
+        retains the source grid and reader and can be read or indexed like any
+        other view. Named `view` rather than
         `array` because `LazyArray.array` is the opposite thing — the raw
         wrapped source — and the two sat next to each other meaning inverses.
     out_selection
@@ -464,7 +512,8 @@ class Partition:
         directly as `out[part.out_selection] = ...`.
     is_complete
         Whether the view covers the whole box. Useful to a writer deciding
-        between a blind overwrite and a read-modify-write. Fancy projections
+        whether coverage is complete; it does not by itself establish buffer order,
+        storage-unit alignment, or concurrent-write safety. Fancy projections
         report `False` because their coverage is deliberately `unknown` until
         duplicate-aware proof is added.
 
@@ -526,69 +575,6 @@ def _validate_prepared_parts(parts: Sequence[Partition], out_shape: tuple[int, .
         raise ValueError("prepared parts do not tile the view exactly")
 
 
-# --------------------------------------------------------------------------- #
-# Tokenization
-# --------------------------------------------------------------------------- #
-
-
-def _wrapped_token(array: Any) -> Any:
-    """A token for the wrapped array.
-
-    In order of preference: the array's own `__dask_tokenize__`;
-    `dask.base.tokenize` when dask is importable (imported lazily — this package
-    never requires it); otherwise a local fallback that digests the contents of
-    a small array.
-
-    The two environments do not agree, and neither is a translation of the
-    other: a token taken with dask installed is meaningless to a process without
-    it, and the reverse. A token is an identifier within one process, not a
-    portable name.
-
-    Above `_TOKEN_DIGEST_LIMIT` the local fallback has nothing left to identify
-    the contents with — reading them is exactly what a token call must not do —
-    so it declines to claim equality at all and returns a value that matches
-    nothing, including itself. A cache keyed on it misses; the alternative, a
-    structural description, is a cache that hands one array's result to a
-    different array of the same shape and dtype.
-    """
-    hook = getattr(array, "__dask_tokenize__", None)
-    if hook is not None:
-        try:
-            return hook()
-        # A token must never raise; fall through to the structural fallback.
-        except Exception:  # pragma: no cover - a hook that refuses to run
-            pass
-    try:
-        # dask is an optional peer, never a dependency of this package, so it is
-        # imported here and its absence is ordinary.
-        from dask.base import tokenize  # pyright: ignore[reportMissingImports]
-    except ImportError:
-        pass
-    else:
-        return tokenize(array)
-
-    shape = tuple(int(s) for s in getattr(array, "shape", ()))
-    dtype = getattr(array, "dtype", None)
-    structural = (type(array).__qualname__, shape, str(dtype))
-    # A token nothing can equal, for when the contents cannot be identified. It
-    # is the shape and dtype that would otherwise be mistaken for an identity,
-    # so they are kept alongside it for a reader looking at a graph.
-    unidentified = (*structural, "unidentified", uuid.uuid4().hex)
-
-    # Decide whether to digest the contents from the *declared* size. Measuring
-    # it by converting first would read the whole array — a multi-gigabyte store
-    # pulled into memory by a token call, which is the opposite of the point.
-    itemsize = getattr(dtype, "itemsize", None)
-    if not isinstance(itemsize, int) or itemsize * math.prod(shape) > _TOKEN_DIGEST_LIMIT:
-        return unidentified
-    try:
-        contents = np.ascontiguousarray(array)
-    # A token must never raise; an unreadable source is simply unidentified.
-    except Exception:
-        return unidentified
-    return (*structural, hashlib.sha256(contents.tobytes()).hexdigest())
-
-
 # --------------------------------------------------------------------------- #
 # The wrapper
 # --------------------------------------------------------------------------- #
@@ -598,22 +584,19 @@ class LazyArray:
     """A lazily-indexable view over a system-memory/basic-indexing source.
 
     Wrapping neither copies nor reads the wrapped array at construction time.
-    Indexing through `.lazy` composes an `IndexTransform` and returns another
+    Indexing composes an `IndexTransform` and returns another
     `LazyArray`; `result()` materializes.
 
     Selections use the **positional NumPy dialect** and reads are broken up
     along a **partitioning** discovered from the wrapped array. Every derived
     view retains its reader; that reader receives the complete projected
     transform once per part. See the module docstring, which also covers how the
-    dialect differs from `zarr.Array.lazy` and why every non-indexing NumPy
-    operation materializes the view.
+    dialect differs from low-level literal transforms and which NumPy operations
+    materialize the view.
 
-    This wrapper describes **reads**. It defines no `__setitem__`, so
-    assigning into a view raises `TypeError`. Writing belongs to the
-    consumer: plan the selection with
-    [`plan_chunks`][zarr_indexing.chunk_resolution.plan_chunks] and own the
-    read-modify-write, since chunk atomicity and concurrent-writer policy are
-    the backend's to decide, not an indexing plan's.
+    Selection is lazy; `result()` reads and `write(values)` writes synchronously.
+    Assignment is shorthand for selecting a view and calling its `write` method.
+    The source owns storage errors and concurrency; writes are not transactional.
 
     Parameters
     ----------
@@ -630,7 +613,7 @@ class LazyArray:
     --------
     >>> import numpy as np
     >>> source = np.arange(12).reshape(3, 4)
-    >>> view = LazyArray.from_numpy(source).with_parts((2, 2)).lazy[1:, ::2]
+    >>> view = LazyArray.from_numpy(source).with_parts((2, 2))[1:, ::2]
     >>> view.shape
     (2, 2)
     >>> view.result()
@@ -638,12 +621,13 @@ class LazyArray:
            [ 8, 10]])
     """
 
-    __slots__ = ("_array", "_part_owner", "_parts", "_reader", "_transform", "_window")
+    __slots__ = ("_array", "_part_owner", "_parts", "_reader", "_transform")
 
     def __init__(self, array: _WrappedArray) -> None:
         """Wrap `array` without reading it; parameters are documented on the class.
 
-        The only validation here is the `numpy.matrix` rejection (`TypeError`).
+        Reject `numpy.matrix`, normalize the shape, and inspect partition metadata.
+        Shape conversion and transform construction can also reject invalid input.
         """
         if isinstance(array, np.matrix):
             # `np.matrix` keeps every result two-dimensional, so `m[1]` has shape
@@ -658,7 +642,6 @@ def __init__(self, array: _WrappedArray) -> None:
             )
         shape = tuple(int(s) for s in array.shape)
         self._array = array
-        self._window: tuple[slice, ...] | None = None
         self._transform = IndexTransform.from_shape(shape)
         self._parts = _discover_parts(array, shape)
         self._reader = basic_reader
@@ -666,7 +649,7 @@ def __init__(self, array: _WrappedArray) -> None:
 
     @classmethod
     def from_numpy(cls, array: np.ndarray[Any, Any]) -> LazyArray:
-        """Wrap a NumPy array with its explicitly selected optimized reader."""
+        """Wrap a NumPy array with its explicitly selected NumPy reader."""
         if not isinstance(cast(object, array), np.ndarray):
             raise TypeError(
                 f"LazyArray.from_numpy requires a numpy.ndarray, got {type(array).__name__}"
@@ -679,17 +662,16 @@ def _derive(
         array: _WrappedArray,
         transform: IndexTransform,
         parts: tuple[DimensionGrid, ...] | None,
-        window: tuple[slice, ...] | None,
         reader: Reader,
     ) -> LazyArray:
         """Build a wrapper sharing `array` but carrying a new transform or partitioning."""
         view = cls.__new__(cls)
         view._array = array
-        # Views re-zero their coordinate system: the positional dialect means a
-        # view's first element is at position 0 whatever it was sliced from.
-        view._transform = transform.translate_domain_to((0,) * transform.input_rank)
+        # The domain keeps its literal coordinates, as TensorStore's does: a
+        # slice of `[10, 20)` remembers that it is `[10, 20)`. Positional keys
+        # are normalized against that origin at selection time instead.
+        view._transform = transform
         view._parts = parts
-        view._window = window
         view._reader = reader
         view._part_owner = _PartOwner()
         return view
@@ -697,9 +679,7 @@ def _derive(
     @property
     def _base_shape(self) -> tuple[int, ...]:
         """The shape of what this wrapper treats as its base array."""
-        if self._window is None:
-            return tuple(int(s) for s in self._array.shape)
-        return tuple(s.stop - s.start for s in self._window)
+        return tuple(int(s) for s in self._array.shape)
 
     # -- array-like surface -------------------------------------------------
 
@@ -713,11 +693,8 @@ def base_shape(self) -> tuple[int, ...]:
         """The shape the partitioning is expressed in — not this view's shape.
 
         `with_parts` and `with_parts_per_axis` describe boxes of the array being
-        read, not of the view reading it, so a narrowed view still partitions
-        the extents named here. For a part's own `array`, this is the part's
-        box, which is why the same call means different sizes there. Without
-        somewhere to read it, the frame in force could only be inferred from an
-        error message.
+        read, not of the view reading it. All derived views, including partition
+        views, retain the full source shape as their partitioning frame.
         """
         return self._base_shape
 
@@ -759,7 +736,6 @@ def with_reader(self, reader: Reader) -> LazyArray:
             self._array,
             self._transform,
             self._parts,
-            self._window,
             reader,
         )
 
@@ -769,32 +745,19 @@ def with_reader(self, reader: Reader) -> LazyArray:
     def is_box(self) -> bool:
         """Whether this view selects a rectangular region rather than a point list.
 
-        True exactly when the composed transform's output maps are all
-        `ConstantMap` or `DimensionMap` — no `ArrayMap`. Such a selection is
-        affine and monotone along every axis, so it is described completely by
-        an interval and a stride per dimension:
-        [`bounding_box`][zarr_indexing.lazy_array.LazyArray.bounding_box]
-        together with
-        [`strides`][zarr_indexing.lazy_array.LazyArray.strides]. Basic indexing,
-        at any depth of composition, stays a box; one `oindex`, `vindex`, or
-        mask anywhere in the chain makes the selection a query permanently.
-
-        A box is dense — every cell of its bounding box selected — only when
-        every stride is 1. A strided box covers its hull sparsely:
-        `lazy[10:50, ::4]` selects 40x20 cells out of a 40x77 hull, so a
-        consumer that reads the whole hull and discards the rest transfers 3.85x
-        the data it needs. Check `strides` before treating a box as a single
-        slab read.
-
-        The distinction lets a consumer decide between a slab read and a
-        gather; see [the design notes](../design-notes.md) for why it is a
-        category rather than an optimization.
+        True exactly when the composed transform has no `ArrayMap` output maps.
+        Basic indexing of a box stays a box. Advanced indexing can introduce
+        index arrays, but singleton gathers and later selections may remove them.
+
+        `bounding_box()` and `strides()` describe the touched coordinate region
+        and stride magnitudes; use the transform for order, result axes, and
+        repetitions. Neither this flag nor the hull alone proves dense coverage.
 
         Examples
         --------
         >>> import numpy as np
         >>> array = LazyArray.from_numpy(np.arange(12).reshape(3, 4))
-        >>> (array.lazy[1:, ::2].is_box, array.lazy.oindex[[2, 0], :].is_box)
+        >>> (array[1:, ::2].is_box, array.oindex[[2, 0], :].is_box)
         (True, False)
         """
         return not any(isinstance(m, ArrayMap) for m in self._transform.output)
@@ -807,12 +770,10 @@ def bounding_box(self) -> tuple[tuple[int, int], ...] | None:
         this view reads from that contains every coordinate the selection
         reaches.
 
-        The hull is dense — every cell in it selected — only for a box whose
-        every stride is 1. A strided box selects a sublattice of its hull (pair
-        this with [`strides`][zarr_indexing.lazy_array.LazyArray.strides] to
-        describe it fully), and a query's hull is a superset that can be
-        arbitrarily loose: `oindex[[0, 999]]` has a 1000-wide hull over two
-        rows.
+        A strided box can leave gaps, and a query hull can be arbitrarily loose:
+        `oindex[[0, 999]]` spans a 1000-wide hull over two selected rows. Conversely,
+        a query may cover every coordinate in its hull. Inspect the transform
+        when coverage or traversal order matters.
 
         Returns
         -------
@@ -832,11 +793,11 @@ def bounding_box(self) -> tuple[tuple[int, int], ...] | None:
         --------
         >>> import numpy as np
         >>> array = LazyArray.from_numpy(np.arange(12).reshape(3, 4))
-        >>> array.lazy[1:, ::2].bounding_box()
+        >>> array[1:, ::2].bounding_box()
         ((1, 3), (0, 3))
-        >>> array.lazy.oindex[[2, 0], :].bounding_box()
+        >>> array.oindex[[2, 0], :].bounding_box()
         ((0, 3), (0, 4))
-        >>> array.lazy[1:1].bounding_box() is None
+        >>> array[1:1].bounding_box() is None
         True
         """
         if self.size == 0:
@@ -859,7 +820,7 @@ def bounding_box(self) -> tuple[tuple[int, int], ...] | None:
     def strides(self) -> tuple[int, ...] | None:
         """The step between selected coordinates, one per storage dimension.
 
-        Together with `bounding_box()`, this fully describes a box selection:
+        Together with `bounding_box()`, this describes a box's per-axis coordinates:
         `bounding_box()` gives the interval per dimension, `strides()` gives the
         step per dimension. A stride of 1 means every cell of the hull along
         that dimension is selected; `k` means every `k`-th. Dimensions fixed by
@@ -889,11 +850,11 @@ def strides(self) -> tuple[int, ...] | None:
         --------
         >>> import numpy as np
         >>> array = LazyArray.from_numpy(np.arange(24).reshape(4, 6))
-        >>> (array.lazy[1:, ::2].bounding_box(), array.lazy[1:, ::2].strides())
+        >>> (array[1:, ::2].bounding_box(), array[1:, ::2].strides())
         (((1, 4), (0, 5)), (1, 2))
-        >>> array.lazy[2, ::3].strides()
+        >>> array[2, ::3].strides()
         (1, 3)
-        >>> array.lazy.oindex[[2, 0], :].strides() is None
+        >>> array.oindex[[2, 0], :].strides() is None
         True
         """
         if not self.is_box:
@@ -916,9 +877,6 @@ def with_parts(self, parts: Sequence[int]) -> LazyArray:
         [`with_parts_per_axis`][zarr_indexing.lazy_array.LazyArray.with_parts_per_axis],
         and to read in one pass see
         [`unpartitioned`][zarr_indexing.lazy_array.LazyArray.unpartitioned].
-        The three were one parameter whose meaning was decided by inspecting the
-        type of what it was given, which left no way to ask for one of them and
-        be told when you had spelled it wrong.
 
         Parameters
         ----------
@@ -1006,9 +964,8 @@ def _part_entries(parts: Sequence[Any], method: str) -> tuple[Any, ...]:
     def unpartitioned(self) -> LazyArray:
         """Return the same view, read in one pass.
 
-        `result()` still allocates its owned output buffer first, then calls the
-        reader once with the whole projected transform. `parts()` still yields a
-        single part covering everything.
+        The source is treated as a single grid cell. Nonempty reads still pass
+        its projection to the reader; empty reads make no reader calls.
 
         Returns
         -------
@@ -1018,7 +975,7 @@ def unpartitioned(self) -> LazyArray:
         return self._with_grids(None)
 
     def _with_grids(self, grids: tuple[DimensionGrid, ...] | None) -> LazyArray:
-        return LazyArray._derive(self._array, self._transform, grids, self._window, self._reader)
+        return LazyArray._derive(self._array, self._transform, grids, self._reader)
 
     def parts(self) -> Iterator[Partition]:
         """Iterate the base partitioning, projected through this view.
@@ -1029,8 +986,8 @@ def parts(self) -> Iterator[Partition]:
 
         Yields one [`Partition`][zarr_indexing.lazy_array.Partition] per box the
         view actually touches. The parts tile the view exactly and disjointly,
-        and each carries a `LazyArray` that can be resolved on its own: in
-        another thread, in another order, or not at all. Those views share this
+        and each view can be resolved with `part.view.result()`: in another thread,
+        in another order, or not at all. Those views share this
         view's reader, and `LazyArray` does not serialize calls, so a stateful
         reader must synchronize its own mutable state.
 
@@ -1046,54 +1003,30 @@ def parts(self) -> Iterator[Partition]:
         --------
         >>> import numpy as np
         >>> view = LazyArray.from_numpy(np.arange(12).reshape(3, 4)).with_parts((2, 2))
-        >>> part = next(view.lazy[:, 1:].parts())
+        >>> part = next(view[:, 1:].parts())
         >>> (part.base_coords, part.view.shape, part.is_complete)
         ((0, 0), (2, 1), False)
         """
-        base_shape = self._base_shape
-        grids = self._parts if self._parts is not None else _whole_array_grids(base_shape)
-        rank = len(base_shape)
-
-        if self._window is None:
-            plan_transform = self._transform
-        else:
-            plan_transform = self._transform.translate(tuple(-item.start for item in self._window))
-
-        for projection in plan_chunks(plan_transform, grids):
-            base_coords = projection.chunk_coords
-            local = projection.chunk_transform
-            origin = tuple(grid.chunk_offset(c) for grid, c in zip(grids, base_coords, strict=True))
-            extent = tuple(grid.data_size(c) for grid, c in zip(grids, base_coords, strict=True))
-            if origin == (0,) * rank and extent == base_shape:
-                # The part is the whole base: lowering directly against the
-                # source beats materializing a block that is the source.
-                window = self._window
-            elif self._window is None:
-                window = tuple(slice(o, o + e) for o, e in zip(origin, extent, strict=True))
-            else:
-                window = tuple(
-                    slice(w.start + o, w.start + o + e)
-                    for w, o, e in zip(self._window, origin, extent, strict=True)
-                )
-            # The global box, computed from the origin directly rather than from
-            # `window`: a part covering the whole base carries no window (so
-            # nothing is pre-materialized) but still sits somewhere concrete.
-            if self._window is None:
-                global_origin = origin
-            else:
-                global_origin = tuple(
-                    w.start + o for w, o in zip(self._window, origin, strict=True)
-                )
+        grids = self._parts if self._parts is not None else _whole_array_grids(self._base_shape)
+        to_buffer = tuple(-o for o in self._transform.domain.inclusive_min)
+        for planned in plan_chunks(self._transform, grids):
+            domain = planned.chunk_domain
+            part_transform = planned.chunk_transform.translate(domain.inclusive_min)
+            placement = _pure_translation(planned.cell_transform)
+            if placement is not None:
+                # A box part sits at a fixed offset in the request, so its view
+                # keeps the request's literal coordinates: its domain is a
+                # sub-domain of this view's, and placement is readable from it.
+                part_transform = part_transform.translate_domain_by(placement)
+            # The planner places cells in the request's literal domain; the
+            # partition places them in this view's zero-origin result buffer.
+            projection = replace(
+                planned, cell_transform=planned.cell_transform.translate(to_buffer)
+            )
             yield Partition(
                 projection=projection,
-                box=tuple((o, o + e) for o, e in zip(global_origin, extent, strict=True)),
-                view=LazyArray._derive(
-                    self._array,
-                    local.translate(global_origin),
-                    None,
-                    window,
-                    self._reader,
-                ),
+                box=tuple(zip(domain.inclusive_min, domain.exclusive_max, strict=True)),
+                view=LazyArray._derive(self._array, part_transform, self._parts, self._reader),
                 out_selection=_partition_out_selection(projection.cell_transform),
                 _owner=self._part_owner,
             )
@@ -1101,22 +1034,23 @@ def parts(self) -> Iterator[Partition]:
     # -- indexing -----------------------------------------------------------
 
     @property
-    def lazy(self) -> _LazyIndexer:
-        """Lazy indexing: `lazy[...]`, `lazy.oindex[...]`, `lazy.vindex[...]`.
+    def oindex(self) -> _LazyOIndex:
+        """Build a view using orthogonal (outer-product) indexing."""
+        return _LazyOIndex(self._select)
 
-        Each returns a new `LazyArray` view; no data is read.
-        """
-        return _LazyIndexer(self._select)
+    @property
+    def vindex(self) -> _LazyVIndex:
+        """Build a view using vectorized coordinate or mask indexing."""
+        return _LazyVIndex(self._select)
 
     def _select(self, selection: Any, mode: SelectionMode) -> LazyArray:
         transform = self._transform
         if mode != "basic":
-            # NumPy applies scalar integers as basic indices before the advanced
-            # ones, dropping their axes. Split them into their own step.
+            # This frontend applies scalar integers first, dropping their axes,
+            # then normalizes its supported advanced-indexing forms.
             scalar_selection, selection = split_scalar_axes(selection, transform.domain, mode)
             if scalar_selection is not None:
                 transform = transform.select(scalar_selection, "basic")
-                transform = transform.translate_domain_to((0,) * transform.input_rank)
         literal = normalize_positional_selection(selection, transform.domain, mode)
         if mode == "basic":
             # IndexTransform's basic path includes NumPy's `None`/newaxis.
@@ -1125,16 +1059,89 @@ def _select(self, selection: Any, mode: SelectionMode) -> LazyArray:
             composed = transform[literal]
         else:
             composed = transform.select(literal, mode)
-        return LazyArray._derive(self._array, composed, self._parts, self._window, self._reader)
+        return LazyArray._derive(self._array, composed, self._parts, self._reader)
+
+    def __getitem__(self, selection: Any) -> LazyArray:
+        """Build a view without reading source values.
+
+        A NumPy key (integers, slices, ellipsis, `None`) is **positional**:
+        `view[0]` is the first element and `view[-1]` the last, whatever
+        literal coordinates the view's domain carries. An `IndexDomain` key
+        is **literal**, restricting the view to those coordinates of its
+        domain, and an `IndexTransform` key composes onto the view, mapping
+        the key's domain into the view's domain. These are the two ways
+        TensorStore's `__getitem__` addresses a view, offered here without
+        changing what a NumPy key means.
+        """
+        if isinstance(selection, IndexDomain):
+            return self._select_domain(selection)
+        if isinstance(selection, IndexTransform):
+            return self._select_transform(selection)
+        return self._select(selection, "basic")
+
+    def _select_domain(self, domain: IndexDomain) -> LazyArray:
+        """Restrict the view to a literal sub-domain of its own domain."""
+        if domain.ndim != self._transform.input_rank:
+            raise ValueError(
+                f"domain rank {domain.ndim} does not match view rank {self._transform.input_rank}"
+            )
+        own = self._transform.domain
+        for axis, (lo, hi) in enumerate(
+            zip(domain.inclusive_min, domain.exclusive_max, strict=True)
+        ):
+            # Stricter than a literal slice, which admits an empty interval
+            # anywhere: a domain key names coordinates of this view's domain.
+            if lo < own.inclusive_min[axis] or hi > own.exclusive_max[axis]:
+                raise BoundsCheckError(
+                    f"domain [{lo}, {hi}) on dimension {axis} is outside the view's domain "
+                    f"[{own.inclusive_min[axis]}, {own.exclusive_max[axis]})"
+                )
+        literal = tuple(
+            slice(lo, hi) for lo, hi in zip(domain.inclusive_min, domain.exclusive_max, strict=True)
+        )
+        return LazyArray._derive(self._array, self._transform[literal], self._parts, self._reader)
 
-    def __getitem__(self, selection: Any) -> Any:
-        """Read a basic selection eagerly, like `numpy.ndarray.__getitem__`.
+    def _select_transform(self, transform: IndexTransform) -> LazyArray:
+        """Compose a literal transform onto the view, as TensorStore's `store[transform]`."""
+        return LazyArray._derive(
+            self._array, transform.compose(self._transform), self._parts, self._reader
+        )
 
-        Reads here are eager, not lazy, so that a `LazyArray` works as a duck
-        array for consumers (dask's `from_array`, `numpy.asarray`) that expect
-        indexing to produce data. Use `.lazy[...]` for the lazy form.
+    def __setitem__(self, selection: Any, values: Any) -> None:
+        """Select a basic view and synchronously write its values."""
+        self[selection].write(values)
+
+    def write(self, values: Any) -> None:
+        """Synchronously write broadcastable values through this view.
+
+        The source must support integer/slice assignment. Values are copied
+        before mutation, including when they alias the source. Writes follow
+        C-order view coordinates; the last occurrence wins for repeated source
+        coordinates.
+
+        Affine selections use one basic assignment. Other selections are
+        scattered against the source's **write grid**, discovered from
+        `write_chunk_sizes` or `chunks`: each touched cell is read once, updated
+        in memory, and written back, so the number of storage round trips is
+        bounded by the number of touched cells rather than selected elements.
+        A NumPy source receives one fancy assignment instead, and a source with
+        no advertised grid is written one element at a time without reading.
+        The read-side partitioning (`with_parts`) does not affect writes.
+
+        Writes go to the source directly and bypass the reader. A reader that
+        caches source data is not invalidated, so reading after writing through
+        such a reader may return stale values. Backend errors propagate and may
+        leave a partially written source. This method does not provide
+        transactions, concurrency control, or asynchronous execution.
         """
-        return self._select(selection, "basic").result()
+        from zarr_indexing.writer import write_into
+
+        write_into(
+            self._array,
+            self._transform,
+            values,
+            write_grid=_discover_write_grid(self._array, self._base_shape),
+        )
 
     def result(self, *, parts: Sequence[Partition] | None = None) -> Any:
         """Materialize this view.
@@ -1143,6 +1150,8 @@ def result(self, *, parts: Sequence[Partition] | None = None) -> Any:
         partition is read through the selected reader directly into its
         rectangular destination, or into an owned dense temporary before fancy
         placement. Empty views allocate without reading the source.
+        Every reader call includes a chunk projection, even when the source is
+        treated as a single grid cell by `unpartitioned()`.
 
         Parameters
         ----------
@@ -1185,10 +1194,6 @@ def result(self, *, parts: Sequence[Partition] | None = None) -> Any:
         if size == 0:
             return out
 
-        if prepared_parts is None and self._parts is None:
-            _invoke_reader(self._reader, self._array, ReadContext(self._transform), out)
-            return out
-
         written = 0
         selected_parts = self.parts() if prepared_parts is None else prepared_parts
         for part in selected_parts:
@@ -1214,7 +1219,9 @@ def result(self, *, parts: Sequence[Partition] | None = None) -> Any:
             # walk that does not tile the view exactly would otherwise hand
             # back process memory dressed as data. The parts are disjoint by
             # contract, so counting the cells each addresses is enough:
-            # a gap undercounts and an overlap overcounts.
+            # a gap alone undercounts and an overlap alone overcounts. This
+            # count cannot detect a compensating gap and overlap; absence of overlap
+            # still relies on the planner contract.
             if prepared_parts is not None:
                 raise ValueError(
                     "prepared parts do not tile the view exactly: "
@@ -1230,7 +1237,8 @@ def _output_buffer(self, out_shape: tuple[int, ...]) -> Any:
         """The buffer `result()` scatters parts into.
 
         Deliberately uninitialized: every cell is written by exactly one part,
-        and `result()` verifies that before returning. A masked source gets a
+        as required by the planner contract. `result()` checks the total count;
+        caller-supplied parts additionally undergo coverage validation. A masked source gets a
         masked buffer so that reader writes preserve the mask; other source-
         specific array types do not survive materializing.
         """
@@ -1246,9 +1254,9 @@ def __array__(self, dtype: Any = None, copy: bool | None = None) -> Any:
 
         The result never shares memory with the wrapped array, whatever `copy`
         asks for: `result()` already allocates, so `copy=True` gets an array the
-        caller owns and `copy=None` gets the same one rather than a second
-        allocation. `copy=False` is refused, because materializing means reading
-        — the values do not exist as a NumPy array until this call makes them.
+        caller owns. `copy=None` need not copy again when the dtype already
+        matches; requesting another dtype can allocate a conversion buffer. `copy=False` is refused, because materializing means reading
+        — this API always materializes into its own result buffer.
         """
         if copy is False:
             raise ValueError(
@@ -1259,27 +1267,26 @@ def __array__(self, dtype: Any = None, copy: bool | None = None) -> Any:
         return np.asarray(self.result(), dtype=dtype)
 
     def __dask_tokenize__(self) -> Any:
-        """A deterministic token: the wrapped array and the view.
-
-        Two wrappers produce equal tokens when they wrap the same data and
-        address the same cells. The view contributes a digest of its canonical
-        ndsel body, so transforms that differ only in representation produce
-        the same token, and a fancy selection with a large index array does not
-        embed that array's JSON in the token. See `_wrapped_token` for the
-        determinism scope of the wrapped array's contribution; dask is imported
-        lazily and is never a requirement of this package.
-
-        The partitioning and reader are deliberately absent. Both decide how
-        the data is read — in which boxes, and through which request strategy —
-        and neither changes the values that come back, so two wrappers differing
-        only in those describe the same data. A token identifies data, so they
-        token alike and a consumer that caches on tokens reuses one result for
-        both.
+        """Tokenize the source and serialized transform.
+
+        The transform contributes a digest of JSON produced by `to_json()`, so
+        its JSON is not embedded in the returned token, but is allocated while
+        computing the digest. Equal serialized transforms and equal source
+        tokens produce equal tokens; arbitrary semantically equivalent mappings
+        are not guaranteed to serialize identically.
+
+        Dask tokenizes the wrapped source using its normal dispatch and
+        determinism policy. This may read or hash source values. Dask is
+        imported only when this method is called and is otherwise optional.
+        The reader and partitioning are omitted because they must preserve
+        values. Mutating a source does not update keys in existing Dask graphs.
         """
+        from dask.base import tokenize  # pyright: ignore[reportMissingImports]
+
         canonical = json.dumps(self._transform.to_json(), sort_keys=True)
         return (
             type(self).__qualname__,
-            _wrapped_token(self._array),
+            tokenize(self._array),
             hashlib.sha256(canonical.encode()).hexdigest(),
         )
 
@@ -1289,8 +1296,11 @@ def __len__(self) -> int:
             raise TypeError("len() of unsized object")
         return self.shape[0]
 
-    def __iter__(self) -> Iterator[Any]:
-        """Iterate eagerly over the first axis, like a NumPy array.
+    def __iter__(self) -> Iterator[LazyArray]:
+        """Iterate over lazy first-axis views without reading source values.
+
+        Each element is a `LazyArray`, not a value: call `result()` or convert
+        with NumPy before doing arithmetic on it.
 
         The rank check happens in `__iter__` itself rather than in the
         generator, so `iter(view)` on a zero-rank view raises immediately as
@@ -1323,35 +1333,8 @@ def __repr__(self) -> str:
         return f"<LazyArray {' '.join(described)}>"
 
 
-class _LazyIndexer:
-    """The `.lazy` accessor: builds views instead of reading data.
-
-    Holds the owning view's bound `_select` rather than the view itself, so the
-    accessor classes never reach into another object's internals.
-    """
-
-    __slots__ = ("_select",)
-
-    def __init__(self, select: SelectFn) -> None:
-        self._select = select
-
-    def __getitem__(self, selection: Any) -> LazyArray:
-        """Basic (integer / slice / ellipsis) indexing, lazily."""
-        return self._select(selection, "basic")
-
-    @property
-    def oindex(self) -> _LazyOIndex:
-        """Orthogonal (outer-product) indexing, lazily."""
-        return _LazyOIndex(self._select)
-
-    @property
-    def vindex(self) -> _LazyVIndex:
-        """Vectorized (coordinate / mask) indexing, lazily."""
-        return _LazyVIndex(self._select)
-
-
 class _LazyOIndex:
-    """`lazy.oindex[...]` — one selection per axis, combined as an outer product."""
+    """`view.oindex[...]` — one selection per axis, combined as an outer product."""
 
     __slots__ = ("_select",)
 
@@ -1361,9 +1344,12 @@ def __init__(self, select: SelectFn) -> None:
     def __getitem__(self, selection: Any) -> LazyArray:
         return self._select(selection, "orthogonal")
 
+    def __setitem__(self, selection: Any, values: Any) -> None:
+        self[selection].write(values)
+
 
 class _LazyVIndex:
-    """`lazy.vindex[...]` — correlated coordinate arrays, or a single mask."""
+    """`view.vindex[...]` — correlated coordinate arrays, or a single mask."""
 
     __slots__ = ("_select",)
 
@@ -1372,3 +1358,6 @@ def __init__(self, select: SelectFn) -> None:
 
     def __getitem__(self, selection: Any) -> LazyArray:
         return self._select(selection, "vectorized")
+
+    def __setitem__(self, selection: Any, values: Any) -> None:
+        self[selection].write(values)
diff --git a/packages/zarr-indexing/src/zarr_indexing/messages.py b/packages/zarr-indexing/src/zarr_indexing/messages.py
index df0e0c87eb..305d765947 100644
--- a/packages/zarr-indexing/src/zarr_indexing/messages.py
+++ b/packages/zarr-indexing/src/zarr_indexing/messages.py
@@ -3,10 +3,10 @@
 This module implements the [ndsel](https://github.com/zarr-developers/ndsel) draft wire
 format: a JSON-serializable representation of NumPy-style n-dimensional
 selections that adapts TensorStore's `IndexTransform` model. It is a **pure
-JSON→JSON** layer: it depends on nothing but the standard library, imposes no
-engine (numpy/array) constraints, and never rounds, clamps, or drops
-information. Engine constraints (finite bounds, in-memory `IndexTransform`
-construction) live one layer up, in `json.py`.
+JSON→JSON** layer depending only on the standard library. It validates and
+desugars messages, removing redundant fields on constant maps. It limits input
+rank to 32 and checks affine references against that rank. Finite bounds and
+in-memory array construction are enforced by the engine lowering layer.
 
 Two entry points:
 
@@ -18,11 +18,12 @@
   `IndexTransform` JSON body, without the `kind` discriminator. `normalize` is
   idempotent when its output is re-tagged with `kind: "transform"`.
 
-The canonical body is, field-for-field, a TensorStore `IndexTransform` (minus
-`kind`), so a normalized `transform` loads directly into TensorStore once
-`kind` is stripped.
+The canonical body uses TensorStore's `IndexTransform` field vocabulary.
+Normalization alone does not guarantee TensorStore acceptance: index-array
+content is deferred, and TensorStore has additional coordinate and label limits.
 
-Value rules enforced here: every integer is a 64-bit signed value; JSON
+Value rules for validated fields (excluding the verbatim `index_array` payload
+and discarded constant-map fields): integers are 64-bit signed values; JSON
 booleans are **not** integers (Python's `isinstance(True, int)` is guarded
 against explicitly); the `"-inf"`/`"+inf"` sentinels are legal only in bound
 positions; an implicit bound is the one-element `[n]`-bracket form, and its
@@ -43,7 +44,7 @@
 # Error taxonomy
 # ---------------------------------------------------------------------------
 
-#: The complete set of ndsel reason codes (spec section 6).
+#: Current ndsel reason codes plus the recognized retired negative-step code.
 REASON_CODES = frozenset(
     {
         "invalid_json",
@@ -117,7 +118,7 @@ def __init__(self, reason: str, detail: str = "") -> None:
 # An upper bound on `input_rank`, because normalization allocates proportionally
 # to it — an identity `output`, a bound per dimension, a label per dimension —
 # from a document that carries no data behind the number. Matches the rank
-# TensorStore accepts, which is well above any real array.
+# TensorStore accepts. This is an implementation limit, not an ndsel limit.
 _MAX_RANK = 32
 
 
@@ -202,6 +203,18 @@ def _bound_is_implicit(bound: int | str | list[int | str]) -> bool:
     return isinstance(bound, list)
 
 
+def _finite(value: int | str, where: str) -> int:
+    """The integer behind a validated `index-value` that is not a sentinel.
+
+    Every value reaching the desugaring helpers has passed `_check_index_value`,
+    so a string here is one of the two sentinels, which each helper handles
+    before calling this. Anything else is an internal error, not bad input.
+    """
+    if isinstance(value, int):
+        return value
+    raise RuntimeError(f"{where} is {value!r}; expected an integer or an infinity sentinel")
+
+
 def _ext_key(value: int | str) -> tuple[int, int]:
     """A sort key giving the extended-integer order `-inf < n < +inf` exactly.
 
@@ -212,8 +225,7 @@ def _ext_key(value: int | str) -> tuple[int, int]:
         return (0, 0)
     if value == "+inf":
         return (2, 0)
-    assert isinstance(value, int)
-    return (1, value)
+    return (1, _finite(value, "bound"))
 
 
 def _rewrap(value: int | str, *, implicit: bool) -> int | str | list[int | str]:
@@ -275,10 +287,10 @@ def _resolve_upper_bound(
     The implicit/explicit bracket travels with the extent-bearing field (the
     upper bound, or `shape`), matching the spec's `[n]`-bracket convention.
     """
-    if upper_field is None:
+    if upper_raw is None:
+        # No upper-bound field was supplied (`upper_field` is None as well).
         return [["+inf"] for _ in range(rank)]
 
-    assert upper_raw is not None
     if kind_of == "exclusive":
         return list(upper_raw)
 
@@ -315,8 +327,7 @@ def _checked_i64(value: int, where: str) -> int:
 def _inclusive_to_exclusive(value: int | str, where: str) -> int | str:
     if value == "+inf" or value == "-inf":
         return value
-    assert isinstance(value, int)
-    return _checked_i64(value + 1, f"{where} converted to an exclusive bound")
+    return _checked_i64(_finite(value, where) + 1, f"{where} converted to an exclusive bound")
 
 
 def _shape_to_exclusive(min_value: int | str, shape_value: int | str, where: str) -> int | str:
@@ -329,9 +340,10 @@ def _shape_to_exclusive(min_value: int | str, shape_value: int | str, where: str
         return "+inf"
     if min_value == "-inf":
         return "-inf"
-    assert isinstance(min_value, int)
-    assert isinstance(shape_value, int)
-    return _checked_i64(min_value + shape_value, f"{where} added to its inclusive_min")
+    return _checked_i64(
+        _finite(min_value, f"inclusive_min for {where}") + _finite(shape_value, where),
+        f"{where} added to its inclusive_min",
+    )
 
 
 def _validate_domain(inclusive_min: list[Any], exclusive_max: list[Any], *, prefix: str) -> None:
@@ -480,8 +492,8 @@ def _normalize_slice(obj: dict[str, Any]) -> dict[str, Any]:
         m = -(-length // abs(s))  # ceil(length / |s|)
         o = _trunc_div(a, s)  # trunc(a / s), toward zero, both signs
         offset = a - s * o  # lattice phase, |offset| < |s|
-        inclusive_min.append(o)
-        exclusive_max.append(o + m)
+        inclusive_min.append(_checked_i64(o, f"input_inclusive_min[{k}]"))
+        exclusive_max.append(_checked_i64(o + m, f"input_exclusive_max[{k}]"))
         output.append({"offset": offset, "stride": s, "input_dimension": k})
 
     labels = labels_raw if labels_raw is not None else [""] * n
@@ -555,7 +567,7 @@ def _normalize_output_map(raw: Any, where: str) -> dict[str, Any]:
     if has_index_array:
         stride = _check_int(raw["stride"], f"{where}.stride") if "stride" in raw else 1
         bounds = (
-            _check_index_array_bounds(raw["index_array_bounds"], where)
+            validate_index_array_bounds(raw["index_array_bounds"], where)
             if "index_array_bounds" in raw
             else ["-inf", "+inf"]
         )
@@ -584,7 +596,8 @@ def _normalize_output_map(raw: Any, where: str) -> dict[str, Any]:
     return {"offset": offset}
 
 
-def _check_index_array_bounds(value: Any, where: str) -> list[int | str]:
+def validate_index_array_bounds(value: Any, where: str) -> list[int | str]:
+    """Validate the syntax and ordering of an inclusive index-array interval."""
     if not isinstance(value, list) or len(value) != 2:
         raise NdselError(
             "invalid_json",
@@ -730,17 +743,23 @@ def normalize_ndsel(obj: Any) -> dict[str, Any]:
     """
     message = _require_object(obj)
     kind = _message_kind(message)
-    return _NORMALIZERS[kind](message)
+    canonical = _NORMALIZERS[kind](message)
+    # Apply the same limit to inferred and shorthand ranks as to explicit
+    # transform ranks, so every result can be normalized again.
+    if canonical["input_rank"] > _MAX_RANK:
+        raise NdselError(
+            "invalid_json", f"input_rank must be <= {_MAX_RANK}, got {canonical['input_rank']}"
+        )
+    return canonical
 
 
 def parse_ndsel(obj: Any) -> dict[str, Any]:
     """Structurally validate an ndsel message, returning it unchanged.
 
-    A lighter gate than `normalize_ndsel`: it confirms the message is a
-    well-formed ndsel message of a recognized kind (correct field membership,
-    JSON types, upper-bound exclusivity, domain ordering, step signs) and
-    raises `NdselError` otherwise, but does not desugar it. Useful for
-    validating a message you intend to keep in its compact shorthand form.
+    Runs the same validation and desugaring as `normalize_ndsel`, discards
+    the canonical body, and returns the original object. Useful for validating
+    a message you intend to keep in its compact shorthand form. Index-array
+    payload validation remains the engine's responsibility.
 
     Examples
     --------
diff --git a/packages/zarr-indexing/src/zarr_indexing/output_map.py b/packages/zarr-indexing/src/zarr_indexing/output_map.py
index 16ad7aeb9b..b3c9eeb281 100644
--- a/packages/zarr-indexing/src/zarr_indexing/output_map.py
+++ b/packages/zarr-indexing/src/zarr_indexing/output_map.py
@@ -56,13 +56,10 @@ def _array_map_dependency_axes(index_array: np.ndarray[Any, Any]) -> tuple[int,
     Normalized `ArrayMap` index arrays carry the full input rank of their
     enclosing transform: an axis the array varies over has its full size, while
     an axis the array is independent of is a singleton (size 1). The dependency
-    axes are therefore exactly the axes of size 2 or more. An orthogonal
-    (`oindex`) array depends on a single axis; a vectorized (`vindex`) array
-    depends on all of the (shared) broadcast axes.
-
-    A size-**0** axis carries no dependency either: the array has no values to
-    vary, so an empty selection stays the flavor it was made as rather than
-    reading as correlated with every other axis.
+    axes are therefore exactly the axes of size 2 or more. This is structural:
+    values are not inspected for constant or repeated coordinates. An array
+    with shape `(0, 2)` is empty but still reports axis 1; the zero-size axis
+    itself is not reported.
     """
     return tuple(axis for axis, size in enumerate(index_array.shape) if size > 1)
 
@@ -76,8 +73,9 @@ class ConstantMap:
 
     Examples
     --------
-    Every input cell maps to the same output coordinate — the NumPy analogy
-    is a broadcast (`np.broadcast_to(5, (3,))`), not an index:
+    Every input cell maps to the same output coordinate, like broadcasting
+    coordinate 5 with `np.broadcast_to(5, (3,))`. Repeated fancy indices can
+    also describe these coordinates, using an explicit list:
 
     >>> from zarr_indexing.domain import IndexDomain
     >>> from zarr_indexing.transform import IndexTransform
@@ -154,11 +152,11 @@ class ArrayMap:
     the result. Arises from fancy indexing (e.g., `arr[[5, 1, 1]]` or boolean
     masks).
 
-    Freshly constructed maps are normalized to the **full input rank** of their
-    enclosing transform: `index_array` has the enclosing domain's rank, sized
+    A map used in a transform must have its **full input rank**:
+    `index_array` has the enclosing domain's rank, sized
     fully on the axes it varies over and singleton (size 1) elsewhere. The
     shape is the single source of truth for what the map depends on — its
-    **dependency axes** are exactly its non-singleton axes (see
+    **dependency axes** are exactly its axes of size greater than one (see
     `_array_map_dependency_axes`) — and it distinguishes the two
     flavors of multi-array fancy indexing:
 
@@ -196,15 +194,12 @@ class ArrayMap:
     """Multiplier applied to each `index_array` value before `offset` is added."""
 
     def __post_init__(self) -> None:
-        """Own the index array and expose it read-only.
-
-        A map is frozen, but the array inside it was not: reaching through a
-        view's transform to `index_array[0] = 9` silently changed what the view
-        returned, in a package whose whole contract is that a view is a
-        description of a read and resolving it twice answers alike. Owning the
-        array also prevents the caller from changing the contents behind the
-        read-only view, which would invalidate this value object's hash.
-        """
+        """Own an immutable snapshot of the integer index coordinates.
+
+        The snapshot is backed by immutable bytes, so callers cannot modify it
+        or re-enable its WRITEABLE flag. Changes to the supplied array do not
+        change the map's coordinates or hash. This freezes the coordinate
+        mapping, not the source values read through it."""
         # Immutable bytes are the ultimate owner so callers cannot re-enable
         # the WRITEABLE flag, as they can on a read-only array that owns its
         # allocation. `asarray` also accepts the NumPy scalars that reach here
@@ -224,14 +219,10 @@ def __reduce__(self) -> tuple[object, tuple[object, int, int]]:
         )
 
     def _with_affine(self, offset: int, stride: int) -> ArrayMap:
-        """This map's coordinates under a different affine adjustment.
+        """Return a map with a different affine adjustment.
 
-        The frozen index array is shared rather than copied: it is already
-        owned by immutable bytes and read-only, so the ownership invariant
-        `__post_init__` establishes holds for the new map too. Chunk
-        resolution translates every restricted map once per chunk, and
-        re-copying the array there dominated the cost of small selections.
-        """
+        Share the immutable index array while replacing the offset and stride.
+        This preserves coordinate ownership without copying the array."""
         new = object.__new__(ArrayMap)
         object.__setattr__(new, "index_array", self.index_array)
         object.__setattr__(new, "offset", offset)
@@ -239,14 +230,10 @@ def _with_affine(self, offset: int, stride: int) -> ArrayMap:
         return new
 
     def __eq__(self, other: object) -> bool:
-        """Value equality, comparing index arrays element-wise.
+        """Compare offset, stride, array shape, and index values.
 
-        The generated `__eq__` compares them with `==`, whose result for two
-        arrays is an array — so asking whether two maps are equal raised
-        `ValueError: the truth value of an array ... is ambiguous`. `frozen=True`
-        reads as a promise that a value can be compared and hashed, and this is
-        what makes good on it.
-        """
+        Return a scalar boolean for another ArrayMap and NotImplemented for
+        other types."""
         if not isinstance(other, ArrayMap):
             return NotImplemented
         return (
@@ -257,11 +244,10 @@ def __eq__(self, other: object) -> bool:
         )
 
     def __hash__(self) -> int:
-        """Hashed by the array's contents, so equal maps hash alike.
+        """Hash the offset, stride, array shape, and index bytes.
 
-        The generated `__hash__` hashed the ndarray itself, which is unhashable;
-        a map could therefore not go in a set, or key a cache.
-        """
+        The immutable coordinate snapshot keeps the hash stable, and equal
+        maps have equal hashes."""
         return hash(
             (
                 self.offset,
@@ -273,11 +259,12 @@ def __hash__(self) -> int:
 
     @property
     def dependency_axes(self) -> tuple[int, ...]:
-        """Every input axis this map varies over: its non-singleton axes.
+        """Structural dependency axes: axes of size greater than one.
 
-        One axis means orthogonal, several mean correlated, and none means
-        the map is degenerate — the shape is the single source of truth for
-        all three.
+        Axes of size greater than one are reported, regardless of coordinate
+        values or a zero-size axis elsewhere. Whether the whole transform is
+        orthogonal also depends on how other maps use these axes; a single
+        map's shape does not establish independence.
 
         Examples
         --------
@@ -302,7 +289,7 @@ def dependent_axis(self) -> int | None:
         -------
         int or None
             The axis the map varies over, or `None` when it varies over no input
-            axis at all — an empty map, or a hand-built all-singleton one. `None`
+            axis of size greater than one, such as an all-singleton map. `None`
             is a valid result, not an error; such maps resolve through the
             pointwise (general) path.
 
@@ -366,9 +353,13 @@ def to_json(self) -> OutputIndexMapJSON:
 def output_index_map_from_json(data: OutputIndexMapJSON) -> OutputIndexMap:
     """Construct the output map a canonical wire form names.
 
-    The wire form is a tagged union — `index_array`, then `input_dimension`,
-    else constant — so loading it dispatches to the right kind here rather
-    than on any one of them.
+    The wire form is structurally discriminated: the presence of `index_array`
+    selects an array map, `input_dimension` selects a dimension map, and
+    neither selects a constant map.
+
+    Validate every raw index value against the inclusive `index_array_bounds`
+    before applying offset and stride. Out-of-bounds values raise `NdselError`
+    at load time. Validated immutable maps do not retain the bounds.
 
     Examples
     --------
@@ -377,11 +368,13 @@ def output_index_map_from_json(data: OutputIndexMapJSON) -> OutputIndexMap:
     >>> output_index_map_from_json({"offset": 0, "stride": 2, "input_dimension": 1})
     DimensionMap(input_dimension=1, offset=0, stride=2)
     """
-    from zarr_indexing._wire import lower_index_array
+    from zarr_indexing._wire import check_index_array_bounds, lower_index_array
 
     if "index_array" in data:
+        array = lower_index_array(data["index_array"], "index_array")
+        check_index_array_bounds(array, data.get("index_array_bounds", ["-inf", "+inf"]), "output")
         return ArrayMap(
-            index_array=lower_index_array(data["index_array"], "index_array"),
+            index_array=array,
             offset=data.get("offset", 0),
             stride=data.get("stride", 1),
         )
diff --git a/packages/zarr-indexing/src/zarr_indexing/reader.py b/packages/zarr-indexing/src/zarr_indexing/reader.py
index 8d47d51d21..9e14d59c10 100644
--- a/packages/zarr-indexing/src/zarr_indexing/reader.py
+++ b/packages/zarr-indexing/src/zarr_indexing/reader.py
@@ -45,10 +45,25 @@ class ReadContext:
     """
 
     transform: IndexTransform
-    """Maps zero-origin output-buffer coordinates to global coordinates in the source."""
+    """Maps zero-origin output-buffer coordinates to global coordinates in the source.
+
+    A transform carrying a literal (nonzero-origin) domain, such as a view's,
+    is re-based to origin zero on construction: readers address the buffer
+    they fill, so the origin is fixed here rather than by every caller.
+    """
 
     projection: ChunkProjection | None = None
-    """The partition plan when this read is one part of a partitioned view, else `None`."""
+    """The read plan, always supplied by `LazyArray` execution.
+
+    Direct reader callers may omit it if their reader supports unplanned reads.
+    """
+
+    def __post_init__(self) -> None:
+        origin = self.transform.domain.inclusive_min
+        if any(origin):
+            object.__setattr__(
+                self, "transform", self.transform.translate_domain_to((0,) * len(origin))
+            )
 
 
 class Reader(Protocol):
@@ -85,7 +100,8 @@ def read_into(
         to global coordinates in `source`, and its domain shape equals
         `out.shape`. `context.projection`, when present, is the corresponding
         partition plan: its `chunk_transform` is chunk-local, its
-        `cell_transform` describes result placement, and its `chunk_domain`
+        `cell_transform` places cells in the zero-origin result buffer of the
+        view that planned the read, and its `chunk_domain`
         describes the grid cell. Fill every cell in place, preserving the
         transform's exact values, order, and dtype, then return `None`. Do not
         replace or retain `out`; it may be a strided writable view rather than
@@ -103,7 +119,8 @@ class BasicReader:
 
     Each transform is decomposed into the smallest enclosing positive-slice
     slab and a residual transform. The slab is read once with basic indexing,
-    so fancy or negative-step selections may over-read, and the residual is
+    so fancy selections may over-read. Reversals read their selected coordinates
+    in ascending order without requiring a negative source slice. The residual is
     then lowered through NumPy system-memory operations into the supplied
     buffer.
 
@@ -132,12 +149,13 @@ def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
 
 
 class NumPyReader:
-    """Reader optimized for NumPy system-memory arrays.
+    """Explicit reader for NumPy system-memory arrays.
 
     This is the reader selected by
     [`LazyArray.from_numpy`][zarr_indexing.lazy_array.LazyArray.from_numpy]. It
     applies the complete transform with NumPy operations and is applicable to
-    `numpy.ndarray` sources, including `numpy.ma.MaskedArray`.
+    `numpy.ndarray` sources, including `numpy.ma.MaskedArray`. Its current
+    implementation uses the same slab and residual path as `BasicReader`.
 
     Examples
     --------
@@ -166,12 +184,13 @@ class UnitStepReader:
     unit-step slab and a residual transform, so the source only ever receives
     `slice(start, stop, 1)` on every axis — the one form an API without
     general strided reads (an FFI binding, an HTTP range endpoint) supports.
-    `BasicReader` instead pushes strided and reversed slices down, which
-    reads less but asks more of the source.
+    `BasicReader` instead requests positive-stride slices for both forward and
+    reversed affine selections, then reverses in memory when needed.
 
     The residual lowering applies strides, reversals, and gathers to the
-    in-memory block, so a strided selection over-reads its cover by the
-    stride factor. Partitioning the wrapping
+    in-memory block. For n selected points at positive spacing k on one axis,
+    the cover contains (n - 1) * k + 1 elements when n is nonzero; its over-read
+    ratio approaches k for long selections. Partitioning the wrapping
     [`LazyArray`][zarr_indexing.lazy_array.LazyArray] (`with_parts`) bounds
     each cover by a part.
 
@@ -360,14 +379,14 @@ def _lower_orthogonal(array: Any, transform: IndexTransform) -> Any:
         if isinstance(m, ConstantMap):
             selection.append(m.offset)
             continue
-        if out_dim in gathered:
-            selection.append(slice(None))
-        else:
-            assert isinstance(m, DimensionMap)
+        if isinstance(m, DimensionMap) and out_dim not in gathered:
             d = m.input_dimension
             lo = transform.domain.inclusive_min[d]
             hi = transform.domain.exclusive_max[d]
             selection.append(slice(m.offset + m.stride * lo, m.offset + m.stride * hi, m.stride))
+        else:
+            # Every ArrayMap, and every non-positive-stride DimensionMap, was gathered above.
+            selection.append(slice(None))
         if isinstance(m, ArrayMap):
             axis = m.dependent_axis
             if axis is None:
@@ -395,15 +414,14 @@ def _lower_general(array: Any, transform: IndexTransform) -> Any:
     flat axis with row-major strides, and a single `take` collects them.
     """
     outputs = transform.output
-    correlated_dims = [d for d, m in enumerate(outputs) if isinstance(m, ArrayMap)]
+    correlated = [(d, m) for d, m in enumerate(outputs) if isinstance(m, ArrayMap)]
+    correlated_dims = [d for d, _ in correlated]
 
     slice_input_dims = {m.input_dimension for m in outputs if isinstance(m, DimensionMap)}
     broadcast_axes = [d for d in range(transform.input_rank) if d not in slice_input_dims]
     broadcast_shape = tuple(transform.domain.shape[d] for d in broadcast_axes)
 
-    for d in correlated_dims:
-        arr_map = outputs[d]
-        assert isinstance(arr_map, ArrayMap)
+    for _, arr_map in correlated:
         # The axes the array varies over (its non-singleton axes; see
         # transform._array_map_dependency_axes) must all live in the block.
         dependency = (axis for axis, size in enumerate(arr_map.index_array.shape) if size > 1)
@@ -435,16 +453,14 @@ def _lower_general(array: Any, transform: IndexTransform) -> Any:
         if isinstance(m, ConstantMap):
             selection.append(m.offset)
             continue
-        if out_dim in correlated_dims:
+        if isinstance(m, ArrayMap):
             selection.append(slice(None))
             correlated_positions.append(axis)
         elif out_dim in gathered:
             selection.append(slice(None))
             residual_positions.append(axis)
-            assert isinstance(m, DimensionMap)
             residual_axis_dims.append(m.input_dimension)
         else:
-            assert isinstance(m, DimensionMap)
             d = m.input_dimension
             lo = transform.domain.inclusive_min[d]
             hi = transform.domain.exclusive_max[d]
@@ -468,10 +484,9 @@ def _lower_general(array: Any, transform: IndexTransform) -> Any:
     flat_index = np.zeros(math.prod(broadcast_shape), dtype=np.intp)
     stride = 1
     for position in range(n_corr - 1, -1, -1):
-        m = outputs[correlated_dims[position]]
-        assert isinstance(m, ArrayMap)
+        _, corr_map = correlated[position]
         flat_index = flat_index + (
-            _correlated_map_coords(m, broadcast_axes, broadcast_shape, transform.input_rank)
+            _correlated_map_coords(corr_map, broadcast_axes, broadcast_shape, transform.input_rank)
             * stride
         )
         stride *= corr_sizes[position]
@@ -489,8 +504,8 @@ def _push_slice_for_dimension_map(
     """The positive-step slice covering a `DimensionMap`, and its block-local map.
 
     A negative step is read forwards and reversed by the residual: a source is
-    only ever asked for a slice that walks upwards, which is the one form every
-    array-like agrees on.
+    only asked for positive-stride slices. Supporting those slices is part of
+    this reader's source contract.
     """
     d = m.input_dimension
     lo = transform.domain.inclusive_min[d]
@@ -524,9 +539,8 @@ def _push_unit_slice_for_dimension_map(
 
     Strides and reversals stay in the residual: the source is only ever asked
     for a contiguous ascending slice, and the original stride is replayed
-    against the in-memory block. The cover therefore over-reads a strided
-    selection by its stride factor, which is the price of a source that
-    accepts nothing but `slice(start, stop, 1)`.
+    against the in-memory block. The cover may include unselected elements;
+    for n distinct points at spacing k it has (n - 1) * k + 1 elements.
     """
     d = m.input_dimension
     lo = transform.domain.inclusive_min[d]
diff --git a/packages/zarr-indexing/src/zarr_indexing/testing/stateful.py b/packages/zarr-indexing/src/zarr_indexing/testing/stateful.py
index 4458d7922a..00dce58bb9 100644
--- a/packages/zarr-indexing/src/zarr_indexing/testing/stateful.py
+++ b/packages/zarr-indexing/src/zarr_indexing/testing/stateful.py
@@ -39,7 +39,7 @@ def make_source(self, data):
 The `choose_reader` rule draws a reader and applies it to the view, so the
 execution strategy becomes part of the chain. Every reader listed by a subclass
 must preserve the NumPy model for its source. The universal `basic_reader` is
-always exercised, even when a subclass lists only specialized readers; with no
+always eligible to be drawn, even when a subclass lists only specialized readers; with no
 declared readers it is the sole strategy drawn.
 
 Requires the `testing` extra (`pip install zarr-indexing[testing]`).
@@ -105,13 +105,12 @@ def make_source(self, data):
         HealthCheck.too_slow,
     ],
 )
-"""Enough examples to find a defect reachable only through a narrow chain, at a
-few seconds per run when there is nothing to find. Every step is followed by
-checks that each materialize the whole view, so the budget buys examples rather
-than long chains — a chain runs out of axes to index within a few steps anyway.
+"""A budget of 250 examples with at most 10 state-machine steps per example.
 
-`filter_too_much` is suppressed because a chain that reaches a rank-0 view
-leaves only `repartition` enabled, so a run that opens there is discarded."""
+Invariants materialize the whole view after steps. Deadlines and selected
+health checks are disabled to accommodate those potentially expensive reads;
+the budget does not guarantee discovery of every defect.
+"""
 
 
 # --------------------------------------------------------------------------- #
@@ -244,8 +243,9 @@ def __init__(self) -> None:
     def _indexable(self) -> bool:
         """Whether there is anything left to index.
 
-        A rank-0 or empty view takes no further step — NumPy would reject one
-        too — so the chain ends there, and the invariants keep checking.
+        This harness stops drawing selections for rank-0 or empty views.
+        Reader changes, repartitioning and invariant checks remain possible.
+        NumPy itself permits some indexing of such arrays, such as `[()]`.
         """
         return self.model.ndim > 0 and self.model.size > 0
 
@@ -253,11 +253,11 @@ def _step(self, mode: SelectionMode, selection: tuple[Any, ...]) -> None:
         self.chain.append((mode, selection))
         self.model = apply_selection(self.model, selection, mode)
         if mode == "basic":
-            self.view = self.view.lazy[selection]
+            self.view = self.view[selection]
         elif mode == "orthogonal":
-            self.view = self.view.lazy.oindex[selection]
+            self.view = self.view.oindex[selection]
         else:
-            self.view = self.view.lazy.vindex[selection]
+            self.view = self.view.vindex[selection]
 
     # -- rules --------------------------------------------------------------
 
@@ -307,11 +307,9 @@ def choose_reader(self, data: st.DataObject) -> None:
     def repartition(self, data: st.DataObject) -> None:
         """Re-box a chain that has run out of axes to index.
 
-        Something must stay enabled once the view is rank-0 or empty, or
-        Hypothesis has no move to make and abandons the run. Re-boxing is the
-        useful thing to do there: it changes nothing the invariants may see, and
-        a rank-0 view read through every partitioning is exactly the state a
-        collapsed correlated selection reaches.
+        Once the harness stops drawing selections, this rule tests another
+        partitioning of the same view while the reader-change rule also remains
+        enabled. The invariants must continue to match the NumPy model.
         """
         parts = data.draw(st.sampled_from(list(type(self).partitionings)))
         self.view = repartition(self.view, parts)
diff --git a/packages/zarr-indexing/src/zarr_indexing/testing/strategies.py b/packages/zarr-indexing/src/zarr_indexing/testing/strategies.py
index 63a3d351a9..3b9970e8b2 100644
--- a/packages/zarr-indexing/src/zarr_indexing/testing/strategies.py
+++ b/packages/zarr-indexing/src/zarr_indexing/testing/strategies.py
@@ -1,8 +1,8 @@
 """Hypothesis strategies for the selections `LazyArray` accepts.
 
 Each strategy takes the shape of the array being indexed and generates one
-selection for it — an index tuple with one entry per axis, in the spelling its
-mode expects. They are the generators behind
+selection for it, in the spelling its mode expects. Some vectorized selections
+use a partial coordinate tuple or a mask with an ellipsis. They are the generators behind
 [`ChainedIndexingStateMachine`][zarr_indexing.testing.stateful.ChainedIndexingStateMachine]
 and are exported on their own for a project that has its own test harness and
 wants only the hard part.
@@ -16,8 +16,9 @@ def test_my_array_slices_like_numpy(selection):
     assert_array_equal(my_array[selection], reference[selection])
 ```
 
-Every axis of `shape` must be non-empty: a selection over an axis of extent 0
-has no coordinates to draw. Filter or narrow the shape before calling.
+Coordinate-drawing strategies require non-empty axes; vectorized selections
+also require positive rank. The `empty_masks` strategy can generate a mask
+for an empty shape because it does not draw element coordinates.
 
 Requires the `testing` extra (`pip install zarr-indexing[testing]`).
 """
@@ -69,16 +70,11 @@ def _basic_entry(size: int) -> st.SearchStrategy[Any]:
 
 
 def _orthogonal_entry(size: int) -> st.SearchStrategy[Any]:
-    """One axis of an `oindex` selection.
+    """Generate one axis of an orthogonal selection.
 
-    The slices carry a step and are free to stop early. Drawing them as
-    `slice(start, size)` alone meant no strided or reversed slice ever reached
-    `oindex`, and no orthogonal selection ever stopped short of the axis end.
-
-    An empty coordinate list is drawn too. It selects nothing, which is legal
-    and is exactly the shape that lost its axis on the way through JSON — but
-    with `min_size=1` no fancy selection was ever empty.
-    """
+    Include scalar coordinates, coordinate lists, boolean masks, and slices
+    with positive or negative steps and varying endpoints. Empty coordinate
+    lists and all-False masks exercise selections with zero-length axes."""
     coordinate = st.integers(-size, size - 1)
     return st.one_of(
         coordinate,
@@ -118,13 +114,10 @@ def masks(draw: st.DrawFn, shape: tuple[int, ...]) -> np.ndarray[Any, np.dtype[n
 
 
 def empty_masks(shape: tuple[int, ...]) -> st.SearchStrategy[np.ndarray[Any, np.dtype[np.bool_]]]:
-    """The all-False mask over `shape` — a fancy selection that empties the view.
+    """Generate an all-False mask with the given shape.
 
-    Split out from `masks`, which forces a cell True so a chain has something
-    left to index at the next step. Drawn on its own because an empty fancy
-    selection is a shape the code paths treat separately, and nothing generated
-    one.
-    """
+    This selects no elements. Unlike masks(), which includes a True cell,
+    this strategy exercises empty fancy selections."""
     return st.just(np.zeros(shape, dtype=np.bool_))
 
 
@@ -151,8 +144,7 @@ def slice_selections(shape: tuple[int, ...]) -> st.SearchStrategy[tuple[Any, ...
     """Selections of slices alone, for the `oindex` spelling that carries no coordinates.
 
     Such a step is not a fancy selection — it narrows the view's own axes and
-    composes like basic indexing — so it is legal after a fancy step, where
-    genuine coordinates are not. The starts reach past the origin, which is what
+    composes like basic indexing. The starts reach past the origin, which is what
     distinguishes a step that walks an existing index array's dependency axes
     from one that walks its broadcast singletons.
     """
diff --git a/packages/zarr-indexing/src/zarr_indexing/transform.py b/packages/zarr-indexing/src/zarr_indexing/transform.py
index 975494490c..adf5e5ff09 100644
--- a/packages/zarr-indexing/src/zarr_indexing/transform.py
+++ b/packages/zarr-indexing/src/zarr_indexing/transform.py
@@ -8,8 +8,9 @@
 Key operations:
 
 - **Indexing** (`transform[2:8]`, `.oindex[idx]`, `.vindex[idx]`) —
-  produces a new transform with a narrower input domain and adjusted output
-  maps. No I/O occurs. This is how lazy slicing works.
+  produces a new transform with a new input domain and adjusted output maps.
+  Slices may narrow a domain; fancy indices can repeat cells and enlarge it,
+  and integer/newaxis indexing changes its rank. No I/O occurs.
 
 - **intersect(output_domain)** — restrict to output coordinates within a
   region. This is chunk resolution: "which of my coordinates fall in this
@@ -22,12 +23,13 @@
 
 The transform is the atomic unit that connects user-facing indexing to
 chunk-level I/O. A wrapper holds one — `LazyArray` starts from the identity —
-and `.lazy[...]` composes a new transform lazily rather than reading. Reading
+and `view[...]` composes a new transform lazily rather than reading. Reading
 resolves the transform against the chunk grid via intersect + translate.
 """
 
 from __future__ import annotations
 
+import math
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Literal, cast
 
@@ -397,43 +399,33 @@ def inverted(self) -> IndexTransform:
                 f"{self.input_rank} and {self.output_rank}"
             )
 
+        # Nothing below touches `self`, so validating and building in one pass
+        # leaves no partial state behind when a map is rejected.
         referenced: set[int] = set()
+        inverse_min: list[int] = []
+        inverse_max: list[int] = []
+        inverse_output: dict[int, OutputIndexMap] = {}
         for output_dimension, output_map in enumerate(self.output):
             if isinstance(output_map, ArrayMap):
                 raise ValueError(  # noqa: TRY004 - valid map, invalid inverse
                     f"cannot invert transform: output[{output_dimension}] is an ArrayMap"
                 )
-            if isinstance(output_map, DimensionMap):
-                if output_map.stride not in (-1, 1):
-                    raise ValueError(
-                        "cannot invert transform: DimensionMap stride must be +1 or -1, "
-                        f"got {output_map.stride} for output[{output_dimension}]"
-                    )
-                if output_map.input_dimension in referenced:
-                    raise ValueError(
-                        "cannot invert transform: input dimension "
-                        f"{output_map.input_dimension} is referenced more than once"
-                    )
-                referenced.add(output_map.input_dimension)
-
-        for input_dimension, extent in enumerate(self.domain.shape):
-            if input_dimension not in referenced and extent != 1:
-                raise ValueError(
-                    "cannot invert transform: unreferenced input dimension "
-                    f"{input_dimension} has extent {extent}, not 1"
-                )
-
-        inverse_min: list[int] = []
-        inverse_max: list[int] = []
-        inverse_output: dict[int, OutputIndexMap] = {}
-        for output_dimension, output_map in enumerate(self.output):
             if isinstance(output_map, ConstantMap):
                 inverse_min.append(output_map.offset)
                 inverse_max.append(output_map.offset + 1)
                 continue
-
-            assert isinstance(output_map, DimensionMap)
+            if output_map.stride not in (-1, 1):
+                raise ValueError(
+                    "cannot invert transform: DimensionMap stride must be +1 or -1, "
+                    f"got {output_map.stride} for output[{output_dimension}]"
+                )
             input_dimension = output_map.input_dimension
+            if input_dimension in referenced:
+                raise ValueError(
+                    "cannot invert transform: input dimension "
+                    f"{input_dimension} is referenced more than once"
+                )
+            referenced.add(input_dimension)
             lower = self.domain.inclusive_min[input_dimension]
             upper = self.domain.exclusive_max[input_dimension]
             if output_map.stride == 1:
@@ -452,9 +444,17 @@ def inverted(self) -> IndexTransform:
                     stride=-1,
                 )
 
-        for input_dimension, lower in enumerate(self.domain.inclusive_min):
-            if input_dimension not in referenced:
-                inverse_output[input_dimension] = ConstantMap(lower)
+        for input_dimension, (lower, extent) in enumerate(
+            zip(self.domain.inclusive_min, self.domain.shape, strict=True)
+        ):
+            if input_dimension in referenced:
+                continue
+            if extent != 1:
+                raise ValueError(
+                    "cannot invert transform: unreferenced input dimension "
+                    f"{input_dimension} has extent {extent}, not 1"
+                )
+            inverse_output[input_dimension] = ConstantMap(lower)
 
         return IndexTransform(
             domain=IndexDomain(tuple(inverse_min), tuple(inverse_max)),
@@ -526,10 +526,20 @@ def intersect(
 
         Returns `(restricted_transform, out_indices)` or None if empty.
 
-        `out_indices` carries the surviving output positions: `None` when all
-        positions survive (ConstantMap/DimensionMap only), a single integer array
-        for one ArrayMap (or correlated/vectorized ArrayMaps), or a dict keyed by
-        output dimension for >= 2 orthogonal ArrayMaps (an outer product).
+        `out_indices` is bookkeeping for chunk resolution. `None` means there
+        are no ArrayMaps; the restricted domain itself records surviving input
+        coordinates, which may be fewer than the original domain's. One
+        orthogonal ArrayMap returns its surviving positional indices; multiple
+        orthogonal ArrayMaps return a dict keyed by output dimension. General
+        array maps return a shared scatter array. For paired public coordinate
+        mappings, use `plan_chunks` and its `cell_transform`.
+
+        Raises
+        ------
+        NotImplementedError
+            For a nonempty transform whose ArrayMap has a non-singleton axis
+            also referenced by a DimensionMap. These dependencies cannot be
+            filtered independently by the current intersection implementation.
         """
         return _intersect(self, output_domain)
 
@@ -567,8 +577,10 @@ def __getitem__(self, selection: Any) -> IndexTransform:
 
         No I/O occurs. Integers and slice bounds are literal domain coordinates
         (TensorStore convention): negative values are not counted from the end,
-        and out-of-domain values raise `BoundsCheckError`. Integer indices drop
-        their input dimension; `None` inserts a size-1 dimension.
+        and nonempty out-of-domain slice intervals raise `BoundsCheckError`.
+        Empty slices (`start == stop`) are accepted even outside the domain.
+        Integer indices must lie inside the domain and drop their input
+        dimension; `None` inserts a size-1 dimension.
         """
         return _apply_basic_indexing(self, selection)
 
@@ -637,14 +649,17 @@ def index_array_structure(self) -> Literal["none", "orthogonal", "general"]:
         Returns
         -------
         `"none"` when no output map is an `ArrayMap`; `"orthogonal"` when every
-        `ArrayMap` varies over exactly one input axis, each its own (an outer
-        product, one independent gather per axis); `"general"` otherwise —
+        `ArrayMap` has exactly one non-singleton input axis, distinct from all
+        other ArrayMaps' axes and all DimensionMap input dimensions (one
+        independent gather per axis); `"general"` otherwise —
         correlated (`vindex`) maps sharing their non-singleton axes, maps produced
         by composing fancy steps, maps sharing an input axis (a diagonal gather),
-        and empty or hand-built all-singleton maps whose shape names no axis. The
+        and maps whose shape names no dependency axis. A map can have a
+        non-singleton axis even when another axis has size zero. The
         orthogonal resolvers narrow one axis at a time and are only sound for
         `"orthogonal"`; everything else takes the pointwise path that collapses
-        the joint block. Everything is read off the index arrays' shapes.
+        the joint block or rejects unsupported shared affine/array dependencies.
+        Classification uses index-array shapes and DimensionMap input dimensions.
 
         Examples
         --------
@@ -662,7 +677,7 @@ def index_array_structure(self) -> Literal["none", "orthogonal", "general"]:
         >>> t.vindex[np.array([0, 2]), np.array([1, 3])].index_array_structure
         'general'
         """
-        seen: set[int] = set()
+        seen = {m.input_dimension for m in self.output if isinstance(m, DimensionMap)}
         has_array = False
         for m in self.output:
             if not isinstance(m, ArrayMap):
@@ -777,7 +792,10 @@ def from_json(cls, data: IndexTransformJSON) -> IndexTransform:
         that omitted fields — identity `output`, default bounds and labels —
         are filled and validated, then lowered to the engine representation.
         Lower-rank `index_array`s are widened to the full input rank on the way
-        in.
+        in. Every supplied raw index value is checked against the inclusive
+        `index_array_bounds` before offset, stride, or map simplification.
+        Out-of-bounds values raise `NdselError` immediately, even if a later
+        selection would avoid them. Validated immutable maps do not retain bounds.
 
         Examples
         --------
@@ -789,6 +807,7 @@ def from_json(cls, data: IndexTransformJSON) -> IndexTransform:
         True
         """
         from zarr_indexing._wire import (
+            check_index_array_bounds,
             full_rank_index_array,
             lower_bound,
             lower_index_array,
@@ -825,6 +844,7 @@ def from_json(cls, data: IndexTransformJSON) -> IndexTransform:
             if "index_array" in om:
                 where = f"output[{i}]"
                 arr = lower_index_array(om["index_array"], f"{where}.index_array")
+                check_index_array_bounds(arr, om["index_array_bounds"], where)
                 # ndsel leaves index-array rank unvalidated, so an external
                 # producer may send an array of lower rank that broadcasts
                 # against the domain. Widen it here, on the way in, so every
@@ -1113,7 +1133,7 @@ def _intersect_general(
     transform: IndexTransform,
     output_domain: IndexDomain,
 ) -> tuple[IndexTransform, np.ndarray[Any, np.dtype[np.intp]]] | None:
-    """Intersect a transform with any index-array structure, pointwise.
+    """Intersect array maps jointly when they are independent of residual affine axes.
 
     Every `ArrayMap` — correlated, orthogonal, or several sharing an axis — is
     treated as a lookup table over the joint block of non-slice axes: a block
@@ -1126,8 +1146,10 @@ def _intersect_general(
     keeps its own resolver.
 
     The surviving broadcast axes collapse to a single axis; the returned
-    `out_indices` is the flat scatter index into the (row-major flattened)
-    output buffer, of shape `(surviving_points,) + (residual slice sizes)`.
+    `out_indices` combines positional broadcast offsets with literal residual
+    slice coordinates, of shape `(surviving_points,) + (residual slice sizes)`.
+    Chunk resolution removes residual origins before treating it as a flat
+    offset into the request buffer.
 
     A rank-0 broadcast block — every coordinate array a scalar, as after
     `vindex[...]` narrowed to a single point — has no axis to collapse and stays
@@ -1141,14 +1163,12 @@ def _intersect_general(
     broadcast_shape = block.broadcast_shape
 
     # Joint bounds mask over the broadcast block.
-    combined: np.ndarray[Any, np.dtype[np.bool_]] | None = None
+    combined = np.ones(math.prod(broadcast_shape), dtype=np.bool_)
     for out_dim in correlated_dims:
         storage = block.flat_storage[out_dim]
         lo = output_domain.inclusive_min[out_dim]
         hi = output_domain.exclusive_max[out_dim]
-        mask = (storage >= lo) & (storage < hi)
-        combined = mask if combined is None else (combined & mask)
-    assert combined is not None
+        combined &= (storage >= lo) & (storage < hi)
     surviving = np.flatnonzero(combined).astype(np.intp)
     if surviving.size == 0:
         return None
@@ -1199,19 +1219,18 @@ def _intersect_general(
     corr_shape = points_shape + (1,) * n_slice
     new_output: list[OutputIndexMap] = []
     for out_dim, m in enumerate(transform.output):
-        if out_dim in correlated_dims:
-            corr = cast("ArrayMap", m)
+        if isinstance(m, ArrayMap):
+            # `correlated_dims` is exactly the ArrayMap output dimensions.
             new_output.append(
                 ArrayMap(
                     index_array=corr_values[out_dim].reshape(corr_shape),
-                    offset=corr.offset,
-                    stride=corr.stride,
+                    offset=m.offset,
+                    stride=m.stride,
                 )
             )
         elif isinstance(m, ConstantMap):
             new_output.append(m)
         else:
-            assert isinstance(m, DimensionMap)
             new_output.append(
                 DimensionMap(
                     input_dimension=new_input_dim_of[m.input_dimension],
@@ -1221,10 +1240,9 @@ def _intersect_general(
             )
     result = IndexTransform(domain=new_domain, output=tuple(new_output))
 
-    # Flat scatter index into the caller's row-major output buffer, whose shape
-    # is the *input* domain's shape. The buffer is addressed positionally, so
-    # this assumes a zero-origin domain — the resolvers normalize with
-    # `translate_domain_to` before resolving.
+    # Scatter bookkeeping with row-major input-domain strides. Broadcast
+    # coordinates below are positional; residual coordinates remain literal.
+    # These are not uniformly zero-origin flat indices for nonzero domains.
     #
     # Each surviving point is a flat index into the broadcast block; unravel it
     # to per-axis coordinates so the buffer stride of each broadcast axis is
@@ -1706,8 +1724,9 @@ def _selection_axis_count(selection: Any) -> int:
 def _apply_vindex(transform: IndexTransform, selection: Any) -> IndexTransform:
     """Apply vectorized indexing to an IndexTransform.
 
-    All array indices are broadcast together. Broadcast dimensions are prepended,
-    followed by non-array (slice) dimensions.
+    All array indices are broadcast together. Their broadcast dimensions occupy
+    the advanced indices' position when adjacent, and lead when a slice axis
+    separates the advanced indices (see `_broadcast_insertion_point`).
 
     A transform that already carries index arrays takes the composition path
     (`_compose_selection`) instead of being rewritten in place; see
@@ -1757,7 +1776,7 @@ def _apply_vindex(transform: IndexTransform, selection: Any) -> IndexTransform:
 
     # Separate array dims and slice dims
     array_dims: list[int] = []
-    slice_dims: list[int] = []
+    slices: dict[int, slice] = {}
     arrays: list[np.ndarray[Any, np.dtype[np.intp]]] = []
 
     for i, sel in enumerate(processed):
@@ -1768,7 +1787,8 @@ def _apply_vindex(transform: IndexTransform, selection: Any) -> IndexTransform:
             array_dims.append(i)
             arrays.append(sel)
         else:
-            slice_dims.append(i)
+            slices[i] = sel
+    slice_dims = list(slices)
 
     # Determine the shared domain without expanding the index arrays: their
     # singleton axes describe independent dependencies during grid partitioning.
@@ -1777,12 +1797,10 @@ def _apply_vindex(transform: IndexTransform, selection: Any) -> IndexTransform:
     # Slice dimensions (preserved-domain literal semantics, like basic indexing)
     slice_dim_params: dict[int, tuple[int, int, int]] = {}
     slice_bounds: list[tuple[int, int]] = []
-    for old_dim in slice_dims:
-        sel = processed[old_dim]
-        assert isinstance(sel, slice)
+    for old_dim, sl in slices.items():
         lo = transform.domain.inclusive_min[old_dim]
         hi = transform.domain.exclusive_max[old_dim]
-        start, step, origin, size = _resolve_slice_ts(sel, old_dim, lo, hi)
+        start, step, origin, size = _resolve_slice_ts(sl, old_dim, lo, hi)
         slice_bounds.append((origin, origin + size))
         slice_dim_params[old_dim] = (start, step, origin)
 
diff --git a/packages/zarr-indexing/src/zarr_indexing/writer.py b/packages/zarr-indexing/src/zarr_indexing/writer.py
new file mode 100644
index 0000000000..f18146b71b
--- /dev/null
+++ b/packages/zarr-indexing/src/zarr_indexing/writer.py
@@ -0,0 +1,226 @@
+"""Synchronous writes through coordinate transforms using basic source assignment."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+
+from zarr_indexing.chunk_resolution import plan_chunks
+from zarr_indexing.output_map import ArrayMap, ConstantMap, DimensionMap
+
+if TYPE_CHECKING:
+    from collections.abc import Sequence
+
+    from zarr_indexing.chunk_resolution import ChunkProjection
+    from zarr_indexing.grid import DimensionGridLike
+    from zarr_indexing.transform import IndexTransform
+
+
+def write_into(
+    source: Any,
+    transform: IndexTransform,
+    values: Any,
+    write_grid: Sequence[DimensionGridLike] | None = None,
+) -> None:
+    """Write broadcast values to precisely the cells addressed by ``transform``.
+
+    The source must expose ``shape``, a NumPy-compatible ``dtype``, and basic
+    integer/slice assignment. Values are snapshotted and converted before the
+    first mutation, so source aliases and conversion failures are safe. Extra
+    leading singleton value axes are accepted, as in NumPy assignment. Repeated
+    source coordinates receive the last value in C order of the view.
+
+    Independent affine maps use one basic assignment. Other selections are
+    scattered in bulk: a NumPy source receives one fancy assignment, and a
+    readable source with a ``write_grid`` is written one grid cell at a time —
+    the cell's touched hull is read once, updated in memory, and written back
+    with one basic assignment, so storage round trips are bounded by touched
+    cells. Without a grid, or for the few transforms the planner cannot factor
+    (such as one input axis feeding two output maps), or for a source that
+    cannot be read, the fallback is one integer assignment per element, which
+    never reads. Backend assignment may itself read storage units as part of
+    updating them.
+
+    Source assignment failures propagate and may leave preceding writes
+    applied; this operation is not transactional.
+    """
+    from zarr_indexing.lazy_array import LazyArray
+
+    shape = transform.domain.shape
+    source_shape = tuple(int(extent) for extent in source.shape)
+    if transform.output_rank != len(source_shape):
+        raise ValueError("transform output rank must match the source rank")
+    if isinstance(values, LazyArray):
+        # Its NumPy conversion protocol may discard MaskedArray metadata.
+        values = values.result()
+    if isinstance(source, np.ma.MaskedArray):
+        prepared = np.ma.array(values, dtype=source.dtype, copy=True)
+    else:
+        prepared = np.array(values, dtype=source.dtype, copy=True)
+    while prepared.ndim > len(shape) and prepared.shape[0] == 1:
+        prepared = prepared[0]
+    if isinstance(prepared, np.ma.MaskedArray):
+        broadcast = np.ma.array(
+            np.broadcast_to(prepared.data, shape),
+            mask=np.broadcast_to(np.ma.getmaskarray(prepared), shape),
+            copy=False,
+        )
+    else:
+        broadcast = np.broadcast_to(prepared, shape)
+    if any(extent == 0 for extent in shape):
+        # Values were still converted and broadcast, so a mis-sized RHS is
+        # reported even when the selection happens to be empty.
+        return
+
+    # Check every map's extremal outputs before any assignment. Python integer
+    # arithmetic avoids overflow while computing bounds of affine maps.
+    for extent, output in zip(source_shape, transform.output, strict=True):
+        if isinstance(output, ConstantMap):
+            low = high = output.offset
+        else:
+            if isinstance(output, DimensionMap):
+                axis = output.input_dimension
+                first = transform.domain.inclusive_min[axis]
+                last = transform.domain.exclusive_max[axis] - 1
+            else:
+                first = int(output.index_array.min())
+                last = int(output.index_array.max())
+            endpoints = (
+                output.offset + output.stride * first,
+                output.offset + output.stride * last,
+            )
+            low, high = min(endpoints), max(endpoints)
+        if low < 0 or high >= extent:
+            raise IndexError("transform output coordinates are outside the source shape")
+
+    if _write_affine(source, transform, broadcast):
+        return
+    if len(source_shape) == 0:
+        # A zero-rank source has one cell; no grid or scatter applies.
+        source[()] = broadcast[(0,) * len(shape)]
+        return
+    if isinstance(source, np.ndarray):
+        _scatter_numpy(source, transform, broadcast)
+        return
+    if write_grid is not None and hasattr(source, "__getitem__"):
+        try:
+            # Materialized before any write: an unfactorable transform is
+            # reported by planning, never after some cells were rewritten.
+            projections = list(plan_chunks(transform, tuple(write_grid)))
+        except (ValueError, NotImplementedError):
+            projections = None
+        if projections is not None:
+            _scatter_planned(source, transform, broadcast, projections)
+            return
+    _scatter_elementwise(source, transform, broadcast)
+
+
+def _write_affine(source: Any, transform: IndexTransform, broadcast: Any) -> bool:
+    """Write with one basic assignment when every map is an independent affine map."""
+    shape = transform.domain.shape
+    axes = [
+        output.input_dimension for output in transform.output if isinstance(output, DimensionMap)
+    ]
+    if (
+        len(set(axes)) != len(axes)
+        or any(shape[axis] != 1 for axis in range(len(shape)) if axis not in axes)
+        or any(
+            isinstance(output, DimensionMap) and output.stride == 0 for output in transform.output
+        )
+    ):
+        return False
+    selection: list[int | slice] = []
+    reverse_axes: list[int] = []
+    for output in transform.output:
+        if isinstance(output, ArrayMap):
+            # An index array is a gather, not one basic assignment.
+            return False
+        if isinstance(output, ConstantMap):
+            selection.append(output.offset)
+            continue
+        axis = output.input_dimension
+        start = output.offset + output.stride * transform.domain.inclusive_min[axis]
+        if output.stride < 0:
+            reverse_axes.append(axes.index(axis))
+            selection.append(
+                slice(start + output.stride * (shape[axis] - 1), start + 1, -output.stride)
+            )
+        else:
+            selection.append(slice(start, start + output.stride * shape[axis], output.stride))
+    unused = tuple(axis for axis in range(len(shape)) if axis not in axes)
+    squeezed = np.squeeze(broadcast, axis=unused)
+    remaining = sorted(axes)
+    ordered = np.transpose(squeezed, tuple(remaining.index(axis) for axis in axes))
+    if reverse_axes:
+        # `np.flip` with no axes would hand a zero-rank masked value back as
+        # the shared `masked` singleton, discarding its payload.
+        ordered = np.flip(ordered, axis=tuple(reverse_axes))
+    source[tuple(selection)] = ordered
+    return True
+
+
+def _domain_cells(shape: tuple[int, ...]) -> np.ndarray[Any, np.dtype[np.intp]]:
+    """Every coordinate of a zero-origin domain, one row per cell in C order."""
+    if len(shape) == 0:
+        return np.zeros((1, 0), dtype=np.intp)
+    return np.indices(shape, dtype=np.intp).reshape(len(shape), -1).T
+
+
+def _last_occurrences(flat: np.ndarray[Any, Any]) -> np.ndarray[Any, np.dtype[np.intp]]:
+    """Positions to keep so that repeated flat indices take their last value."""
+    _, first_in_reversed = np.unique(flat[::-1], return_index=True)
+    return np.asarray(len(flat) - 1 - first_in_reversed, dtype=np.intp)
+
+
+def _scatter_numpy(source: np.ndarray[Any, Any], transform: IndexTransform, broadcast: Any) -> None:
+    """One fancy assignment: NumPy sources need no read-modify-write."""
+    positions = _domain_cells(transform.domain.shape)
+    coords = transform.apply_many(positions + np.asarray(transform.domain.inclusive_min))
+    flat = np.asarray(np.ravel_multi_index(tuple(coords.T), source.shape), dtype=np.intp)
+    keep = _last_occurrences(flat)
+    source[tuple(coords[keep].T)] = broadcast[tuple(positions[keep].T)]
+
+
+def _scatter_planned(
+    source: Any,
+    transform: IndexTransform,
+    broadcast: Any,
+    projections: Sequence[ChunkProjection],
+) -> None:
+    """One read-modify-write per touched grid cell, through basic slices only."""
+    origin = np.asarray(transform.domain.inclusive_min, dtype=np.intp)
+    for projection in projections:
+        cells = _domain_cells(projection.chunk_transform.domain.shape)
+        local = projection.chunk_transform.apply_many(cells)
+        positions = projection.cell_transform.apply_many(cells) - origin
+        cell_origin = np.asarray(projection.chunk_domain.inclusive_min, dtype=np.intp)
+        hull_min = local.min(axis=0)
+        hull_shape = tuple(int(n) for n in local.max(axis=0) + 1 - hull_min)
+        box = tuple(
+            slice(int(lo), int(lo + n))
+            for lo, n in zip(cell_origin + hull_min, hull_shape, strict=True)
+        )
+        block = np.array(source[box], dtype=source.dtype, copy=True)
+        flat = np.asarray(
+            np.ravel_multi_index(tuple((local - hull_min).T), hull_shape), dtype=np.intp
+        )
+        keep = _last_occurrences(flat)
+        np.put(block, flat[keep], np.asarray(broadcast[tuple(positions[keep].T)]))
+        source[box] = block
+
+
+def _scatter_elementwise(source: Any, transform: IndexTransform, broadcast: Any) -> None:
+    """One integer assignment per element, for sources that cannot be read."""
+    origin = transform.domain.inclusive_min
+    for position in np.ndindex(transform.domain.shape):
+        point = tuple(start + offset for start, offset in zip(origin, position, strict=True))
+        if isinstance(broadcast, np.ma.MaskedArray):
+            # Masked scalar indexing returns the shared ``masked`` singleton,
+            # discarding the payload. A zero-dimensional array retains both.
+            value = np.ma.array(
+                broadcast.data[position], mask=np.ma.getmaskarray(broadcast)[position]
+            )
+        else:
+            value = broadcast[position]
+        source[transform.apply(point)] = value
diff --git a/packages/zarr-indexing/tests/test_boundary.py b/packages/zarr-indexing/tests/test_boundary.py
new file mode 100644
index 0000000000..92a2e99d4f
--- /dev/null
+++ b/packages/zarr-indexing/tests/test_boundary.py
@@ -0,0 +1,47 @@
+"""Positional array selectors retain their values through bounds validation."""
+
+from typing import Literal
+
+import numpy as np
+import pytest
+
+from zarr_indexing.boundary import normalize_positional_selection
+from zarr_indexing.domain import IndexDomain
+
+
+@pytest.mark.parametrize("dtype", ["i1", "i2", "i4", "i8", "u1", "u2", "u4", "u8"])
+@pytest.mark.parametrize("mode", ["orthogonal", "vectorized"])
+@pytest.mark.parametrize("origin", [-3, 0, 10])
+def test_positional_integer_arrays(
+    dtype: str, mode: Literal["orthogonal", "vectorized"], origin: int
+) -> None:
+    domain = IndexDomain((origin,), (origin + 4,))
+    values = [-4, -1, 0, 3] if np.dtype(dtype).kind == "i" else [0, 3, 0, 3]
+    selector = np.array(values, dtype=dtype)
+    snapshot = selector.copy()
+    normalized = normalize_positional_selection(selector, domain, mode)
+    expected = np.array([value % 4 + origin for value in values], dtype=np.intp)
+    np.testing.assert_array_equal(normalized[0], expected)
+    np.testing.assert_array_equal(selector, snapshot)
+    assert normalized[0].dtype == np.dtype(np.intp)
+
+
+@pytest.mark.parametrize(
+    ("dtype", "value"),
+    [
+        (dtype, value)
+        for dtype in ("i1", "i2", "i4", "i8", "u1", "u2", "u4", "u8")
+        for value in (
+            (int(np.iinfo(dtype).min), -5, 4, int(np.iinfo(dtype).max))
+            if np.dtype(dtype).kind == "i"
+            else (4, int(np.iinfo(dtype).max))
+        )
+    ],
+)
+@pytest.mark.parametrize("mode", ["orthogonal", "vectorized"])
+def test_positional_integer_array_out_of_bounds(
+    dtype: str, value: int, mode: Literal["orthogonal", "vectorized"]
+) -> None:
+    selector = np.array([value], dtype=dtype)
+    with pytest.raises(IndexError, match="out of bounds"):
+        normalize_positional_selection(selector, IndexDomain.from_shape((4,)), mode)
diff --git a/packages/zarr-indexing/tests/test_chunk_resolution.py b/packages/zarr-indexing/tests/test_chunk_resolution.py
index ef67c2cedb..8570fd34d2 100644
--- a/packages/zarr-indexing/tests/test_chunk_resolution.py
+++ b/packages/zarr-indexing/tests/test_chunk_resolution.py
@@ -4,7 +4,7 @@
 
 import numpy as np
 import pytest
-from hypothesis import assume, given
+from hypothesis import assume, given, settings
 from hypothesis import strategies as st
 
 import zarr_indexing
@@ -56,6 +56,52 @@ def _points(domain: IndexDomain) -> list[tuple[int, ...]]:
     ]
 
 
+@pytest.mark.parametrize("shape", [(4,), (2, 2)])
+@pytest.mark.parametrize(
+    "coordinates",
+    [
+        [(-1, 0), (0, -1), (-1, 0), (0, 0)],
+        [(-2, -1), (-1, -2), (-2, -2), (-1, -1)],
+        [(0, 1), (1, 0), (0, 1), (0, 0)],
+        [(-(2**63), 0), (0, -(2**63)), (-1, -1), (0, 0)],
+    ],
+)
+def test_correlated_plan_with_signed_chunk_ids(
+    shape: tuple[int, ...], coordinates: list[tuple[int, int]]
+) -> None:
+    """Shared-axis lookups group distinct signed chunk tuples without collisions."""
+
+    class SignedUnitGrid:
+        def index_to_chunk(self, index: int) -> int:
+            return index
+
+        def indices_to_chunks(self, indices: Any) -> Any:
+            return indices
+
+        def chunk_offset(self, chunk: int) -> int:
+            return chunk
+
+        def chunk_size(self, chunk: int) -> int:
+            return 1
+
+    values = np.array(coordinates, dtype=np.intp)
+    transform = IndexTransform(
+        IndexDomain.from_shape(shape),
+        tuple(ArrayMap(values[:, axis].reshape(shape)) for axis in range(2)),
+    )
+    plan = plan_chunks(transform, (SignedUnitGrid(), SignedUnitGrid()))
+    expected_chunks = sorted(set(coordinates))
+    assert [tuple(row) for row in plan.partition().chunk_coords()] == expected_chunks
+    seen = []
+    for projection in plan:
+        for point in _points(projection.chunk_transform.domain):
+            assert _storage_of(projection.chunk_transform, point) == (0, 0)
+            request_point = _storage_of(projection.cell_transform, point)
+            assert _storage_of(transform, request_point) == projection.chunk_coords
+            seen.append(request_point)
+    assert sorted(seen) == sorted(_points(transform.domain))
+
+
 def test_basic_plan_is_reiterable_and_projects_both_spaces() -> None:
     """A plan can be revisited without losing either side of each projection."""
     transform = IndexTransform.from_shape((6,))[1:6]
@@ -782,7 +828,7 @@ def test_mixed_affine_array_dependency_is_rejected() -> None:
         IndexDomain.from_shape((4,)), (DimensionMap(0), ArrayMap(np.array([3, 2, 1, 0])))
     )
     grids = dimension_grids_from_chunks((2, 2), shape=(4, 4))
-    with pytest.raises(ValueError, match="read input axis 0"):
+    with pytest.raises(NotImplementedError, match="also bound by a slice map"):
         list(plan_chunks(transform, grids))
 
 
@@ -897,7 +943,7 @@ def test_independent_components_scatter_through_lazy_array(reader_kind: str) ->
     b = np.array([5, 1, 3])[:, None]
     c = np.array([6, 0, 6, 2])[None, :]
     wrapped = LazyArray.from_numpy(source) if reader_kind == "numpy" else LazyArray(source)
-    view = wrapped.with_parts((2, 3, 2, 2)).lazy.vindex[a, b, c, ...]
+    view = wrapped.with_parts((2, 3, 2, 2)).vindex[a, b, c, ...]
     assert (
         len(
             plan_chunks(view.transform, dimension_grids_from_chunks((2, 3, 2, 2), source.shape))
@@ -909,25 +955,125 @@ def test_independent_components_scatter_through_lazy_array(reader_kind: str) ->
     np.testing.assert_array_equal(view.result(), source[a, b, c, :])
 
 
-@given(data=st.data())
-def test_component_dependency_graph_matches_pointwise_oracle(data: st.DataObject) -> None:
-    shape = tuple(data.draw(st.lists(st.integers(1, 3), min_size=0, max_size=3)))
+class SignedGrid:
+    """An unbounded grid with translated boundaries and signed chunk identifiers."""
+
+    def __init__(self, size: int, origin: int) -> None:
+        self.size = size
+        self.origin = origin
+
+    def index_to_chunk(self, index: int) -> int:
+        return (index - self.origin) // self.size
+
+    def indices_to_chunks(
+        self, indices: np.ndarray[Any, np.dtype[np.intp]]
+    ) -> np.ndarray[Any, np.dtype[np.intp]]:
+        return (indices - self.origin) // self.size
+
+    def chunk_offset(self, chunk: int) -> int:
+        return self.origin + chunk * self.size
+
+    def chunk_size(self, chunk: int) -> int:
+        return self.size
+
+
+@settings(max_examples=300)
+@given(data=st.data(), shape=st.lists(st.integers(0, 3), min_size=0, max_size=3))
+def test_component_dependency_graph_matches_pointwise_oracle(
+    data: st.DataObject, shape: list[int]
+) -> None:
+    """Catch lost duplicates, signed chunk collisions, and incorrect request origins.
+
+    Enumerate the transform's small domain directly: no planner intersection,
+    grouping, or dependency helpers contribute to the expected mapping.
+    """
+    origin = tuple(data.draw(st.integers(-4, 4)) for _ in shape)
     output_rank = data.draw(st.integers(1, 5))
-    maps = []
+    affine_axes = {axis for axis in range(len(shape)) if data.draw(st.booleans())}
+    maps: list[ArrayMap | ConstantMap | DimensionMap] = [
+        DimensionMap(
+            axis, offset=data.draw(st.integers(-3, 3)), stride=data.draw(st.integers(-2, 2))
+        )
+        for axis in sorted(affine_axes)
+    ]
     for _ in range(output_rank):
-        dependencies = data.draw(st.lists(st.booleans(), min_size=len(shape), max_size=len(shape)))
+        if data.draw(st.booleans()):
+            maps.append(ConstantMap(data.draw(st.integers(-3, 3))))
+            continue
+        # Reserve affine axes for one DimensionMap each. Unsupported shared
+        # affine dependencies are exercised explicitly in the error properties.
+        dependencies = [
+            axis not in affine_axes and data.draw(st.booleans()) for axis in range(len(shape))
+        ]
         array_shape = tuple(
             size if dependent else 1 for size, dependent in zip(shape, dependencies, strict=True)
         )
         count = int(np.prod(array_shape))
-        values = data.draw(st.lists(st.integers(0, 3), min_size=count, max_size=count))
-        maps.append(ArrayMap(np.array(values, dtype=np.intp).reshape(array_shape)))
-    transform = IndexTransform(IndexDomain.from_shape(shape), tuple(maps))
-    grids = dimension_grids_from_chunks((2,) * output_rank, (4,) * output_rank)
-    partition = plan_chunks(transform, grids).partition()
+        # A small value range produces repeated storage points at distinct request positions.
+        values = data.draw(st.lists(st.integers(-2, 2), min_size=count, max_size=count))
+        maps.append(
+            ArrayMap(
+                np.array(values, dtype=np.intp).reshape(array_shape),
+                offset=data.draw(st.integers(-3, 3)),
+                stride=data.draw(st.integers(-2, 2)),
+            )
+        )
+    grids = [SignedGrid(data.draw(st.integers(1, 3)), data.draw(st.integers(-3, 3))) for _ in maps]
+    transform = IndexTransform(
+        IndexDomain(origin, tuple(lo + size for lo, size in zip(origin, shape, strict=True))),
+        tuple(maps),
+    )
+    expected = {point: _storage_of(transform, point) for point in _points(transform.domain)}
+    expected_chunks = {
+        tuple(grid.index_to_chunk(value) for grid, value in zip(grids, storage, strict=True))
+        for storage in expected.values()
+    }
+    partition = plan_chunks(transform, tuple(grids)).partition()
     rows = list(partition)
     _check_projections(transform, rows)
+    assert {row.chunk_coords for row in rows} == expected_chunks
+    assert len(rows) == len(expected_chunks)
     assert partition.chunk_coords().tolist() == [list(row.chunk_coords) for row in rows]
+    reconstructed = []
+    for row in rows:
+        assert row.chunk_domain.inclusive_min == tuple(
+            grid.chunk_offset(chunk) for grid, chunk in zip(grids, row.chunk_coords, strict=True)
+        )
+        for cell in _points(row.cell_transform.domain):
+            request = _storage_of(row.cell_transform, cell)
+            storage = tuple(
+                local + grid.chunk_offset(chunk)
+                for local, grid, chunk in zip(
+                    _storage_of(row.chunk_transform, cell), grids, row.chunk_coords, strict=True
+                )
+            )
+            reconstructed.append((request, storage))
+    # A list comparison retains multiplicity: repeating one position cannot hide a missing one.
+    assert sorted(reconstructed) == sorted(expected.items())
+
+
+@given(origin=st.integers(-4, 4), size=st.integers(2, 5), stride=st.sampled_from([-2, -1, 1, 2]))
+def test_generated_shared_affine_dependency_is_rejected(
+    origin: int, size: int, stride: int
+) -> None:
+    transform = IndexTransform(
+        IndexDomain((origin,), (origin + size,)),
+        (DimensionMap(0, stride=stride), DimensionMap(0, offset=3)),
+    )
+    with pytest.raises(ValueError, match="read input axis 0"):
+        list(plan_chunks(transform, (SignedGrid(2, -1), SignedGrid(3, 1))))
+
+
+@given(origin=st.integers(-4, 4), size=st.integers(2, 5), stride=st.sampled_from([-2, -1, 1, 2]))
+def test_generated_mixed_affine_array_dependency_is_rejected(
+    origin: int, size: int, stride: int
+) -> None:
+    transform = IndexTransform(
+        IndexDomain((origin,), (origin + size,)),
+        (DimensionMap(0, stride=stride), ArrayMap(np.zeros(size, dtype=np.intp))),
+    )
+    with pytest.raises(NotImplementedError, match="also bound by a slice map"):
+        list(plan_chunks(transform, (SignedGrid(2, -1), SignedGrid(3, 1))))
 
 
 @pytest.mark.parametrize("stride", [0, 1, 2, -2])
diff --git a/packages/zarr-indexing/tests/test_composition.py b/packages/zarr-indexing/tests/test_composition.py
index 0cb6155344..74e7ed443d 100644
--- a/packages/zarr-indexing/tests/test_composition.py
+++ b/packages/zarr-indexing/tests/test_composition.py
@@ -440,11 +440,7 @@ def test_composing_an_inner_array_with_a_broadcast_axis_wider_than_one_cell() ->
 
 
 def test_composing_a_one_dimensional_inner_array_under_a_higher_rank_outer() -> None:
-    """The shortcut gated on the output rank but sized by the input rank.
-
-    A rank-2 outer therefore built a rank-1 array for a rank-2 domain, which the
-    engine's own invariant then rejected.
-    """
+    """Composed index arrays retain the full input rank of their domain."""
     outer = IndexTransform(
         domain=IndexDomain.from_shape((2, 3)),
         output=(DimensionMap(input_dimension=0, offset=1, stride=1),),
diff --git a/packages/zarr-indexing/tests/test_doc_examples.py b/packages/zarr-indexing/tests/test_doc_examples.py
index a4833296da..2af51f4a80 100644
--- a/packages/zarr-indexing/tests/test_doc_examples.py
+++ b/packages/zarr-indexing/tests/test_doc_examples.py
@@ -35,6 +35,7 @@
 import zarr_indexing
 import zarr_indexing.lazy_array as lazy_array_module
 from zarr_indexing import IndexTransform, LazyArray, ReadContext
+from zarr_indexing.domain import IndexDomain
 
 DOCS = Path(__file__).parents[1] / "docs"
 PACKAGE_ROOT = DOCS.parent
@@ -72,7 +73,7 @@ def _markdown_includes() -> tuple[tuple[str, str, str | None], ...]:
 PATTERN_CASES: tuple[dict[str, Any], ...] = PATTERN_NAMESPACE["PATTERN_CASES"]
 CACHE_NAMESPACE: dict[str, Any] = runpy.run_path(str(CACHE_EXAMPLE))
 
-# The documented pattern matrix must keep covering every selection family.
+# The documented pattern matrix must keep its listed selection families.
 REQUIRED_PATTERNS = {
     "basic-slice",
     "integer-axis-removal",
@@ -133,7 +134,7 @@ def test_documentation_example_executes(example: Path) -> None:
 
 @pytest.mark.parametrize("script", CLI_EXAMPLES, ids=lambda path: path.stem)
 def test_cli_example_runs_as_a_subprocess(script: Path) -> None:
-    """The CLI examples exit 0 when run the way their READMEs instruct."""
+    """CLI examples exit 0 with this test environment's installed dependencies."""
     if "dask" in script.stem:
         pytest.importorskip("dask.array")
     completed = subprocess.run(
@@ -203,9 +204,9 @@ def test_indexing_pattern_matrix_matches_numpy(case: dict[str, Any]) -> None:
     image = PATTERN_NAMESPACE["image"]
     lazy = LazyArray.from_numpy(image)
     accessor = {
-        "basic": lazy.lazy,
-        "oindex": lazy.lazy.oindex,
-        "vindex": lazy.lazy.vindex,
+        "basic": lazy,
+        "oindex": lazy.oindex,
+        "vindex": lazy.vindex,
     }[case["mode"]]
     view = accessor[case["selection"]]
     result = view.result()
@@ -242,7 +243,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> object:
             return self.data[key].tolist()
 
     source = ListSlabSource()
-    result = LazyArray(source).with_parts((2, 3)).lazy.oindex[[3, 1, 1], 1:5:2].result()
+    result = LazyArray(source).with_parts((2, 3)).oindex[[3, 1, 1], 1:5:2].result()
 
     np.testing.assert_array_equal(result, np.array([[16, 18], [6, 8], [6, 8]]))
     assert len(source.keys) > 0
@@ -251,7 +252,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> object:
 
 def test_coordinate_array_example_preserves_order_and_duplicates() -> None:
     """Coordinate arrays are ordered sequences, not mathematical sets."""
-    view = LazyArray.from_numpy(np.arange(6)).with_parts((2,)).lazy.oindex[[4, 1, 1, 3]]
+    view = LazyArray.from_numpy(np.arange(6)).with_parts((2,)).oindex[[4, 1, 1, 3]]
 
     np.testing.assert_array_equal(view.result(), np.array([4, 1, 1, 3]))
     assembled = np.empty(view.shape, dtype=view.dtype)
@@ -264,8 +265,9 @@ def test_documented_partition_transform_is_global_and_projection_is_chunk_local(
     source = np.arange(8)
     part = tuple(LazyArray.from_numpy(source).with_parts((4,)).parts())[1]
 
-    assert part.view.transform.apply((0,)) == (4,)
-    assert part.view.array[part.view.transform.apply((0,))] == 4
+    assert part.view.transform.domain == IndexDomain((4,), (8,))
+    assert part.view.transform.apply((4,)) == (4,)
+    assert part.view.array[part.view.transform.apply((4,))] == 4
     assert part.projection.chunk_transform.apply((0,)) == (0,)
 
 
@@ -378,7 +380,7 @@ def test_chunk_cache_reader_resolves_a_transform_from_cached_chunks() -> None:
     reader_type = CACHE_NAMESPACE["SystemMemoryChunkReader"]
     source = source_type(np.arange(48).reshape(6, 8), chunks=(3, 4))
     reader = reader_type(capacity=2)
-    view = LazyArray(source).with_reader(reader).lazy[1:5, 2]
+    view = LazyArray(source).with_reader(reader)[1:5, 2]
     parts = tuple(view.parts())
     out = np.empty(view.shape, dtype=source.dtype)
     for part in parts:
diff --git a/packages/zarr-indexing/tests/test_json.py b/packages/zarr-indexing/tests/test_json.py
index 9848c6801f..210ee2dbbe 100644
--- a/packages/zarr-indexing/tests/test_json.py
+++ b/packages/zarr-indexing/tests/test_json.py
@@ -347,9 +347,8 @@ def _index_array_body(index_array: Any, rank: int = 1, extent: int = 2) -> Index
         ([True, False], "bool"),
         (["a", "b"], "str"),
         # Not lists at all, so they are turned away before their content is
-        # looked at: a bare string would be iterated into characters, and a bare
-        # integer would become a rank-0 array and then a length-1 map, so a
-        # document naming no cells would select one.
+        # looked at: the wire representation requires a nested array rather
+        # than a scalar string or integer.
         ("abc", "must be an array of integers"),
         (5, "must be an array of integers"),
         ([None, None], "object"),
@@ -357,12 +356,7 @@ def _index_array_body(index_array: Any, rank: int = 1, extent: int = 2) -> Index
     ids=["floats", "mixed", "bools", "strings", "string", "scalar", "nulls"],
 )
 def test_a_non_integer_index_array_is_rejected(index_array: Any, detail: str) -> None:
-    """An `index_array` addresses output coordinates, so it must be integral.
-
-    Lowering a float array silently truncated it (`[0.9, 1.9]` selected cells 0
-    and 1), a bool array coerced to 0/1, and a string array leaked a raw NumPy
-    `ValueError` from the middle of the conversion.
-    """
+    """Index arrays require integer coordinates and reject float, bool, and string dtypes."""
     with pytest.raises(NdselError) as excinfo:
         IndexTransform.from_json(_index_array_body(index_array))
     assert excinfo.value.reason == "invalid_json"
@@ -547,13 +541,7 @@ def test_an_ambiguous_empty_index_array_is_rejected() -> None:
     ids=["float", "string", "bool", "non-string-label", "out-of-range"],
 )
 def test_a_malformed_domain_document_is_rejected(document: Any, reason: str, detail: str) -> None:
-    """The domain loader validates what the message layer validates.
-
-    Reading the keys directly was a second, undefended way into the same
-    objects: a bare `int()` truncated `3.9` to 3, coerced `"3"` and `True`, and
-    let a non-string label into a `tuple[str, ...]` — each building a domain
-    that was not the document's, and re-dumping as a different document.
-    """
+    """The domain loader enforces coordinate types, integer bounds, and string labels."""
     with pytest.raises(NdselError) as excinfo:
         IndexDomain.from_json(document)
     assert excinfo.value.reason == reason
diff --git a/packages/zarr-indexing/tests/test_lazy_array.py b/packages/zarr-indexing/tests/test_lazy_array.py
index 003e04c50f..787b408c26 100644
--- a/packages/zarr-indexing/tests/test_lazy_array.py
+++ b/packages/zarr-indexing/tests/test_lazy_array.py
@@ -26,8 +26,10 @@
     ChunkProjection,
     ConstantMap,
     DimensionMap,
+    EagerArrayAdapter,
     EdgeDimensionGrid,
     FixedDimension,
+    IndexDomain,
     IndexTransform,
     LazyArray,
     ReadContext,
@@ -276,11 +278,7 @@ def test_array_map_dependent_axis_reports_no_axis() -> None:
 
 
 def test_scalar_on_a_fancy_axis_collapses_to_a_constant() -> None:
-    """The degenerate-collapse rule: an all-singleton ArrayMap becomes a ConstantMap.
-
-    Without it the map keeps an `input_dimension` naming an axis the integer
-    index just removed, which after renumbering aliases a different axis.
-    """
+    """Scalar selection collapses an all-singleton ArrayMap to a ConstantMap."""
     view = IndexTransform.from_shape((7, 5)).oindex[np.array([3, 1]), slice(None)][0]
     assert view.output[0] == ConstantMap(offset=3)
     assert isinstance(view.output[1], DimensionMap)
@@ -345,27 +343,27 @@ def source(request: pytest.FixtureRequest) -> LazyArray:
 CASES: list[tuple[str, Callable[[LazyArray], LazyArray], Callable[[Any], Any]]] = [
     (
         "basic-strided-and-int-drop",
-        lambda a: a.lazy[1:6:2, :, -1],
+        lambda a: a[1:6:2, :, -1],
         lambda r: r[1:6:2, :, -1],
     ),
-    ("basic-ellipsis", lambda a: a.lazy[..., -2], lambda r: r[..., -2]),
-    ("basic-negative-scalar", lambda a: a.lazy[-3], lambda r: r[-3]),
-    ("basic-newaxis", lambda a: a.lazy[None, :, :, None], lambda r: r[None, :, :, None]),
-    ("basic-empty", lambda a: a.lazy[:, 2:2, :], lambda r: r[:, 2:2, :]),
-    ("basic-all-scalars", lambda a: a.lazy[-1, 0, 2], lambda r: r[-1, 0, 2]),
+    ("basic-ellipsis", lambda a: a[..., -2], lambda r: r[..., -2]),
+    ("basic-negative-scalar", lambda a: a[-3], lambda r: r[-3]),
+    ("basic-newaxis", lambda a: a[None, :, :, None], lambda r: r[None, :, :, None]),
+    ("basic-empty", lambda a: a[:, 2:2, :], lambda r: r[:, 2:2, :]),
+    ("basic-all-scalars", lambda a: a[-1, 0, 2], lambda r: r[-1, 0, 2]),
     (
         "oindex-unsorted-duplicates-multi-axis",
-        lambda a: a.lazy.oindex[[4, 0, 0, 2], :, [3, 1]],
+        lambda a: a.oindex[[4, 0, 0, 2], :, [3, 1]],
         lambda r: outer(r, ([4, 0, 0, 2], slice(None), [3, 1])),
     ),
     (
         "oindex-negative-and-slice",
-        lambda a: a.lazy.oindex[:, [-1, 0], 1:4],
+        lambda a: a.oindex[:, [-1, 0], 1:4],
         lambda r: outer(r, (slice(None), [-1, 0], slice(1, 4))),
     ),
     (
         "oindex-boolean-axis",
-        lambda a: a.lazy.oindex[np.array([True, False, True, False, False, False, True]), :, :],
+        lambda a: a.oindex[np.array([True, False, True, False, False, False, True]), :, :],
         lambda r: outer(
             r,
             (np.array([True, False, True, False, False, False, True]), slice(None), slice(None)),
@@ -373,115 +371,111 @@ def source(request: pytest.FixtureRequest) -> LazyArray:
     ),
     (
         "vindex-coordinates",
-        lambda a: a.lazy.vindex[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])],
+        lambda a: a.vindex[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])],
         lambda r: r[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])],
     ),
     (
         "vindex-broadcast-pair",
-        lambda a: a.lazy.vindex[np.array([[0], [6]]), np.array([1, 4]), np.array([2, 0])],
+        lambda a: a.vindex[np.array([[0], [6]]), np.array([1, 4]), np.array([2, 0])],
         lambda r: r[np.array([[0], [6]]), np.array([1, 4]), np.array([2, 0])],
     ),
     (
         "vindex-negative-coordinates",
-        lambda a: a.lazy.vindex[np.array([-1, -7]), np.array([-2, 0]), np.array([0, -1])],
+        lambda a: a.vindex[np.array([-1, -7]), np.array([-2, 0]), np.array([0, -1])],
         lambda r: r[np.array([-1, -7]), np.array([-2, 0]), np.array([0, -1])],
     ),
-    ("vindex-mask", lambda a: a.lazy.vindex[MASK], lambda r: r[MASK]),
+    ("vindex-mask", lambda a: a.vindex[MASK], lambda r: r[MASK]),
     (
         "compose-basic-then-oindex",
-        lambda a: a.lazy[1:6].lazy.oindex[[3, 0, 0], [4, 1], :],
+        lambda a: a[1:6].oindex[[3, 0, 0], [4, 1], :],
         lambda r: outer(r[1:6], ([3, 0, 0], [4, 1], slice(None))),
     ),
     (
         "compose-oindex-then-basic-other-axis",
-        lambda a: a.lazy.oindex[[4, 0, 2], :, :].lazy[:, 1:4, ::2],
+        lambda a: a.oindex[[4, 0, 2], :, :][:, 1:4, ::2],
         lambda r: outer(r, ([4, 0, 2], slice(None), slice(None)))[:, 1:4, ::2],
     ),
     (
         "compose-basic-then-basic",
-        lambda a: a.lazy[2:, 1:].lazy[::2, -1],
+        lambda a: a[2:, 1:][::2, -1],
         lambda r: r[2:, 1:][::2, -1],
     ),
     (
         "compose-basic-then-vindex",
-        lambda a: a.lazy[1:6, :, 1:].lazy.vindex[
-            np.array([0, 4]), np.array([2, 0]), np.array([1, 2])
-        ],
+        lambda a: a[1:6, :, 1:].vindex[np.array([0, 4]), np.array([2, 0]), np.array([1, 2])],
         lambda r: r[1:6, :, 1:][np.array([0, 4]), np.array([2, 0]), np.array([1, 2])],
     ),
     # Scalar integers are basic indices in the positional dialect: they drop the
     # axis, in every mode, exactly as NumPy does.
-    ("oindex-scalar-drops-axis", lambda a: a.lazy.oindex[0], lambda r: r[0]),
+    ("oindex-scalar-drops-axis", lambda a: a.oindex[0], lambda r: r[0]),
     (
         "oindex-scalar-with-arrays",
-        lambda a: a.lazy.oindex[0, [1, 2], :],
+        lambda a: a.oindex[0, [1, 2], :],
         lambda r: outer(r, (0, [1, 2], slice(None))),
     ),
     (
         "oindex-scalar-middle-axis",
-        lambda a: a.lazy.oindex[[3, 1], -1, :],
+        lambda a: a.oindex[[3, 1], -1, :],
         lambda r: outer(r, ([3, 1], -1, slice(None))),
     ),
-    ("oindex-all-scalars", lambda a: a.lazy.oindex[0, 1, 2], lambda r: r[0, 1, 2]),
-    ("vindex-all-scalars", lambda a: a.lazy.vindex[0, 1, 2], lambda r: r[0, 1, 2]),
+    ("oindex-all-scalars", lambda a: a.oindex[0, 1, 2], lambda r: r[0, 1, 2]),
+    ("vindex-all-scalars", lambda a: a.vindex[0, 1, 2], lambda r: r[0, 1, 2]),
     (
         "vindex-scalar-with-arrays",
-        lambda a: a.lazy.vindex[0, [1, 2], [3, 0]],
+        lambda a: a.vindex[0, [1, 2], [3, 0]],
         lambda r: r[0, [1, 2], [3, 0]],
     ),
     (
         "vindex-scalar-on-middle-axis",
-        lambda a: a.lazy.vindex[[1, 2], 0, [3, 0]],
+        lambda a: a.vindex[[1, 2], 0, [3, 0]],
         lambda r: r[[1, 2], 0, [3, 0]],
     ),
     # Scalar applied to a previously fancy-indexed axis, both orders.
     (
         "compose-oindex-then-scalar",
-        lambda a: a.lazy.oindex[[3, 1], :, :].lazy[0],
+        lambda a: a.oindex[[3, 1], :, :][0],
         lambda r: outer(r, ([3, 1], slice(None), slice(None)))[0],
     ),
     (
         "compose-oindex-then-scalar-negative",
-        lambda a: a.lazy.oindex[[3, 1, 1], :, :].lazy[-1, 2],
+        lambda a: a.oindex[[3, 1, 1], :, :][-1, 2],
         lambda r: outer(r, ([3, 1, 1], slice(None), slice(None)))[-1, 2],
     ),
     (
         "compose-scalar-then-oindex",
-        lambda a: a.lazy[0].lazy.oindex[[3, 1], :],
+        lambda a: a[0].oindex[[3, 1], :],
         lambda r: outer(r[0], ([3, 1], slice(None))),
     ),
     (
         "compose-vindex-then-scalar",
-        lambda a: a.lazy.vindex[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])].lazy[
-            1
-        ],
+        lambda a: a.vindex[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])][1],
         lambda r: r[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])][1],
     ),
     # Partial vindex whose coordinate arrays are NOT on the leading axes: NumPy
     # inserts the gathered axis where the (adjacent) advanced indices sat.
     (
         "vindex-trailing-arrays",
-        lambda a: a.lazy.vindex[..., np.array([1, 4, 0]), np.array([2, 0, 1])],
+        lambda a: a.vindex[..., np.array([1, 4, 0]), np.array([2, 0, 1])],
         lambda r: r[..., np.array([1, 4, 0]), np.array([2, 0, 1])],
     ),
     (
         "vindex-single-trailing-array",
-        lambda a: a.lazy.vindex[..., np.array([3, 0, 1])],
+        lambda a: a.vindex[..., np.array([3, 0, 1])],
         lambda r: r[..., np.array([3, 0, 1])],
     ),
     (
         "vindex-trailing-mask",
-        lambda a: a.lazy.vindex[..., TRAILING_MASK],
+        lambda a: a.vindex[..., TRAILING_MASK],
         lambda r: r[..., TRAILING_MASK],
     ),
     (
         "vindex-leading-partial",
-        lambda a: a.lazy.vindex[np.array([1, 2, 2])],
+        lambda a: a.vindex[np.array([1, 2, 2])],
         lambda r: r[np.array([1, 2, 2])],
     ),
     (
         "compose-basic-then-vindex-trailing",
-        lambda a: a.lazy[2:, 1:].lazy.vindex[..., np.array([1, 3, 0])],
+        lambda a: a[2:, 1:].vindex[..., np.array([1, 3, 0])],
         lambda r: r[2:, 1:][..., np.array([1, 3, 0])],
     ),
     # A ConstantMap sitting between a slice and the coordinate arrays: NumPy
@@ -489,7 +483,7 @@ def source(request: pytest.FixtureRequest) -> LazyArray:
     # front of the chunk block even though the arrays are trailing.
     (
         "compose-vindex-trailing-then-scalar",
-        lambda a: a.lazy.vindex[..., np.array([3, 0])].lazy[2],
+        lambda a: a.vindex[..., np.array([3, 0])][2],
         lambda r: r[..., np.array([3, 0])][2],
     ),
     # Two fancy axes, then a scalar on the first: the surviving ArrayMap ends up
@@ -497,57 +491,57 @@ def source(request: pytest.FixtureRequest) -> LazyArray:
     # advanced rule bites.
     (
         "compose-oindex-two-axes-then-scalar",
-        lambda a: a.lazy.oindex[[3, 1, 0], 3:5, [2, 0, 2]].lazy[0],
+        lambda a: a.oindex[[3, 1, 0], 3:5, [2, 0, 2]][0],
         lambda r: outer(r, ([3, 1, 0], slice(3, 5), [2, 0, 2]))[0],
     ),
     # Negative steps: the positional dialect is NumPy's, including the empty
     # cases NumPy allows where the transform algebra alone would object.
-    ("reverse", lambda a: a.lazy[::-1], lambda r: r[::-1]),
-    ("reverse-every-axis", lambda a: a.lazy[::-1, ::-1, ::-1], lambda r: r[::-1, ::-1, ::-1]),
-    ("reverse-strided", lambda a: a.lazy[::-2], lambda r: r[::-2]),
-    ("reverse-nondivisible", lambda a: a.lazy[::-3], lambda r: r[::-3]),
-    ("reverse-bounded", lambda a: a.lazy[5:1:-1], lambda r: r[5:1:-1]),
-    ("reverse-negative-start", lambda a: a.lazy[-1:None:-1], lambda r: r[-1:None:-1]),
-    ("reverse-past-the-start", lambda a: a.lazy[:-8:-1], lambda r: r[:-8:-1]),
-    ("reverse-empty", lambda a: a.lazy[2:2:-1], lambda r: r[2:2:-1]),
+    ("reverse", lambda a: a[::-1], lambda r: r[::-1]),
+    ("reverse-every-axis", lambda a: a[::-1, ::-1, ::-1], lambda r: r[::-1, ::-1, ::-1]),
+    ("reverse-strided", lambda a: a[::-2], lambda r: r[::-2]),
+    ("reverse-nondivisible", lambda a: a[::-3], lambda r: r[::-3]),
+    ("reverse-bounded", lambda a: a[5:1:-1], lambda r: r[5:1:-1]),
+    ("reverse-negative-start", lambda a: a[-1:None:-1], lambda r: r[-1:None:-1]),
+    ("reverse-past-the-start", lambda a: a[:-8:-1], lambda r: r[:-8:-1]),
+    ("reverse-empty", lambda a: a[2:2:-1], lambda r: r[2:2:-1]),
     # NumPy reads a reversed *positional* interval as empty; only the literal
     # layer calls it a direction error.
-    ("reverse-inverted-is-empty", lambda a: a.lazy[2:5:-1], lambda r: r[2:5:-1]),
-    ("reverse-with-int-drop", lambda a: a.lazy[::-2, 2, ::-1], lambda r: r[::-2, 2, ::-1]),
-    ("reverse-trailing-axis", lambda a: a.lazy[..., ::-1], lambda r: r[..., ::-1]),
+    ("reverse-inverted-is-empty", lambda a: a[2:5:-1], lambda r: r[2:5:-1]),
+    ("reverse-with-int-drop", lambda a: a[::-2, 2, ::-1], lambda r: r[::-2, 2, ::-1]),
+    ("reverse-trailing-axis", lambda a: a[..., ::-1], lambda r: r[..., ::-1]),
     (
         "compose-reverse-then-reverse",
-        lambda a: a.lazy[::-1].lazy[::-1],
+        lambda a: a[::-1][::-1],
         lambda r: r[::-1][::-1],
     ),
     (
         "compose-strided-then-reverse",
-        lambda a: a.lazy[::2].lazy[::-1],
+        lambda a: a[::2][::-1],
         lambda r: r[::2][::-1],
     ),
     (
         "compose-reverse-then-strided",
-        lambda a: a.lazy[::-1].lazy[::2],
+        lambda a: a[::-1][::2],
         lambda r: r[::-1][::2],
     ),
     (
         "compose-reverse-then-oindex",
-        lambda a: a.lazy[::-1].lazy.oindex[[3, 0, 0], :, :],
+        lambda a: a[::-1].oindex[[3, 0, 0], :, :],
         lambda r: outer(r[::-1], ([3, 0, 0], slice(None), slice(None))),
     ),
     (
         "compose-oindex-then-reverse",
-        lambda a: a.lazy.oindex[[3, 1, 2], :, :].lazy[::-1],
+        lambda a: a.oindex[[3, 1, 2], :, :][::-1],
         lambda r: outer(r, ([3, 1, 2], slice(None), slice(None)))[::-1],
     ),
     (
         "compose-reverse-then-vindex",
-        lambda a: a.lazy[::-1].lazy.vindex[..., np.array([1, 3, 0])],
+        lambda a: a[::-1].vindex[..., np.array([1, 3, 0])],
         lambda r: r[::-1][..., np.array([1, 3, 0])],
     ),
     (
         "compose-vindex-trailing-then-scalar-and-slice",
-        lambda a: a.lazy.vindex[..., np.array([3, 0, 1])].lazy[-1, 1:4],
+        lambda a: a.vindex[..., np.array([3, 0, 1])][-1, 1:4],
         lambda r: r[..., np.array([3, 0, 1])][-1, 1:4],
     ),
     # A downward walk that begins off the front of the axis selects nothing.
@@ -555,17 +549,17 @@ def source(request: pytest.FixtureRequest) -> LazyArray:
     # carried by an index array rather than by the domain.
     (
         "compose-oindex-then-empty-downward-walk",
-        lambda a: a.lazy.oindex[np.array([3, 1, 4]), :, :].lazy[-8::-1],
+        lambda a: a.oindex[np.array([3, 1, 4]), :, :][-8::-1],
         lambda r: r[np.array([3, 1, 4])][-8::-1],
     ),
     (
         "compose-vindex-then-empty-downward-walk",
-        lambda a: a.lazy.vindex[np.array([3, 1]), np.array([2, 0])].lazy[-9::-2],
+        lambda a: a.vindex[np.array([3, 1]), np.array([2, 0])][-9::-2],
         lambda r: r[np.array([3, 1]), np.array([2, 0])][-9::-2],
     ),
     (
         "empty-downward-walk-on-a-plain-axis",
-        lambda a: a.lazy[-11::-1],
+        lambda a: a[-11::-1],
         lambda r: r[-11::-1],
     ),
     # A fancy *spelling* whose entries are all slices is not a fancy selection:
@@ -574,22 +568,22 @@ def source(request: pytest.FixtureRequest) -> LazyArray:
     # broadcast (singleton) axes of the existing index array would truncate it.
     (
         "compose-oindex-then-oindex-slices-only",
-        lambda a: a.lazy.oindex[[4, 0, 0], :, :].lazy.oindex[:, 2:5, 1:],
+        lambda a: a.oindex[[4, 0, 0], :, :].oindex[:, 2:5, 1:],
         lambda r: outer(r, ([4, 0, 0], slice(None), slice(None)))[:, 2:5, 1:],
     ),
     (
         "compose-oindex-then-oindex-slices-only-strided",
-        lambda a: a.lazy.oindex[:, [3, 1, 1], :].lazy.oindex[1::2, :, ::-1],
+        lambda a: a.oindex[:, [3, 1, 1], :].oindex[1::2, :, ::-1],
         lambda r: outer(r, (slice(None), [3, 1, 1], slice(None)))[1::2, :, ::-1],
     ),
     (
         "compose-vindex-then-oindex-slices-only",
-        lambda a: a.lazy.vindex[np.array([4, 0, 2]), np.array([1, 3, 0])].lazy.oindex[1:, 2:],
+        lambda a: a.vindex[np.array([4, 0, 2]), np.array([1, 3, 0])].oindex[1:, 2:],
         lambda r: r[np.array([4, 0, 2]), np.array([1, 3, 0])][1:, 2:],
     ),
     (
         "compose-oindex-then-oindex-array-on-its-own-axis",
-        lambda a: a.lazy.oindex[[4, 0, 0], :, :].lazy.oindex[[2, 0], 3:, :],
+        lambda a: a.oindex[[4, 0, 0], :, :].oindex[[2, 0], 3:, :],
         lambda r: outer(
             outer(r, ([4, 0, 0], slice(None), slice(None))),
             ([2, 0], slice(3, None), slice(None)),
@@ -611,7 +605,7 @@ def test_selection_matches_numpy(
     assert view.shape == expected.shape
     assert view.ndim == expected.ndim
     np.testing.assert_array_equal(np.asarray(view.result()), expected)
-    # `__getitem__` is eager, and `__array__` routes through `result()`.
+    # NumPy conversion routes through `result()`.
     np.testing.assert_array_equal(np.asarray(view), expected)
 
 
@@ -724,10 +718,10 @@ def _apply_oracle(
 
 def _apply_view(view: LazyArray, mode: str, selection: tuple[Any, ...]) -> LazyArray:
     if mode == "basic":
-        return view.lazy[selection]
+        return view[selection]
     if mode == "orthogonal":
-        return view.lazy.oindex[selection]
-    return view.lazy.vindex[selection]
+        return view.oindex[selection]
+    return view.vindex[selection]
 
 
 def _random_slices_only(rng: np.random.Generator, shape: tuple[int, ...]) -> tuple[Any, ...]:
@@ -851,9 +845,7 @@ def test_a_slice_only_fancy_step_after_a_fancy_step_reads_real_data() -> None:
     expected = base[np.ix_([0, 2], range(8))][:, 2:8]
 
     for parts in (None, (2, 4), (1, 8), (3, 3)):
-        view = (
-            repartition(LazyArray(base), parts).lazy.oindex[np.array([0, 2]), :].lazy.oindex[:, 2:8]
-        )
+        view = repartition(LazyArray(base), parts).oindex[np.array([0, 2]), :].oindex[:, 2:8]
         assert view.shape == expected.shape, f"parts={parts}"
         np.testing.assert_array_equal(np.asarray(view.result()), expected, err_msg=f"{parts}")
 
@@ -869,28 +861,28 @@ def test_a_fancy_step_composes_onto_any_axis_of_a_fancy_view() -> None:
     rows, cols = np.array([0, 2]), np.array([1, 3, 3])
 
     for parts in (None, (2, 4), (1, 8), (3, 3)):
-        view = repartition(LazyArray(base), parts).lazy.oindex[rows, :]
+        view = repartition(LazyArray(base), parts).oindex[rows, :]
 
-        composed = view.lazy.oindex[:, cols]
+        composed = view.oindex[:, cols]
         expected = base[np.ix_(rows, cols)]
         assert composed.shape == expected.shape, f"parts={parts}"
         np.testing.assert_array_equal(np.asarray(composed.result()), expected, err_msg=f"{parts}")
 
-        gathered = view.lazy.vindex[np.array([0, 1]), np.array([7, 0])]
+        gathered = view.vindex[np.array([0, 1]), np.array([7, 0])]
         np.testing.assert_array_equal(
             np.asarray(gathered.result()),
             base[np.ix_(rows, range(8))][[0, 1], [7, 0]],
             err_msg=f"{parts}",
         )
 
-        pointwise = repartition(LazyArray(base), parts).lazy.vindex[[0, 1, 2], [0, 2, 3]]
+        pointwise = repartition(LazyArray(base), parts).vindex[[0, 1, 2], [0, 2, 3]]
         np.testing.assert_array_equal(
-            np.asarray(pointwise.lazy.oindex[[2, 0]].result()),
+            np.asarray(pointwise.oindex[[2, 0]].result()),
             base[[0, 1, 2], [0, 2, 3]][[2, 0]],
             err_msg=f"{parts}",
         )
         np.testing.assert_array_equal(
-            np.asarray(pointwise.lazy.vindex[[1, 1, 0]].result()),
+            np.asarray(pointwise.vindex[[1, 1, 0]].result()),
             base[[0, 1, 2], [0, 2, 3]][[1, 1, 0]],
             err_msg=f"{parts}",
         )
@@ -907,8 +899,8 @@ def test_a_partial_vindex_after_an_oindex_resolves_the_mixed_transform() -> None
     expected = base[:, :, [4, 0]][[0, 2], [1, 3]]
 
     for parts in (None, (2, 2, 2), (3, 4, 5), (1, 1, 1)):
-        view = repartition(LazyArray(base), parts).lazy.oindex[:, :, [4, 0]]
-        composed = view.lazy.vindex[np.array([0, 2]), np.array([1, 3])]
+        view = repartition(LazyArray(base), parts).oindex[:, :, [4, 0]]
+        composed = view.vindex[np.array([0, 2]), np.array([1, 3])]
         assert composed.shape == expected.shape, f"parts={parts}"
         np.testing.assert_array_equal(np.asarray(composed.result()), expected, err_msg=f"{parts}")
 
@@ -919,35 +911,32 @@ def test_a_boolean_mask_composes_onto_a_fancy_view() -> None:
     expected = base[[0, 1, 2]][mask]
 
     for parts in (None, (2, 2, 2), (1, 4, 5)):
-        view = repartition(LazyArray(base), parts).lazy.oindex[[0, 1, 2], :, :]
+        view = repartition(LazyArray(base), parts).oindex[[0, 1, 2], :, :]
         np.testing.assert_array_equal(
-            np.asarray(view.lazy.oindex[mask].result()), expected, err_msg=f"{parts}"
+            np.asarray(view.oindex[mask].result()), expected, err_msg=f"{parts}"
         )
 
 
 def test_an_ellipsis_only_vindex_step_preserves_a_correlated_gather() -> None:
-    """Regression: a slice-only vindex step misread correlated maps as orthogonal.
+    """Ellipsis-only vectorized selection preserves correlated coordinates.
 
-    `vindex[...]` (and `vindex[..., scalar]`, whose remainder after the scalar
-    is split off is ellipsis-only) used to stamp each correlated map with its
-    block axis as an orthogonal binding. Two "orthogonal" maps then shared one
-    input axis, and the partition walk rejected its own transform mid-read.
-    """
+    This also applies after scalar indices have been split off. The selected
+    values must agree across partitionings."""
     base = np.arange(16).reshape(4, 4)
 
     for parts in (None, (2, 2), (4, 4), (1, 3)):
-        pointwise = repartition(LazyArray(base), parts).lazy.vindex[[0, 1, 2], [0, 2, 3]]
+        pointwise = repartition(LazyArray(base), parts).vindex[[0, 1, 2], [0, 2, 3]]
         np.testing.assert_array_equal(
-            np.asarray(pointwise.lazy.vindex[...].result()),
+            np.asarray(pointwise.vindex[...].result()),
             base[[0, 1, 2], [0, 2, 3]],
             err_msg=f"{parts}",
         )
 
-        planar = repartition(LazyArray(base), parts).lazy.vindex[
+        planar = repartition(LazyArray(base), parts).vindex[
             np.array([[0], [1]]), np.array([[1], [3]])
         ]
         np.testing.assert_array_equal(
-            np.asarray(planar.lazy.vindex[..., np.array(0)].result()),
+            np.asarray(planar.vindex[..., np.array(0)].result()),
             base[[0, 1], [1, 3]],
             err_msg=f"{parts}",
         )
@@ -972,27 +961,27 @@ def test_an_ellipsis_only_vindex_step_preserves_a_correlated_gather() -> None:
 ] = [
     (
         "leading-singleton-row",
-        lambda a: a.lazy.vindex[np.array([[2, 0]])].lazy[:, 0],
+        lambda a: a.vindex[np.array([[2, 0]])][:, 0],
         lambda r: r[np.array([[2, 0]])][:, 0],
     ),
     (
         "trailing-singleton-column",
-        lambda a: a.lazy.vindex[np.array([[2], [0]])].lazy[0],
+        lambda a: a.vindex[np.array([[2], [0]])][0],
         lambda r: r[np.array([[2], [0]])][0],
     ),
     (
         "repeated-coordinates-over-a-singleton",
-        lambda a: a.lazy.vindex[np.array([[1, 1]]), np.array([[3, 3]])].lazy[:, 0],
+        lambda a: a.vindex[np.array([[1, 1]]), np.array([[3, 3]])][:, 0],
         lambda r: r[np.array([[1, 1]]), np.array([[3, 3]])][:, 0],
     ),
     (
         "unreferenced-axis-emptied",
-        lambda a: a.lazy.vindex[np.array([[2, 0]])].lazy[0:0, 0],
+        lambda a: a.vindex[np.array([[2, 0]])][0:0, 0],
         lambda r: r[np.array([[2, 0]])][0:0, 0],
     ),
     (
         "partial-vindex-with-a-residual-slice",
-        lambda a: a.lazy.vindex[np.array([[2, 0]]), np.array([[1, 3]])].lazy[:, 0, 1:4],
+        lambda a: a.vindex[np.array([[2, 0]]), np.array([[1, 3]])][:, 0, 1:4],
         lambda r: r[np.array([[2, 0]]), np.array([[1, 3]])][:, 0, 1:4],
     ),
 ]
@@ -1040,7 +1029,7 @@ def test_an_unreferenced_domain_axis_of_extent_zero_stays_empty() -> None:
     data = np.arange(140, dtype=np.int64).reshape(7, 5, 4)
     coords = np.array([[6], [3], [0]])
     for parts in (None, (1, 1, 1), (3, 2, 3), (7, 5, 4)):
-        view = repartition(LazyArray(data), parts).lazy.vindex[coords, -4].lazy[0, 0:0]
+        view = repartition(LazyArray(data), parts).vindex[coords, -4][0, 0:0]
         expected = data[coords, -4][0, 0:0]
         assert view.shape == expected.shape == (0, 4), f"parts={parts}"
         np.testing.assert_array_equal(np.asarray(view.result()), expected, err_msg=f"{parts}")
@@ -1053,11 +1042,7 @@ def test_a_zero_length_axis_resolves_the_same_way_under_every_partitioning() ->
     expected = base[np.ix_([1, 0, 0], np.arange(0, dtype=int))]
 
     for parts in (None, ((1, 1, 1), ()), ((3,), ())):
-        view = (
-            repartition(LazyArray(base), parts)
-            .lazy.oindex[np.array([1, -3, -3]), :]
-            .lazy.oindex[:, :]
-        )
+        view = repartition(LazyArray(base), parts).oindex[np.array([1, -3, -3]), :].oindex[:, :]
         assert view.shape == expected.shape, f"parts={parts}"
         np.testing.assert_array_equal(np.asarray(view.result()), expected, err_msg=f"{parts}")
         assert list(view.parts()) == []
@@ -1074,7 +1059,7 @@ def test_an_empty_slice_of_a_length_one_correlated_axis_has_no_parts() -> None:
     mask = np.array([False, True, False, False, False])
 
     for parts in PARTITIONINGS_1D:
-        view = repartition(LazyArray(base), parts).lazy.vindex[mask].lazy[1:-2]
+        view = repartition(LazyArray(base), parts).vindex[mask][1:-2]
         assert view.shape == (0,), f"parts={parts}"
         assert list(view.parts()) == [], f"parts={parts}"
         np.testing.assert_array_equal(np.asarray(view.result()), base[mask][1:-2])
@@ -1085,9 +1070,7 @@ def test_an_empty_slice_of_a_length_one_vindex_pair_has_no_parts() -> None:
     base = np.arange(35).reshape(7, 5)
 
     for parts in (None, (2, 2), (7, 5)):
-        view = (
-            repartition(LazyArray(base), parts).lazy.vindex[np.array([6]), np.array([0])].lazy[0:0]
-        )
+        view = repartition(LazyArray(base), parts).vindex[np.array([6]), np.array([0])][0:0]
         assert view.shape == (0,), f"parts={parts}"
         assert list(view.parts()) == [], f"parts={parts}"
         np.testing.assert_array_equal(
@@ -1113,7 +1096,7 @@ def test_a_correlated_view_narrowed_to_one_point_has_parts_of_the_views_rank() -
     for parts in (None, (2, 2, 2), (3, 3, 3), (7, 5, 4)):
         for selection, tail in cases:
             expected = base[selection][tail]
-            view = repartition(LazyArray(base), parts).lazy.vindex[selection].lazy[tail]
+            view = repartition(LazyArray(base), parts).vindex[selection][tail]
             assert view.shape == expected.shape, f"parts={parts}, {selection}"
 
             assembled = np.zeros(view.shape, dtype=view.dtype)
@@ -1128,8 +1111,9 @@ def test_a_correlated_view_narrowed_to_one_point_has_parts_of_the_views_rank() -
             np.testing.assert_array_equal(np.asarray(view.result()), expected, err_msg=err)
 
 
-def test_eager_getitem_returns_data(source: LazyArray) -> None:
-    """`arr[...]` reads immediately, like `numpy.ndarray.__getitem__`."""
+def test_getitem_returns_a_view(source: LazyArray) -> None:
+    """`arr[...]` returns a view that materializes to the selected values."""
+    assert isinstance(source[1:3, ::2, -1], LazyArray)
     np.testing.assert_array_equal(np.asarray(source[1:3, ::2, -1]), reference()[1:3, ::2, -1])
 
 
@@ -1149,7 +1133,7 @@ def test_forwards_array_attributes(source: LazyArray) -> None:
 
 def test_view_shape_comes_from_the_transform(source: LazyArray) -> None:
     """A view reports its own shape, not the wrapped array's."""
-    view = source.lazy[1:6:2, :, -1]
+    view = source[1:6:2, :, -1]
     assert view.shape == (3, 5)
     assert view.ndim == 2
     assert view.size == 15
@@ -1176,7 +1160,7 @@ def test_scalar_is_basic_even_when_a_slice_separates_it_from_the_arrays() -> Non
     selection reads as `x[0][:, i]`.
     """
     data = reference()
-    view = make_source("numpy-uniform-parts").lazy.vindex[0, ..., np.array([3, 0])]
+    view = make_source("numpy-uniform-parts").vindex[0, ..., np.array([3, 0])]
     np.testing.assert_array_equal(np.asarray(view.result()), data[0][..., np.array([3, 0])])
     assert view.shape == data[0][..., np.array([3, 0])].shape
     assert view.shape != data[0, ..., np.array([3, 0])].shape
@@ -1184,7 +1168,7 @@ def test_scalar_is_basic_even_when_a_slice_separates_it_from_the_arrays() -> Non
 
 def test_zero_dimensional_result_is_an_array(source: LazyArray) -> None:
     """Both resolvers agree on the kind of a zero-rank result."""
-    result = source.lazy[0, 1, 2].result()
+    result = source[0, 1, 2].result()
     assert isinstance(result, np.ndarray)
     assert result.ndim == 0
     assert result[()] == reference()[0, 1, 2]
@@ -1211,7 +1195,7 @@ def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
     data = reference()
     inner = RecordingDelegatingReader("inner", numpy_reader)
     outer = RecordingDelegatingReader("outer", inner)
-    view = LazyArray(data).with_reader(outer).lazy[1:6:2, ::-1, 1].unpartitioned()
+    view = LazyArray(data).with_reader(outer)[1:6:2, ::-1, 1].unpartitioned()
 
     result = view.result()
 
@@ -1219,7 +1203,8 @@ def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
     outer_call, inner_call = events
     assert outer_call[1] is inner_call[1] is data
     assert outer_call[2] is inner_call[2]
-    assert outer_call[3] is inner_call[3] is result
+    assert outer_call[3] is inner_call[3]
+    assert np.shares_memory(outer_call[3], result)
     np.testing.assert_array_equal(result, data[1:6:2, ::-1, 1])
 
 
@@ -1245,7 +1230,7 @@ def test_view_operations_preserve_the_reader_without_reading() -> None:
     reader = RecordingReader()
     base = LazyArray(data).with_reader(reader)
     views = (
-        base.lazy[1:5],
+        base[1:5],
         base.with_parts((2, 2, 2)),
         base.with_parts_per_axis(((3, 3, 1), (2, 3), (1, 3))),
         base.unpartitioned(),
@@ -1266,10 +1251,12 @@ def read_into(self, source: Any, context: ReadContext, out: Any, /) -> Any:
         return np.empty(context.transform.domain.shape, dtype=source.dtype)
 
 
-def test_result_rejects_a_reader_that_returns_a_value() -> None:
+@pytest.mark.parametrize("independent", [False, True])
+def test_result_rejects_a_reader_that_returns_a_value(independent: bool) -> None:
     view = LazyArray(reference()).with_reader(ReturningReader())
+    target = next(view.parts()).view if independent else view
     with pytest.raises(TypeError, match="must return None"):
-        view.result()
+        target.result()
 
 
 class BufferRecordingReader(RecordingReader):
@@ -1285,7 +1272,7 @@ def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
 def test_reader_is_called_once_per_touched_part() -> None:
     data = np.arange(48).reshape(6, 8)
     reader = RecordingReader()
-    view = LazyArray(data).with_reader(reader).with_parts((3, 4)).lazy[1:5, 2]
+    view = LazyArray(data).with_reader(reader).with_parts((3, 4))[1:5, 2]
     np.testing.assert_array_equal(view.result(), data[1:5, 2])
     assert len(reader.calls) == len(tuple(view.parts())) == 2
     assert all(
@@ -1307,14 +1294,14 @@ def test_partition_reader_receives_global_transform_and_existing_projection() ->
 
 def test_an_empty_result_does_not_call_the_reader() -> None:
     reader = RecordingReader()
-    result = LazyArray(reference()).with_reader(reader).lazy[:, 0:0, :].result()
+    result = LazyArray(reference()).with_reader(reader)[:, 0:0, :].result()
     assert result.shape == (7, 0, 4)
     assert reader.calls == []
 
 
 def test_rectangular_parts_write_into_result_views() -> None:
     reader = BufferRecordingReader()
-    view = LazyArray(reference()).with_reader(reader).with_parts((2, 2, 2)).lazy[1:6, 1:4]
+    view = LazyArray(reference()).with_reader(reader).with_parts((2, 2, 2))[1:6, 1:4]
     view.result()
     assert reader.owns_data
     assert not any(reader.owns_data)
@@ -1322,25 +1309,23 @@ def test_rectangular_parts_write_into_result_views() -> None:
 
 def test_fancy_part_placement_uses_owned_dense_temporaries() -> None:
     reader = BufferRecordingReader()
-    view = (
-        LazyArray(reference())
-        .with_reader(reader)
-        .with_parts((2, 2, 2))
-        .lazy.oindex[[6, 1, 1], :, :]
-    )
+    view = LazyArray(reference()).with_reader(reader).with_parts((2, 2, 2)).oindex[[6, 1, 1], :, :]
     np.testing.assert_array_equal(view.result(), reference()[np.ix_([6, 1, 1], range(5), range(4))])
     assert any(reader.owns_data)
 
 
-def test_reader_exception_propagates_unchanged() -> None:
+@pytest.mark.parametrize("independent", [False, True])
+def test_reader_exception_propagates_unchanged(independent: bool) -> None:
     error = RuntimeError("backend failed")
 
     class FailingReader:
         def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
             raise error
 
+    view = LazyArray(reference()).with_reader(FailingReader())
+    target = next(view.parts()).view if independent else view
     with pytest.raises(RuntimeError) as caught:
-        LazyArray(reference()).with_reader(FailingReader()).result()
+        target.result()
     assert caught.value is error
 
 
@@ -1373,7 +1358,7 @@ def test_malformed_discovered_parts_are_ignored() -> None:
     for bogus in (((3, 3), (5,), (4,)), (3, 2), "nope", (3.5, 2, 2)):
         wrapped = LazyArray(ForeignArray(data, bogus))
         assert len(list(wrapped.parts())) == 1
-        np.testing.assert_array_equal(np.asarray(wrapped.lazy[1:3].result()), data[1:3])
+        np.testing.assert_array_equal(np.asarray(wrapped[1:3].result()), data[1:3])
 
 
 def test_discovered_parts_come_from_the_source_vocabulary() -> None:
@@ -1392,37 +1377,37 @@ def test_discovered_parts_come_from_the_source_vocabulary() -> None:
 # intervals of the wrapped (7, 5, 4) array, computed by hand.
 BOX_CASES: list[tuple[str, Callable[[LazyArray], LazyArray], bool, Any]] = [
     ("identity", lambda a: a, True, ((0, 7), (0, 5), (0, 4))),
-    ("basic-slice", lambda a: a.lazy[1:6, :, 1:3], True, ((1, 6), (0, 5), (1, 3))),
+    ("basic-slice", lambda a: a[1:6, :, 1:3], True, ((1, 6), (0, 5), (1, 3))),
     # Stride 2 over axis 1 touches 0, 2, 4; the hull is the closed span.
-    ("strided", lambda a: a.lazy[::3, ::2, :], True, ((0, 7), (0, 5), (0, 4))),
-    ("int-drop", lambda a: a.lazy[2, :, -1], True, ((2, 3), (0, 5), (3, 4))),
-    ("all-scalars", lambda a: a.lazy[0, 1, 2], True, ((0, 1), (1, 2), (2, 3))),
-    ("negative-and-open", lambda a: a.lazy[-2:], True, ((5, 7), (0, 5), (0, 4))),
+    ("strided", lambda a: a[::3, ::2, :], True, ((0, 7), (0, 5), (0, 4))),
+    ("int-drop", lambda a: a[2, :, -1], True, ((2, 3), (0, 5), (3, 4))),
+    ("all-scalars", lambda a: a[0, 1, 2], True, ((0, 1), (1, 2), (2, 3))),
+    ("negative-and-open", lambda a: a[-2:], True, ((5, 7), (0, 5), (0, 4))),
     (
         "oindex",
-        lambda a: a.lazy.oindex[[4, 0, 0], :, [3, 1]],
+        lambda a: a.oindex[[4, 0, 0], :, [3, 1]],
         False,
         ((0, 5), (0, 5), (1, 4)),
     ),
     (
         "vindex",
-        lambda a: a.lazy.vindex[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])],
+        lambda a: a.vindex[np.array([0, 6, 3]), np.array([1, 4, 0]), np.array([2, 0, 1])],
         False,
         ((0, 7), (0, 5), (0, 3)),
     ),
-    ("mask", lambda a: a.lazy.vindex[MASK], False, ((0, 7), (0, 5), (0, 4))),
+    ("mask", lambda a: a.vindex[MASK], False, ((0, 7), (0, 5), (0, 4))),
     # Composition preserves the category in both directions.
-    ("box-of-box", lambda a: a.lazy[1:6].lazy[:, 1:3], True, ((1, 6), (1, 3), (0, 4))),
+    ("box-of-box", lambda a: a[1:6][:, 1:3], True, ((1, 6), (1, 3), (0, 4))),
     (
         "box-after-fancy",
-        lambda a: a.lazy.oindex[[4, 0, 2], :, :].lazy[0:2],
+        lambda a: a.oindex[[4, 0, 2], :, :][0:2],
         False,
         ((0, 5), (0, 5), (0, 4)),
     ),
-    ("empty", lambda a: a.lazy[2:2], True, None),
+    ("empty", lambda a: a[2:2], True, None),
     (
         "empty-fancy",
-        lambda a: a.lazy.oindex[np.array([], dtype=np.intp), :, :],
+        lambda a: a.oindex[np.array([], dtype=np.intp), :, :],
         False,
         None,
     ),
@@ -1449,7 +1434,7 @@ def test_is_box_and_bounding_box(
 def test_a_unit_stride_box_is_dense_in_its_bounding_box() -> None:
     """Stride 1 everywhere: the hull is exactly what the view selects."""
     data = reference()
-    view = make_source("numpy-uniform-parts").lazy[1:6, :, 1:3]
+    view = make_source("numpy-uniform-parts")[1:6, :, 1:3]
     assert view.is_box
     assert view.strides() == (1, 1, 1)
     bounds = view.bounding_box()
@@ -1463,7 +1448,7 @@ def test_a_unit_stride_box_is_dense_in_its_bounding_box() -> None:
 def test_a_strided_box_is_sparse_in_its_bounding_box() -> None:
     """Stride > 1: the hull is a superset, and `strides()` is what says by how much."""
     data = reference()
-    view = make_source("numpy-uniform-parts").lazy[1:6, ::2, :]
+    view = make_source("numpy-uniform-parts")[1:6, ::2, :]
     assert view.is_box
     assert view.strides() == (1, 2, 1)
     bounds = view.bounding_box()
@@ -1483,20 +1468,20 @@ def test_a_strided_box_is_sparse_in_its_bounding_box() -> None:
 
 
 def test_strides_are_none_for_a_query() -> None:
-    view = make_source("numpy-uniform-parts").lazy.oindex[[5, 1], :, :]
+    view = make_source("numpy-uniform-parts").oindex[[5, 1], :, :]
     assert not view.is_box
     assert view.strides() is None
 
 
 def test_an_integer_indexed_dimension_has_stride_one() -> None:
-    view = make_source("numpy-uniform-parts").lazy[2, ::3, :]
+    view = make_source("numpy-uniform-parts")[2, ::3, :]
     assert view.strides() == (1, 3, 1)
     assert view.bounding_box() == ((2, 3), (0, 4), (0, 4))
 
 
 def test_a_query_bounding_box_is_only_a_hull() -> None:
     """For a fancy selection the box is a superset, and `is_box` says so."""
-    view = make_source("numpy-uniform-parts").lazy.oindex[[5, 1], :, :]
+    view = make_source("numpy-uniform-parts").oindex[[5, 1], :, :]
     assert not view.is_box
     assert view.bounding_box() == ((1, 6), (0, 5), (0, 4))
     # The hull spans 5 rows; the selection touches 2 of them.
@@ -1516,7 +1501,7 @@ def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
 def test_prepared_part_validation_allocates_boolean_coverage_bitmap(
     monkeypatch: pytest.MonkeyPatch,
 ) -> None:
-    view = LazyArray.from_numpy(reference()).with_parts(PART_SHAPE).lazy[1:6, ::2, 1:]
+    view = LazyArray.from_numpy(reference()).with_parts(PART_SHAPE)[1:6, ::2, 1:]
     parts = tuple(view.parts())
     allocations: list[tuple[tuple[int, ...], np.dtype[Any]]] = []
     real_zeros = np.zeros
@@ -1539,35 +1524,35 @@ def recording_zeros(shape: Any, *args: Any, **kwargs: Any) -> np.ndarray[Any, An
         pytest.param(
             np.arange(8),
             (3,),
-            lambda array: array.lazy[1:7:2],
+            lambda array: array[1:7:2],
             np.array([1, 3, 5]),
             id="basic-reordered-parts",
         ),
         pytest.param(
             np.arange(8),
             (3,),
-            lambda array: array.lazy[3],
+            lambda array: array[3],
             np.array(3),
             id="scalar",
         ),
         pytest.param(
             np.arange(20).reshape(4, 5),
             (2, 3),
-            lambda array: array.lazy.oindex[[3, 1, 1], [4, 0]],
+            lambda array: array.oindex[[3, 1, 1], [4, 0]],
             np.array([[19, 15], [9, 5], [9, 5]]),
             id="orthogonal-fancy",
         ),
         pytest.param(
             np.arange(20).reshape(4, 5),
             (2, 3),
-            lambda array: array.lazy.vindex[[3, 1, 1], [4, 0, 4]],
+            lambda array: array.vindex[[3, 1, 1], [4, 0, 4]],
             np.array([19, 5, 9]),
             id="correlated-fancy",
         ),
         pytest.param(
             np.arange(8),
             (3,),
-            lambda array: array.lazy[2:2],
+            lambda array: array[2:2],
             np.array([], dtype=np.int64),
             id="empty",
         ),
@@ -1594,9 +1579,9 @@ def unexpected_replan(self: LazyArray) -> Any:
 def test_result_rejects_prepared_parts_owned_by_another_view() -> None:
     data = reference()
     base = LazyArray.from_numpy(data).with_reader(_ReadMustNotRun()).with_parts(PART_SHAPE)
-    view = base.lazy[1:6, ::2, 1:]
+    view = base[1:6, ::2, 1:]
     owned_parts = tuple(view.parts())
-    foreign_parts = tuple(base.lazy[1:6, ::2, 1:].parts())
+    foreign_parts = tuple(base[1:6, ::2, 1:].parts())
     mixed_parts = (owned_parts[0], *foreign_parts[1:])
 
     with pytest.raises(ValueError, match="prepared parts do not belong to this view"):
@@ -1608,8 +1593,7 @@ def test_result_rejects_prepared_parts_that_do_not_tile_the_view() -> None:
     view = (
         LazyArray.from_numpy(data)
         .with_reader(_ReadMustNotRun())
-        .with_parts(PART_SHAPE)
-        .lazy[1:6, ::2, 1:]
+        .with_parts(PART_SHAPE)[1:6, ::2, 1:]
     )
     parts = tuple(view.parts())
 
@@ -1659,9 +1643,7 @@ def test_result_rejects_empty_prepared_parts_for_a_nonempty_view() -> None:
 
 
 def test_result_accepts_empty_prepared_parts_for_an_empty_view() -> None:
-    view = (
-        LazyArray.from_numpy(np.arange(8)).with_reader(_ReadMustNotRun()).with_parts((4,)).lazy[0:0]
-    )
+    view = LazyArray.from_numpy(np.arange(8)).with_reader(_ReadMustNotRun()).with_parts((4,))[0:0]
 
     np.testing.assert_array_equal(view.result(parts=()), np.array([], dtype=np.int64))
 
@@ -1671,14 +1653,14 @@ def test_result_accepts_empty_prepared_parts_for_an_empty_view() -> None:
     "build",
     [
         lambda a: a,
-        lambda a: a.lazy[1:6, :, 1:],
-        lambda a: a.lazy.oindex[[4, 0, 0], :, [3, 1]],
-        lambda a: a.lazy.vindex[..., np.array([1, 4, 0]), np.array([2, 0, 1])],
+        lambda a: a[1:6, :, 1:],
+        lambda a: a.oindex[[4, 0, 0], :, [3, 1]],
+        lambda a: a.vindex[..., np.array([1, 4, 0]), np.array([2, 0, 1])],
         # A reversing view drives the negative-stride branches of
         # `_intersect_dimension_map` and chunk projection, which were
         # written defensively long before anything could reach them.
-        lambda a: a.lazy[::-1, ::-2, :],
-        lambda a: a.lazy[5:1:-1, :, ::-1],
+        lambda a: a[::-1, ::-2, :],
+        lambda a: a[5:1:-1, :, ::-1],
     ],
     ids=["identity", "basic", "oindex", "vindex", "reversed", "reversed-bounded"],
 )
@@ -1725,8 +1707,8 @@ def _transform_point(transform: IndexTransform, point: tuple[int, ...]) -> tuple
 @pytest.mark.parametrize(
     "build",
     [
-        lambda array: array.lazy.oindex[[6, 0, 2], :, [3, 1]],
-        lambda array: array.lazy.vindex[..., np.array([4, 0, 4]), np.array([3, 1, 1])],
+        lambda array: array.oindex[[6, 0, 2], :, [3, 1]],
+        lambda array: array.vindex[..., np.array([4, 0, 4]), np.array([3, 1, 1])],
     ],
     ids=["orthogonal", "vectorized"],
 )
@@ -1776,24 +1758,29 @@ def test_nonfirst_partition_transform_directly_addresses_its_array() -> None:
     part = list(LazyArray.from_numpy(source).with_parts((4,)).parts())[1]
 
     assert part.box == ((4, 8),)
-    assert part.view.transform.apply((0,)) == (4,)
-    assert part.view.array[part.view.transform.apply((0,))] == 4
+    # A box part keeps the request's literal coordinates, so its domain says
+    # where it sits; the transform addresses the raw source from there.
+    assert part.view.transform.domain == IndexDomain((4,), (8,))
+    assert part.view.transform.apply((4,)) == (4,)
+    assert part.view.array[part.view.transform.apply((4,))] == 4
     assert part.view.result()[0] == 4
+    assert part.view[0].result() == 4
     assert part.projection.chunk_transform.apply((0,)) == (0,)
 
 
 def test_partition_token_encodes_its_public_global_transform() -> None:
+    pytest.importorskip("dask.base")
     source = np.arange(8)
     base = LazyArray.from_numpy(source)
     partition_view = list(base.with_parts((4,)).parts())[1].view
-    direct_view = base.lazy[4:8]
+    direct_view = base[4:8]
 
     assert partition_view.__dask_tokenize__() == direct_view.__dask_tokenize__()
 
 
 def test_parts_resolve_independently_and_concurrently() -> None:
     """Each part's `array` is a standalone `LazyArray` with no shared mutable state."""
-    view = make_source("zarr").lazy[1:7, :, 1:].with_parts((2, 2, 2))
+    view = make_source("zarr")[1:7, :, 1:].with_parts((2, 2, 2))
     parts = list(view.parts())
     assert len(parts) > 1
 
@@ -1812,15 +1799,15 @@ def test_parts_report_completeness() -> None:
     assert all(part.is_complete for part in array.parts())
     # Boxes along axis 2 are [0, 3) and [3, 4); dropping column 0 leaves the
     # first partially covered and the second whole.
-    trimmed = {part.base_coords[2]: part.is_complete for part in array.lazy[:, :, 1:].parts()}
+    trimmed = {part.base_coords[2]: part.is_complete for part in array[:, :, 1:].parts()}
     assert trimmed == {0: False, 1: True}
     # A fancy axis is always reported incomplete.
-    assert not any(part.is_complete for part in array.lazy.oindex[[4, 0, 0], :, :].parts())
+    assert not any(part.is_complete for part in array.oindex[[4, 0, 0], :, :].parts())
 
 
 def test_partition_boxes_are_global_and_tile_the_base() -> None:
     """Both the selected hull and the whole partition box use global coordinates."""
-    view = make_source("numpy-uniform-parts").lazy[1:6, :, 1:]
+    view = make_source("numpy-uniform-parts")[1:6, :, 1:]
     parts = {part.base_coords: part for part in view.parts()}
 
     # The reviewer's repro: two parts of the same view now expose distinct
@@ -1867,7 +1854,7 @@ def test_an_unpartitioned_wrapper_has_a_single_whole_array_part() -> None:
 
 
 def test_with_parts_keeps_the_view_and_the_base() -> None:
-    view = make_source("zarr").lazy[1:6, ::2]
+    view = make_source("zarr")[1:6, ::2]
     repartitioned = view.with_parts((2, 1, 4))
     assert repartitioned.shape == view.shape
     assert repartitioned.array is view.array
@@ -1880,7 +1867,7 @@ def test_with_parts_keeps_the_view_and_the_base() -> None:
 
 
 def test_with_parts_none_forces_one_shot_resolution() -> None:
-    view = make_source("zarr").lazy.oindex[[4, 0, 0], :, :]
+    view = make_source("zarr").oindex[[4, 0, 0], :, :]
     whole = view.unpartitioned()
     assert len(list(whole.parts())) == 1
     np.testing.assert_array_equal(np.asarray(whole.result()), np.asarray(view.result()))
@@ -1914,22 +1901,24 @@ def test_with_parts_validates_strictly(parts: Any, match: str) -> None:
 
 def test_dask_token_is_deterministic_and_discriminating() -> None:
     """Same data and same view token alike; a different selection differs."""
+    pytest.importorskip("dask.base")
     data = reference()
     base = LazyArray(data)
     assert base.__dask_tokenize__() == LazyArray(reference()).__dask_tokenize__()
 
     tokens = {
         "base": base.__dask_tokenize__(),
-        "view": base.lazy[1:3].__dask_tokenize__(),
-        "other view": base.lazy[2:4].__dask_tokenize__(),
+        "view": base[1:3].__dask_tokenize__(),
+        "other view": base[2:4].__dask_tokenize__(),
         "other data": LazyArray(data + 1).__dask_tokenize__(),
     }
     assert len({repr(token) for token in tokens.values()}) == len(tokens)
     # Equivalent transforms reached different ways still token alike.
-    assert base.lazy[1:5].lazy[0:2].__dask_tokenize__() == base.lazy[1:3].__dask_tokenize__()
+    assert base[1:5][0:2].__dask_tokenize__() == base[1:3].__dask_tokenize__()
 
 
 def test_reader_and_partitioning_do_not_change_dask_identity() -> None:
+    pytest.importorskip("dask.base")
     base = LazyArray(reference())
     token = base.__dask_tokenize__()
     assert base.with_reader(numpy_reader).__dask_tokenize__() == token
@@ -1939,27 +1928,28 @@ def test_reader_and_partitioning_do_not_change_dask_identity() -> None:
 
 @pytest.mark.parametrize("reader", [basic_reader, numpy_reader, DelegatingReader(numpy_reader)])
 def test_reader_survives_pickle(reader: Reader) -> None:
-    view = LazyArray(reference()).with_reader(reader).lazy[1:5, ::2]
+    view = LazyArray(reference()).with_reader(reader)[1:5, ::2]
     restored = pickle.loads(pickle.dumps(view))
     assert type(restored.reader) is type(reader)
     np.testing.assert_array_equal(restored.result(), view.result())
 
 
-def test_iteration_yields_eager_slices(source: LazyArray) -> None:
-    rows = list(source.lazy[2:5])
+def test_iteration_yields_lazy_slices(source: LazyArray) -> None:
+    rows = list(source[2:5])
     assert len(rows) == 3
     for row, expected in zip(rows, reference()[2:5], strict=True):
+        assert isinstance(row, LazyArray)
         np.testing.assert_array_equal(np.asarray(row), expected)
 
 
 def test_iteration_over_a_zero_dimensional_view_is_rejected() -> None:
     with pytest.raises(TypeError, match="iteration over a 0-d array"):
-        iter(make_source("numpy-uniform-parts").lazy[0, 0, 0])
+        iter(make_source("numpy-uniform-parts")[0, 0, 0])
 
 
 def test_len_of_a_zero_dimensional_view_is_rejected() -> None:
     with pytest.raises(TypeError, match="len\\(\\) of unsized object"):
-        len(make_source("numpy-uniform-parts").lazy[0, 0, 0])
+        len(make_source("numpy-uniform-parts")[0, 0, 0])
 
 
 @pytest.mark.parametrize(
@@ -1976,7 +1966,7 @@ def test_len_of_a_zero_dimensional_view_is_rejected() -> None:
 def test_scalar_conversions_match_numpy(convert: Any, selection: Any) -> None:
     """Size-1 conversions delegate to NumPy, values and all."""
     data = reference()
-    view = make_source("numpy-uniform-parts").lazy[selection]
+    view = make_source("numpy-uniform-parts")[selection]
     assert convert(view) == convert(data[selection])
 
 
@@ -1995,7 +1985,7 @@ def test_scalar_conversions_raise_what_numpy_raises(
     convert: Any, selection: Any, error: type[Exception]
 ) -> None:
     data = reference()
-    view = make_source("numpy-uniform-parts").lazy[selection]
+    view = make_source("numpy-uniform-parts")[selection]
     with pytest.raises(error):
         convert(view)
     with pytest.raises(error):
@@ -2004,10 +1994,9 @@ def test_scalar_conversions_raise_what_numpy_raises(
 
 def test_pickle_round_trip() -> None:
     """A wrapper over a picklable base survives a round trip, view and parts intact."""
-    view = LazyArray(reference()).with_parts((2, 2, 2)).lazy[1:6, ::2].lazy.oindex[[3, 0, 0], :, :]
+    view = LazyArray(reference()).with_parts((2, 2, 2))[1:6, ::2].oindex[[3, 0, 0], :, :]
     restored = pickle.loads(pickle.dumps(view))
     assert restored.shape == view.shape
-    assert restored.__dask_tokenize__() == view.__dask_tokenize__()
     np.testing.assert_array_equal(np.asarray(restored.result()), np.asarray(view.result()))
 
 
@@ -2017,16 +2006,16 @@ def test_pickle_round_trip() -> None:
 
 
 def test_dask_from_array_roundtrip() -> None:
-    """A `LazyArray` is a drop-in dask source — no translation ceremony."""
+    """Dask can tokenize and read a wrapper over a Zarr source."""
     da = pytest.importorskip("dask.array")
     source = make_source("zarr")
 
-    lazy = da.from_array(source)
+    lazy = da.from_array(EagerArrayAdapter(source))
     np.testing.assert_array_equal(lazy.compute(), reference())
 
     # dask chooses its own blocks; the wrapper reads each of them through its
     # own parts, so the two partitionings need not agree.
-    blocked = da.from_array(source, chunks=(4, 3, 3))
+    blocked = da.from_array(EagerArrayAdapter(source), chunks=(4, 3, 3))
     assert blocked.chunks == ((4, 3), (3, 2), (3, 1))
     np.testing.assert_array_equal(blocked[2:, ::2].compute(), reference()[2:, ::2])
 
@@ -2038,7 +2027,7 @@ def test_dask_from_array_roundtrip() -> None:
 
 def test_boolean_scalar_is_rejected() -> None:
     with pytest.raises(IndexError, match="boolean scalars are not valid indices"):
-        make_source("numpy-uniform-parts").lazy[True]
+        make_source("numpy-uniform-parts")[True]
 
 
 @pytest.mark.parametrize(
@@ -2060,9 +2049,9 @@ def test_positional_selectors_support_the_index_protocol(
 ) -> None:
     source = LazyArray.from_numpy(np.arange(8))
     if mode == "basic":
-        view = source.lazy[selection]
+        view = source[selection]
     else:
-        view = getattr(source.lazy, "oindex" if mode == "orthogonal" else "vindex")[selection]
+        view = getattr(source, "oindex" if mode == "orthogonal" else "vindex")[selection]
 
     result = np.asarray(view.result())
     assert result.shape == expected.shape
@@ -2071,47 +2060,47 @@ def test_positional_selectors_support_the_index_protocol(
 
 def test_positional_selector_rejects_int_only_objects() -> None:
     with pytest.raises(IndexError, match="unsupported selection type"):
-        LazyArray.from_numpy(np.arange(8)).lazy[IntOnly()]
+        LazyArray.from_numpy(np.arange(8))[IntOnly()]
 
 
 def test_positional_selector_propagates_malformed_index_protocol() -> None:
     with pytest.raises(TypeError, match="__index__ returned non-int"):
-        LazyArray.from_numpy(np.arange(8)).lazy[BadIndex()]
+        LazyArray.from_numpy(np.arange(8))[BadIndex()]
 
 
 def test_positional_slice_propagates_malformed_index_protocol() -> None:
     with pytest.raises(TypeError, match="__index__ returned non-int"):
-        LazyArray.from_numpy(np.arange(8)).lazy[:: BadIndex()]
+        LazyArray.from_numpy(np.arange(8))[:: BadIndex()]
 
 
 def test_protocol_objects_inside_an_index_array_remain_invalid() -> None:
     selection = np.array([IndexLike(2)], dtype=object)
     with pytest.raises(IndexError, match="integer or boolean"):
-        LazyArray.from_numpy(np.arange(8)).lazy.oindex[selection]
+        LazyArray.from_numpy(np.arange(8)).oindex[selection]
 
 
 def test_mask_shape_must_match_the_view() -> None:
     array = make_source("numpy-uniform-parts")
     with pytest.raises(IndexError, match="boolean index has shape"):
-        array.lazy.vindex[np.ones((2, 2, 2), dtype=bool)]
+        array.vindex[np.ones((2, 2, 2), dtype=bool)]
 
 
 def test_scalar_index_out_of_bounds() -> None:
     with pytest.raises(IndexError, match="index 7 is out of bounds for axis 0 with size 7"):
-        make_source("numpy-uniform-parts").lazy[7]
+        make_source("numpy-uniform-parts")[7]
 
 
 def test_scalar_index_out_of_bounds_in_a_view() -> None:
     """Bounds are the *view's*, not the wrapped array's."""
-    array = make_source("numpy-uniform-parts").lazy[1:4]
+    array = make_source("numpy-uniform-parts")[1:4]
     with pytest.raises(IndexError, match="index 3 is out of bounds for axis 0 with size 3"):
-        array.lazy[3]
+        array[3]
 
 
 def test_index_array_out_of_bounds() -> None:
     array = make_source("numpy-uniform-parts")
     with pytest.raises(IndexError, match="index 99 is out of bounds for axis 0 with size 7"):
-        array.lazy.oindex[[0, 99], :, :]
+        array.oindex[[0, 99], :, :]
 
 
 @pytest.mark.parametrize("mode", ["oindex", "vindex"])
@@ -2121,12 +2110,12 @@ def test_unsigned_index_array_beyond_intp_is_out_of_bounds(mode: str) -> None:
     index = np.array([2**64 - 1], dtype=np.uint64)
     selection = (index, 0, 0) if mode == "vindex" else (index, slice(None), slice(None))
     with pytest.raises(IndexError, match=f"index {2**64 - 1} is out of bounds for axis 0"):
-        getattr(array.lazy, mode)[selection]
+        getattr(array, mode)[selection]
 
 
 def test_too_many_indices() -> None:
     with pytest.raises(IndexError, match="too many indices"):
-        make_source("numpy-uniform-parts").lazy[0, 0, 0, 0]
+        make_source("numpy-uniform-parts")[0, 0, 0, 0]
 
 
 def test_copy_false_conversion_is_rejected() -> None:
@@ -2142,32 +2131,33 @@ def test_copy_false_conversion_is_rejected() -> None:
 
 def test_reversed_box_reports_a_positive_stride(source: LazyArray) -> None:
     """A reversal is still a box; `strides()` is magnitudes, so it matches the forward twin."""
-    reversed_view = source.lazy[::-2]
-    forward = source.lazy[::2]
+    reversed_view = source[::-2]
+    forward = source[::2]
     assert reversed_view.is_box
     assert reversed_view.strides() == forward.strides() == (2, 1, 1)
     assert reversed_view.bounding_box() == ((0, 7), (0, 5), (0, 4))
 
 
-def test_a_reversed_view_is_re_based_to_origin_zero() -> None:
-    """The literal domain of a reversal is negative; the positional dialect hides it."""
-    view = make_source("numpy-whole").lazy[::-1]
-    # The algebra's own answer keeps the source frame.
+def test_a_reversed_view_keeps_its_negative_literal_domain() -> None:
+    """The literal domain of a reversal is negative; positional keys hide it."""
+    view = make_source("numpy-whole")[::-1]
+    # The algebra's answer keeps the source frame, and so does the wrapper.
     assert IndexTransform.from_shape(SHAPE)[::-1].domain.inclusive_min[0] == -6
-    # The wrapper re-bases, so positions start at 0 as NumPy expects.
-    assert view.transform.domain.inclusive_min == (0, 0, 0)
+    assert view.transform.domain.inclusive_min == (-6, 0, 0)
     assert view.shape == SHAPE
     np.testing.assert_array_equal(np.asarray(view.result()), reference()[::-1])
+    # Position 0 is still the first element, whatever the domain says.
+    np.testing.assert_array_equal(view[0].result(), reference()[-1])
 
 
 def test_zero_step_is_rejected() -> None:
     with pytest.raises(ValueError, match="step cannot be zero"):
-        make_source("numpy-whole").lazy[::0]
+        make_source("numpy-whole")[::0]
 
 
 def test_reversed_positional_interval_is_empty_not_an_error() -> None:
     """NumPy's rule at the boundary; the literal layer keeps TensorStore's."""
-    view = make_source("numpy-uniform-parts").lazy[2:5:-1]
+    view = make_source("numpy-uniform-parts")[2:5:-1]
     assert view.shape == (0, 5, 4)
     np.testing.assert_array_equal(np.asarray(view.result()), reference()[2:5:-1])
     # Literal coordinates, on the other hand, call it a direction error.
@@ -2177,7 +2167,7 @@ def test_reversed_positional_interval_is_empty_not_an_error() -> None:
 
 def test_negative_step_over_a_fancy_axis_reverses_the_coordinates(source: LazyArray) -> None:
     """Reversing a gathered axis materializes, rather than attaching a stride."""
-    view = source.lazy.oindex[[3, 1, 2], :, :].lazy[::-1]
+    view = source.oindex[[3, 1, 2], :, :][::-1]
     expected = outer(reference(), ([3, 1, 2], slice(None), slice(None)))[::-1]
     np.testing.assert_array_equal(np.asarray(view.result()), expected)
     m = view.transform.output[0]
@@ -2223,8 +2213,8 @@ def __getitem__(self, key: Any) -> Any:
 @pytest.mark.parametrize(
     "build",
     [
-        lambda a: a.lazy[:, 2:2, :],
-        lambda a: a.lazy.vindex[np.array([[6], [3], [0]]), -4].lazy[0, 0:0],
+        lambda a: a[:, 2:2, :],
+        lambda a: a.vindex[np.array([[6], [3], [0]]), -4][0, 0:0],
     ],
     ids=["ordinary", "unreferenced-axis"],
 )
@@ -2271,10 +2261,10 @@ def __getitem__(self, selection: Any) -> Any:
 @pytest.mark.parametrize(
     ("build", "description"),
     [
-        (lambda a: a.lazy[1:3, :, :], "a basic slice"),
-        (lambda a: a.lazy[:, :, :], "the whole array"),
-        (lambda a: a.lazy[::-1, :, :], "a reversal"),
-        (lambda a: a.lazy.oindex[[2, 0], :, :], "a gather"),
+        (lambda a: a[1:3, :, :], "a basic slice"),
+        (lambda a: a[:, :, :], "the whole array"),
+        (lambda a: a[::-1, :, :], "a reversal"),
+        (lambda a: a.oindex[[2, 0], :, :], "a gather"),
     ],
 )
 def test_materializing_never_hands_back_the_wrapped_array(
@@ -2310,9 +2300,9 @@ def test_materializing_never_hands_back_the_wrapped_array(
         np.testing.assert_array_equal(data, before, err_msg=description)
 
 
-def test_an_eager_getitem_never_hands_back_the_wrapped_array() -> None:
+def test_eager_adapter_getitem_never_hands_back_the_wrapped_array() -> None:
     data = reference()
-    block = LazyArray(data)[1:3]
+    block = EagerArrayAdapter(LazyArray(data))[1:3]
     block[...] = -1
     np.testing.assert_array_equal(data, reference())
 
@@ -2326,7 +2316,7 @@ def test_result_refuses_to_return_a_partly_written_buffer(
     the parts tile the view. This is the guard that turns any future break of
     that contract into a failure instead of into plausible-looking numbers.
     """
-    view = LazyArray(reference()).with_parts(PART_SHAPE).lazy[:, 1:, :]
+    view = LazyArray(reference()).with_parts(PART_SHAPE)[:, 1:, :]
     complete = LazyArray.parts
 
     def drop_one(self: LazyArray) -> Any:
@@ -2339,7 +2329,7 @@ def drop_one(self: LazyArray) -> Any:
 
 def test_result_refuses_a_partition_of_the_wrong_rank(monkeypatch: pytest.MonkeyPatch) -> None:
     """A part addressing fewer axes than the view has is caught by name."""
-    view = LazyArray(reference()).with_parts(PART_SHAPE).lazy[:, 1:, :]
+    view = LazyArray(reference()).with_parts(PART_SHAPE)[:, 1:, :]
     complete = LazyArray.parts
 
     def truncate(self: LazyArray) -> Any:
@@ -2384,13 +2374,13 @@ def __getitem__(self, key: Any) -> DuckBlock:
 @pytest.mark.parametrize(
     ("build", "oracle"),
     [
-        (lambda a: a.lazy[1:5, ::2, :], lambda r: r[1:5, ::2, :]),
+        (lambda a: a[1:5, ::2, :], lambda r: r[1:5, ::2, :]),
         (
-            lambda a: a.lazy.oindex[[4, 0, 0], :, :],
+            lambda a: a.oindex[[4, 0, 0], :, :],
             lambda r: r[np.ix_([4, 0, 0], range(5), range(4))],
         ),
-        (lambda a: a.lazy.vindex[[4, 0], [1, 1]], lambda r: r[[4, 0], [1, 1]]),
-        (lambda a: a.lazy[::-1, :, :], lambda r: r[::-1, :, :]),
+        (lambda a: a.vindex[[4, 0], [1, 1]], lambda r: r[[4, 0], [1, 1]]),
+        (lambda a: a[::-1, :, :], lambda r: r[::-1, :, :]),
     ],
     ids=["basic", "oindex", "vindex", "reversal"],
 )
@@ -2426,53 +2416,28 @@ def test_numpy_matrix_is_refused() -> None:
 @pytest.mark.parametrize("parts", [None, (2, 2), (1, 4), (3, 4)])
 def test_a_masked_source_keeps_its_mask_under_every_partitioning(parts: Any) -> None:
     data = np.ma.masked_greater(np.arange(12).reshape(3, 4), 7)
-    got = repartition(LazyArray(data), parts).lazy[:, 1:].result()
+    view = repartition(LazyArray(data), parts)[:, 1:]
+    got = view.result()
     expected = data[:, 1:]
     assert isinstance(got, np.ma.MaskedArray), parts
     np.testing.assert_array_equal(np.ma.getmaskarray(got), np.ma.getmaskarray(expected))
     np.testing.assert_array_equal(np.ma.filled(got, 0), np.ma.filled(expected, 0))
+    assembled = np.ma.masked_all(view.shape, dtype=view.dtype)
+    for part in view.parts():
+        assembled[part.out_selection] = part.view.result()
+    np.testing.assert_array_equal(np.ma.getmaskarray(assembled), np.ma.getmaskarray(expected))
+    np.testing.assert_array_equal(np.ma.filled(assembled, 0), np.ma.filled(expected, 0))
 
 
 @pytest.mark.parametrize("parts", [None, (2, 2), (3, 4)])
 def test_a_masked_source_keeps_its_mask_when_the_view_is_empty(parts: Any) -> None:
-    """An empty result is still a result, and its type must not depend on the parts.
-
-    An empty view is answered without reading the source at all, and that
-    shortcut reached for the array namespace's own `empty` — which knows nothing
-    about masks — so an unpartitioned empty view came back a plain array while
-    the same view partitioned came back masked. No cells either way, so nothing
-    about the values changed; the caller just got a different type depending on
-    how the read had been divided.
-    """
+    """Empty views of masked sources return masked arrays for every partitioning."""
     data = np.ma.masked_greater(np.arange(12).reshape(3, 4), 7)
-    got = repartition(LazyArray(data), parts).lazy[:, 2:2].result()
+    got = repartition(LazyArray(data), parts)[:, 2:2].result()
     assert isinstance(got, np.ma.MaskedArray), parts
     assert np.asarray(got).shape == (3, 0), parts
 
 
-def test_a_large_array_without_dask_refuses_to_claim_equality(
-    monkeypatch: pytest.MonkeyPatch,
-) -> None:
-    """Above the digest limit the fallback must miss a cache rather than lie.
-
-    Two arrays differing in one element used to token identically, because the
-    fallback described the shape and dtype and gave up on the contents.
-    """
-    import sys
-
-    monkeypatch.setitem(sys.modules, "dask.base", None)
-    big = np.zeros(1 << 19, dtype=np.int64)
-    other = big.copy()
-    other[0] = 1
-
-    assert LazyArray(big).__dask_tokenize__() != LazyArray(other).__dask_tokenize__()
-    assert LazyArray(big).__dask_tokenize__() != LazyArray(big).__dask_tokenize__()
-
-    # Below the limit the contents are digested, so equal data still tokens alike.
-    small = np.zeros(8, dtype=np.int64)
-    assert LazyArray(small).__dask_tokenize__() == LazyArray(small.copy()).__dask_tokenize__()
-
-
 # ---------------------------------------------------------------------------
 # Completeness and partition spellings
 # ---------------------------------------------------------------------------
@@ -2481,8 +2446,8 @@ def test_a_large_array_without_dask_refuses_to_claim_equality(
 def test_a_reversing_view_covers_its_parts() -> None:
     """A reversal reads every cell of every box, back to front."""
     data = np.arange(48).reshape(8, 6)
-    forward = LazyArray(data).with_parts((2, 2)).lazy[:, :]
-    reversed_view = LazyArray(data).with_parts((2, 2)).lazy[::-1, ::-1]
+    forward = LazyArray(data).with_parts((2, 2))[:, :]
+    reversed_view = LazyArray(data).with_parts((2, 2))[::-1, ::-1]
     assert [part.is_complete for part in reversed_view.parts()] == [
         part.is_complete for part in forward.parts()
     ]
@@ -2491,7 +2456,7 @@ def test_a_reversing_view_covers_its_parts() -> None:
 
 def test_a_strided_reversal_is_still_incomplete() -> None:
     data = np.arange(48).reshape(8, 6)
-    view = LazyArray(data).with_parts((2, 2)).lazy[::-2, :]
+    view = LazyArray(data).with_parts((2, 2))[::-2, :]
     assert not any(part.is_complete for part in view.parts())
 
 
@@ -2521,17 +2486,9 @@ def test_a_zero_chunk_on_a_nonempty_axis_is_still_rejected() -> None:
 def test_the_coverage_count_agrees_with_numpy_for_reversed_selections(
     selection: tuple[Any, ...],
 ) -> None:
-    """The safety net behind `result()`'s coverage assertion, checked on its own.
-
-    `_out_selection_cell_count` sizes a partition's `out_selection` without
-    materializing it, and `result()` trusts that count to decide whether the
-    walk covered the view. Nothing pinned it for a reversed slice, so dropping
-    its `start <= stop` guard — or wrapping the subtraction in `abs()` — left
-    the suite green. A net nobody tests only matters once something else breaks,
-    which is exactly when it needs to be right.
-    """
+    """Coverage counts match NumPy selection sizes for reversed slices."""
     data = reference()
-    view = LazyArray(data).with_parts((2, 2, 2)).lazy[selection]
+    view = LazyArray(data).with_parts((2, 2, 2))[selection]
     out_shape = view.shape
     for part in view.parts():
         counted = _out_selection_cell_count(part.out_selection, out_shape)
@@ -2556,49 +2513,32 @@ def test_the_coverage_count_agrees_with_numpy_for_reversed_selections(
 def test_the_coverage_count_matches_numpy_for_intervals_the_fast_path_declines(
     selection: tuple[Any, ...], out_shape: tuple[int, ...], expected: int
 ) -> None:
-    """The guard on `result()`'s safety net, exercised where the walk cannot reach it.
-
-    A partition walk only ever produces concrete forward in-bounds intervals, so
-    the guard that keeps everything else off the subtraction fast path is not
-    reachable through `parts()` at all — which is why removing it left the whole
-    suite green. It is the net's own contract, so it is checked directly.
-    """
+    """Coverage counts match NumPy for intervals outside the subtraction fast path."""
     counted = _out_selection_cell_count(selection, out_shape)
     assert counted == np.empty(out_shape)[selection].size
     assert counted == expected
 
 
 def test_a_zero_dimensional_index_array_drops_its_axis_like_a_scalar() -> None:
-    """`a[np.array(2), :]` is `a[2, :]` in NumPy, and now here too.
-
-    Only Python and NumPy integers counted as scalars, so a 0-d array fell
-    through to the fancy path and was widened into a length-1 index array —
-    keeping an axis NumPy drops. That was a third answer, agreeing with neither
-    NumPy nor eager zarr, which rejects it.
-    """
+    """Zero-dimensional integer arrays drop axes in orthogonal and vectorized selections."""
     data = np.arange(20).reshape(4, 5)
     for mode, expected in (
         ("oindex", data[np.array(2), :]),
         ("vindex", data[np.array(2), np.array(3)]),
     ):
         view = (
-            LazyArray(data).lazy.oindex[np.array(2), slice(None)]
+            LazyArray(data).oindex[np.array(2), slice(None)]
             if mode == "oindex"
-            else LazyArray(data).lazy.vindex[np.array(2), np.array(3)]
+            else LazyArray(data).vindex[np.array(2), np.array(3)]
         )
         assert view.shape == expected.shape, mode
         np.testing.assert_array_equal(np.asarray(view.result()), expected, err_msg=mode)
 
 
 def test_a_multidimensional_array_in_an_orthogonal_selection_is_refused() -> None:
-    """The rule belongs to the selection, so the message speaks its vocabulary.
-
-    Left to the engine, this surfaced as a rank complaint about an `index_array`
-    the caller never wrote — the transform layer's words for a mistake made two
-    layers above it.
-    """
+    """Reject multidimensional orthogonal index arrays with a selection-level error."""
     with pytest.raises(IndexError, match="must be 1-dimensional"):
-        LazyArray(np.arange(20).reshape(4, 5)).lazy.oindex[[[0, 1], [2, 3]], slice(None)]
+        LazyArray(np.arange(20).reshape(4, 5)).oindex[[[0, 1], [2, 3]], slice(None)]
 
 
 def test_with_parts_rejects_a_bare_integer() -> None:
@@ -2611,18 +2551,72 @@ def test_with_parts_rejects_a_bare_integer() -> None:
 
 
 def test_fancy_composition_over_an_empty_axis() -> None:
-    """Regression: composing fancy steps over an empty axis stays unpinned.
-
-    The empty-domain branch of `compose` produces index arrays that are
-    singleton on every non-empty axis; pinning one to an axis it merely
-    broadcasts along made a later basic step index a size-1 axis positionally
-    and raise, deep inside a legal chain.
-    """
+    """Fancy composition over an empty axis preserves shape through later selections."""
     base = np.empty((3, 0, 6), dtype=np.int64)
-    view = LazyArray(base).lazy.oindex[[2, 1], :, [5, 0, 3]]
+    view = LazyArray(base).oindex[[2, 1], :, [5, 0, 3]]
     assert view.shape == (2, 0, 3)
-    composed = view.lazy.oindex[[1, 0], :, [2, 2]]
+    composed = view.oindex[[1, 0], :, [2, 2]]
     assert composed.shape == (2, 0, 2)
-    scalar = composed.lazy.vindex[..., np.array(1)]
+    scalar = composed.vindex[..., np.array(1)]
     assert scalar.shape == (2, 0)
     assert np.asarray(scalar.result()).shape == (2, 0)
+
+
+@pytest.mark.parametrize("kind", ["numpy", "object", "masked", "registered", "hook"])
+def test_source_token_uses_dask_policy(kind: str) -> None:
+    dask_base = pytest.importorskip("dask.base")
+
+    class RegisteredArray(ForeignArray):
+        pass
+
+    class VersionedArray(ForeignArray):
+        def __dask_tokenize__(self) -> Any:
+            return ("versioned-source", 1)
+
+    dask_base.normalize_token.register(RegisteredArray, lambda source: ("registered-source", 1))
+    data = np.arange(4)
+    sources = {
+        "numpy": data,
+        "object": data.astype(object),
+        "masked": np.ma.masked_greater(data, 2),
+        "registered": RegisteredArray(data, None),
+        "hook": VersionedArray(data, None),
+    }
+    source = sources[kind]
+    assert LazyArray(source).__dask_tokenize__()[1] == dask_base.tokenize(source)
+
+
+def test_source_token_preserves_dask_determinism_requirement() -> None:
+    dask_base = pytest.importorskip("dask.base")
+    dask_tokenize = pytest.importorskip("dask.tokenize")
+
+    class UnserializableArray(ForeignArray):
+        def __reduce_ex__(self, protocol: int) -> Any:
+            raise TypeError("cannot serialize source")
+
+    source = UnserializableArray(np.arange(4), None)
+    for value in (source, LazyArray(source)):
+        with pytest.raises(dask_tokenize.TokenizationError):
+            dask_base.tokenize(value, ensure_deterministic=True)
+
+
+def test_source_token_preserves_hook_failure() -> None:
+    pytest.importorskip("dask.base")
+
+    class RefusingArray(ForeignArray):
+        def __dask_tokenize__(self) -> Any:
+            raise RuntimeError("source version unavailable")
+
+    with pytest.raises(RuntimeError, match="source version unavailable"):
+        LazyArray(RefusingArray(np.arange(4), None)).__dask_tokenize__()
+
+
+def test_dask_is_only_required_for_tokenization(monkeypatch: pytest.MonkeyPatch) -> None:
+    import sys
+
+    monkeypatch.setitem(sys.modules, "dask.base", None)
+    data = np.arange(4)
+    view = LazyArray(data)[1:]
+    np.testing.assert_array_equal(view.result(), data[1:])
+    with pytest.raises(ModuleNotFoundError):
+        view.__dask_tokenize__()
diff --git a/packages/zarr-indexing/tests/test_lazy_array_stateful.py b/packages/zarr-indexing/tests/test_lazy_array_stateful.py
index 4f5dadc1e4..de0d422b0e 100644
--- a/packages/zarr-indexing/tests/test_lazy_array_stateful.py
+++ b/packages/zarr-indexing/tests/test_lazy_array_stateful.py
@@ -9,13 +9,9 @@
 declared. The zarr case runs a smaller budget: it reads through a store, and it
 exercises the same code paths.
 
-This replaces a seeded `_random_chain` sweep in `test_lazy_array` that read
-chained selections through `parts()`. That sweep did reach the states it was
-meant to, but a rank-0 correlated view was absorbed by a reshape in `result()`
-and mirrored into the sweep rather than read as a failure; asserting the
-documented assembly literally makes that impossible to paper over.
-`test_lazy_array` keeps its `result()`-based sweep, which is the deterministic
-cross-flavor coverage this does not attempt.
+The state machine checks both result() and explicit partition assembly against
+NumPy, including the shape of each partition's values. test_lazy_array also
+provides deterministic selection-chain coverage across source flavors.
 """
 
 from __future__ import annotations
diff --git a/packages/zarr-indexing/tests/test_lazy_default.py b/packages/zarr-indexing/tests/test_lazy_default.py
new file mode 100644
index 0000000000..875b7cd5c2
--- /dev/null
+++ b/packages/zarr-indexing/tests/test_lazy_default.py
@@ -0,0 +1,213 @@
+"""The wrapper defers selection; explicit execution touches the source."""
+
+from collections.abc import Callable
+from typing import Any
+
+import numpy as np
+import pytest
+
+from zarr_indexing import EagerArrayAdapter, IndexDomain, IndexTransform, LazyArray
+from zarr_indexing.errors import BoundsCheckError
+
+
+class RecordingArray:
+    def __init__(self) -> None:
+        self.data = np.arange(30).reshape(5, 6)
+        self.shape = self.data.shape
+        self.dtype = self.data.dtype
+        self.reads: list[Any] = []
+
+    def __getitem__(self, key: Any) -> Any:
+        self.reads.append(key)
+        return self.data[key]
+
+
+@pytest.mark.parametrize("mode", ["basic", "oindex", "vindex", "iteration"])
+def test_selection_defers_reads(mode: str) -> None:
+    source = RecordingArray()
+    array = LazyArray(source)
+    if mode == "basic":
+        view = array[1:][::-1, ::2]
+        expected = source.data[1:][::-1, ::2]
+    elif mode == "oindex":
+        view = array.oindex[[4, 1], :][:, ::2]
+        expected = source.data[[4, 1]][:, ::2]
+    elif mode == "vindex":
+        view = array.vindex[[4, 1], [2, 0]][::-1]
+        expected = source.data[[4, 1], [2, 0]][::-1]
+    else:
+        view = list(array)[2]
+        expected = source.data[2]
+    assert isinstance(view, LazyArray)
+    assert source.reads == []
+    np.testing.assert_array_equal(view.result(), expected)
+    assert source.reads
+
+
+def test_no_redundant_lazy_accessor() -> None:
+    assert not hasattr(LazyArray(np.arange(3)), "lazy")
+
+
+@pytest.mark.parametrize("selection", [slice(None), slice(0, 0), 0])
+def test_eager_adapter_executes_selection(selection: Any) -> None:
+    source = RecordingArray()
+    view = LazyArray(source)[1:, ::2]
+    adapter = EagerArrayAdapter(view)
+    assert (adapter.shape, adapter.ndim, adapter.dtype) == (view.shape, view.ndim, view.dtype)
+    assert source.reads == []
+    result = adapter[selection]
+    assert isinstance(result, np.ndarray)
+    np.testing.assert_array_equal(result, source.data[1:, ::2][selection])
+    assert not np.shares_memory(result, source.data)
+
+
+def test_eager_adapter_distinguishes_token_semantics() -> None:
+    pytest.importorskip("dask")
+    view = LazyArray(np.arange(8))[::2]
+    assert EagerArrayAdapter(view).__dask_tokenize__() != view.__dask_tokenize__()
+
+
+def test_eager_adapter_refuses_no_copy_conversion() -> None:
+    with pytest.raises(ValueError, match="copy"):
+        EagerArrayAdapter(LazyArray(np.arange(3))).__array__(copy=False)
+
+
+def test_views_keep_literal_domains_while_keys_stay_positional() -> None:
+    source = np.arange(30)
+    view = LazyArray(source)[10:20]
+    assert view.transform.domain == IndexDomain((10,), (20,))
+    nested = view[2:5]
+    assert nested.transform.domain == IndexDomain((12,), (15,))
+    np.testing.assert_array_equal(nested.result(), source[12:15])
+    # NumPy keys are positions in the current view, not literal coordinates.
+    assert view[0].result() == source[10]
+    assert view[-1].result() == source[19]
+    assert nested[-1].result() == source[14]
+    np.testing.assert_array_equal(view[::-1][:3].result(), source[10:20][::-1][:3])
+    # Equivalent selections built by different routes share one domain.
+    assert LazyArray(source)[0:20][5:10].transform == LazyArray(source)[5:10].transform
+
+
+def test_domain_key_selects_literal_coordinates() -> None:
+    source = np.arange(30)
+    view = LazyArray(source)[10:20]
+    inner = view[IndexDomain((12,), (15,))]
+    assert inner.transform.domain == IndexDomain((12,), (15,))
+    np.testing.assert_array_equal(inner.result(), source[12:15])
+    np.testing.assert_array_equal(LazyArray(source)[IndexDomain((2,), (5,))].result(), source[2:5])
+    with pytest.raises(BoundsCheckError):
+        view[IndexDomain((0,), (3,))]
+    # An empty domain outside the view is refused too: the key names the view's coordinates.
+    with pytest.raises(BoundsCheckError):
+        view[IndexDomain((50,), (50,))]
+    assert view[IndexDomain((15,), (15,))].shape == (0,)
+    with pytest.raises(ValueError, match="rank"):
+        view[IndexDomain((0, 0), (1, 1))]
+    view[IndexDomain((12,), (15,))] = [-1, -2, -3]
+    np.testing.assert_array_equal(source[12:15], [-1, -2, -3])
+
+
+def test_transform_key_composes_onto_the_view() -> None:
+    source = np.arange(30)
+    view = LazyArray(source)[10:20]
+    reversed_key = IndexTransform.identity(view.transform.domain)[::-1]
+    np.testing.assert_array_equal(view[reversed_key].result(), source[10:20][::-1])
+    rebased = IndexTransform.identity(IndexDomain((12,), (15,))).translate_domain_to((0,))
+    composed = view[rebased]
+    assert composed.transform.domain == IndexDomain((0,), (3,))
+    np.testing.assert_array_equal(composed.result(), source[12:15])
+    with pytest.raises((ValueError, BoundsCheckError)):
+        view[IndexTransform.identity(IndexDomain((0,), (3,)))]
+
+
+def test_box_part_views_are_sub_domains_of_their_parent() -> None:
+    source = np.arange(40).reshape(4, 10)
+    view = LazyArray(source).with_parts((2, 4))[1:, 3:9]
+    origin = view.transform.domain.inclusive_min
+    for part in view.parts():
+        domain = part.view.transform.domain
+        assert all(
+            lo >= parent_lo and hi <= parent_hi
+            for lo, hi, parent_lo, parent_hi in zip(
+                domain.inclusive_min,
+                domain.exclusive_max,
+                view.transform.domain.inclusive_min,
+                view.transform.domain.exclusive_max,
+                strict=True,
+            )
+        )
+        # Placement is readable from the domain: it is `out_selection`.
+        assert part.out_selection == tuple(
+            slice(lo - o, hi - o, 1)
+            for lo, hi, o in zip(domain.inclusive_min, domain.exclusive_max, origin, strict=True)
+        )
+        np.testing.assert_array_equal(part.view.result(), source[1:, 3:9][part.out_selection])
+        for child in part.view.parts():
+            assert child.view.transform.domain == domain
+    # A part placed by index arrays cannot carry the request's coordinates: its
+    # domain is fresh and zero-origin, and `out_selection` is the placement.
+    fancy = LazyArray(source).with_parts((2, 4))[1:, 3:9].oindex[[2, 0], :]
+    assembled = np.empty(fancy.shape, dtype=fancy.dtype)
+    for part in fancy.parts():
+        assert part.view.transform.domain.inclusive_min == (0,) * part.view.ndim
+        assembled[part.out_selection] = part.view.result()
+    np.testing.assert_array_equal(assembled, source[1:, 3:9][[2, 0], :])
+
+
+def test_reader_contexts_are_re_based_whatever_the_view_domain() -> None:
+    from zarr_indexing.reader import ReadContext
+
+    view = LazyArray(np.arange(30))[10:20][::-1]
+    context = ReadContext(view.transform)
+    assert context.transform.domain == IndexDomain((0,), (10,))
+    assert context.transform.apply((0,)) == view.transform.apply(
+        view.transform.domain.inclusive_min
+    )
+
+
+DOMAIN_CASES: list[
+    tuple[str, Callable[[LazyArray], LazyArray], tuple[int, ...], tuple[int, ...]]
+] = [
+    ("whole", lambda v: v[:], (0, 0), (6, 8)),
+    ("ellipsis", lambda v: v[...], (0, 0), (6, 8)),
+    ("slice", lambda v: v[2:5], (2, 0), (5, 8)),
+    ("nested slice", lambda v: v[2:5][1:], (3, 0), (5, 8)),
+    ("negative stop", lambda v: v[2:5][:-1], (2, 0), (4, 8)),
+    ("empty", lambda v: v[2:5][1:1], (3, 0), (3, 8)),
+    ("int drops axis", lambda v: v[2:5][-1], (0,), (8,)),
+    ("strided", lambda v: v[:, 1:7:2], (0, 0), (6, 3)),
+    ("reversed", lambda v: v[::-1], (-5, 0), (1, 8)),
+    ("reversed then slice", lambda v: v[::-1][1:3], (-4, 0), (-2, 8)),
+    ("reversed twice", lambda v: v[1:4, 2:6][::-1, ::-1], (-3, -5), (0, -1)),
+    ("newaxis", lambda v: v[None, 2:4], (0, 2, 0), (1, 4, 8)),
+    ("oindex", lambda v: v.oindex[[3, 1], 2:6], (0, 2), (2, 6)),
+    ("oindex on slice", lambda v: v[2:5].oindex[[1, 0], :], (0, 0), (2, 8)),
+    ("vindex", lambda v: v.vindex[[1, 2], [3, 4]], (0,), (2,)),
+    ("domain key", lambda v: v[2:5][IndexDomain((3, 0), (4, 8))], (3, 0), (4, 8)),
+]
+
+
+@pytest.mark.parametrize(
+    ("case", "select", "lo", "hi"), DOMAIN_CASES, ids=[c[0] for c in DOMAIN_CASES]
+)
+def test_indexing_preserves_the_literal_domain(
+    case: str, select: Callable[[LazyArray], LazyArray], lo: tuple[int, ...], hi: tuple[int, ...]
+) -> None:
+    """A view's domain is the literal domain TensorStore-style composition gives it.
+
+    Slices keep their coordinates, nested slices compose them, integers drop
+    axes, `None` and index arrays open fresh zero-origin axes, and reversals
+    run negative. Values are unaffected: the same positional keys select the
+    same NumPy elements.
+    """
+    source = np.arange(48).reshape(6, 8)
+    view = select(LazyArray(source))
+    expected = IndexDomain(lo, hi)
+    assert view.transform.domain == expected, case
+    assert view.shape == expected.shape
+    # The literal frame is live: the domain's own first coordinate addresses the
+    # view's first element, and `ReadContext` still hands readers a zero origin.
+    if view.size:
+        np.testing.assert_array_equal(
+            view.result().flat[0], source[view.transform.apply(expected.inclusive_min)]
+        )
diff --git a/packages/zarr-indexing/tests/test_ndsel_tensorstore.py b/packages/zarr-indexing/tests/test_ndsel_tensorstore.py
index ab9465c8d1..29b5b8a2e4 100644
--- a/packages/zarr-indexing/tests/test_ndsel_tensorstore.py
+++ b/packages/zarr-indexing/tests/test_ndsel_tensorstore.py
@@ -1,14 +1,14 @@
 """Cross-check canonical ndsel bodies against a real TensorStore.
 
-A normalized ndsel `transform` body is, field-for-field, a TensorStore
-`IndexTransform` (minus the `kind` discriminator, which the canonical body never
-carries). This test loads a handful of finite-bound canonical bodies into
+Canonical ndsel bodies use TensorStore's `IndexTransform` field vocabulary,
+but the consumers have different validation constraints. This test loads a
+handful of finite-bound canonical bodies supported by both implementations into
 `tensorstore.IndexTransform(json=...)` and confirms that TensorStore's own
 `to_json()` re-loads, through our engine layer, into an equivalent transform.
 
 Skipped when tensorstore is not installed. Run it explicitly with:
 
-    uv run --with tensorstore pytest \
+    hatch run test.py3.12-optional:pytest \
         packages/zarr-indexing/tests/test_ndsel_tensorstore.py -q
 """
 
diff --git a/packages/zarr-indexing/tests/test_reader.py b/packages/zarr-indexing/tests/test_reader.py
index 11241a316c..d3da049f0e 100644
--- a/packages/zarr-indexing/tests/test_reader.py
+++ b/packages/zarr-indexing/tests/test_reader.py
@@ -69,7 +69,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> np.ndarray[Any, Any]:
         np.zeros((1, 0), dtype=np.intp),
         np.array([[3]], dtype=np.intp),
         np.array(3),
-        lambda array: array.lazy[3],
+        lambda array: array[3],
         id="constant",
     ),
     pytest.param(
@@ -79,7 +79,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> np.ndarray[Any, Any]:
         np.array([[0], [1], [2], [3]], dtype=np.intp),
         np.array([[1], [3], [5], [7]], dtype=np.intp),
         np.array([1, 3, 5, 7]),
-        lambda array: array.lazy[1:8:2],
+        lambda array: array[1:8:2],
         id="positive-affine",
     ),
     pytest.param(
@@ -89,7 +89,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> np.ndarray[Any, Any]:
         np.array([[-3], [-2], [-1], [0]], dtype=np.intp),
         np.array([[7], [5], [3], [1]], dtype=np.intp),
         np.array([7, 5, 3, 1]),
-        lambda array: array.lazy[::-2],
+        lambda array: array[::-2],
         id="negative-affine",
     ),
     pytest.param(
@@ -102,7 +102,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> np.ndarray[Any, Any]:
         np.array([[0], [1], [2]], dtype=np.intp),
         np.array([[2], [2], [2]], dtype=np.intp),
         np.array([2, 2, 2]),
-        lambda array: array.lazy.oindex[[2, 2, 2]],
+        lambda array: array.oindex[[2, 2, 2]],
         id="zero-affine",
     ),
     pytest.param(
@@ -112,7 +112,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> np.ndarray[Any, Any]:
         np.array([[0, 0], [0, 1], [1, 0], [1, 1], [2, 0], [2, 1]], dtype=np.intp),
         np.array([[3, 4], [3, 0], [1, 4], [1, 0], [1, 4], [1, 0]], dtype=np.intp),
         np.array([[19, 15], [9, 5], [9, 5]]),
-        lambda array: array.lazy.oindex[[3, 1, 1], [4, 0]],
+        lambda array: array.oindex[[3, 1, 1], [4, 0]],
         id="orthogonal-array",
     ),
     pytest.param(
@@ -122,7 +122,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> np.ndarray[Any, Any]:
         np.array([[0], [1], [2]], dtype=np.intp),
         np.array([[3, 4], [1, 0], [1, 4]], dtype=np.intp),
         np.array([19, 5, 9]),
-        lambda array: array.lazy.vindex[[3, 1, 1], [4, 0, 4]],
+        lambda array: array.vindex[[3, 1, 1], [4, 0, 4]],
         id="correlated-array",
     ),
     pytest.param(
@@ -145,7 +145,7 @@ def __getitem__(self, key: tuple[Any, ...]) -> np.ndarray[Any, Any]:
         np.empty((0, 1), dtype=np.intp),
         np.empty((0, 1), dtype=np.intp),
         np.array([], dtype=np.intp),
-        lambda array: array.lazy[2:2],
+        lambda array: array[2:2],
         id="empty",
     ),
 )
@@ -210,8 +210,65 @@ def test_successful_transform_contract_across_planning_readers_and_lazy_array(
         np.testing.assert_array_equal(out, expected_values)
 
     if lazy_selection is not None:
-        view = lazy_selection(LazyArray.from_numpy(source_data).with_parts(chunk_shape))
-        np.testing.assert_array_equal(view.result(), expected_values)
+        reader = ProjectionRequiredReader()
+        view = lazy_selection(
+            LazyArray.from_numpy(source_data).with_parts(chunk_shape).with_reader(reader)
+        )
+        parts = tuple(view.parts())
+        np.testing.assert_array_equal(view.result(parts=parts), expected_values)
+        parent_contexts = tuple(reader.contexts)
+        reader.contexts.clear()
+        assembled = np.empty(view.shape, dtype=view.dtype)
+        for part in reversed(parts):
+            values = part.view.result()
+            assert not np.shares_memory(values, source_data)
+            assert values.dtype == expected_values.dtype
+            assembled[part.out_selection] = values
+        np.testing.assert_array_equal(assembled, expected_values)
+        for independent, parent in zip(reversed(reader.contexts), parent_contexts, strict=True):
+            assert independent.transform == parent.transform
+            assert independent.projection is not None
+            assert parent.projection is not None
+            assert independent.projection.chunk_coords == parent.projection.chunk_coords
+            assert independent.projection.chunk_domain == parent.projection.chunk_domain
+            assert independent.projection.chunk_transform == parent.projection.chunk_transform
+        for candidate in (view, view.unpartitioned()):
+            np.testing.assert_array_equal(candidate.result(), expected_values)
+        for part in parts:
+            assert part.view.base_shape == source_data.shape
+            for child in part.view.parts():
+                np.testing.assert_array_equal(child.view.result(), part.view.result())
+            reverse = (slice(None, None, -1),) * part.view.ndim
+            np.testing.assert_array_equal(part.view[reverse].result(), part.view.result()[reverse])
+            for candidate in (
+                part.view.unpartitioned(),
+                part.view.with_parts((1,) * source_data.ndim),
+            ):
+                np.testing.assert_array_equal(candidate.result(), part.view.result())
+
+
+class ProjectionRequiredReader:
+    """Read through chunk-local coordinates so losing the projection breaks execution."""
+
+    def __init__(self) -> None:
+        self.contexts: list[ReadContext] = []
+
+    def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
+        projection = context.projection
+        assert projection is not None
+        self.contexts.append(context)
+        for position, cell in zip(
+            np.ndindex(out.shape),
+            _domain_coordinates(projection.chunk_transform.domain),
+            strict=True,
+        ):
+            local = projection.chunk_transform.apply(cell)
+            global_position = tuple(
+                coord + origin
+                for coord, origin in zip(local, projection.chunk_domain.inclusive_min, strict=True)
+            )
+            assert context.transform.apply(position) == global_position
+            out[position] = source[global_position]
 
 
 def _domain_coordinates(domain: IndexDomain) -> list[tuple[int, ...]]:
@@ -349,15 +406,12 @@ def test_builtin_readers_share_transform_affine_overflow(reader_name: str) -> No
 
 
 def test_empty_domain_composed_fancy_transform_reads_as_empty() -> None:
-    """An ArrayMap composed over an empty domain resolves like any other map.
+    """An empty composed domain reads as empty for every built-in reader.
 
-    The composed map is legitimately empty along the vanished axis; the
-    resolvers used to fail reshaping it instead of noticing that an empty
-    domain selects nothing.
-    """
+    Empty index arrays are valid when the domain selects no elements."""
     source_data = np.arange(6).reshape(2, 3)
-    view = LazyArray.from_numpy(source_data).lazy.oindex[slice(0, 0), np.array([2, 1, 2, 0])]
-    transform = view.lazy.oindex[slice(None), np.array([1, 3, 1])].transform
+    view = LazyArray.from_numpy(source_data).oindex[slice(0, 0), np.array([2, 1, 2, 0])]
+    transform = view.oindex[slice(None), np.array([1, 3, 1])].transform
     assert transform.domain.shape == (0, 3)
 
     for reader, source in (
@@ -370,19 +424,19 @@ def test_empty_domain_composed_fancy_transform_reads_as_empty() -> None:
 
 
 def test_unit_step_reader_reads_through_lazy_array() -> None:
-    """The full dialect resolves through a source that only accepts unit-step slices.
+    """The parametrized selections resolve through a unit-step-only source.
 
     `UnitStepOnlySource` asserts the shape of every key it receives, so each
     selection here also proves no strided, descending, or non-slice key
     reached the source — partitioned and unpartitioned alike.
     """
     selections: tuple[Callable[[LazyArray], LazyArray], ...] = (
-        lambda v: v.lazy[1:5, ::2, ::-1],
-        lambda v: v.lazy[5:1:-2, None, 3, ::3],
-        lambda v: v.lazy.oindex[[3, 0, 3], ::-2, [7, 7]],
-        lambda v: v.lazy.vindex[np.array([[0, 5]]), np.array([[6], [0]]), 2],
-        lambda v: v.lazy[2:2, :, ::-1],
-        lambda v: v.lazy[::5, 6, 1:8:4],
+        lambda v: v[1:5, ::2, ::-1],
+        lambda v: v[5:1:-2, None, 3, ::3],
+        lambda v: v.oindex[[3, 0, 3], ::-2, [7, 7]],
+        lambda v: v.vindex[np.array([[0, 5]]), np.array([[6], [0]]), 2],
+        lambda v: v[2:2, :, ::-1],
+        lambda v: v[::5, 6, 1:8:4],
     )
     for select in selections:
         for parts in (None, (2, 3, 8), (6, 7, 1)):
diff --git a/packages/zarr-indexing/tests/test_transform.py b/packages/zarr-indexing/tests/test_transform.py
index 9e8b24bf4a..6fffca110b 100644
--- a/packages/zarr-indexing/tests/test_transform.py
+++ b/packages/zarr-indexing/tests/test_transform.py
@@ -1142,23 +1142,14 @@ def test_length1_orthogonal_collapses_to_a_constant(self) -> None:
 
 
 class TestDerivedMapDependency:
-    """A map's `input_dimension` must describe the array it is built with.
+    """Derived map dependencies follow the index array's shape.
 
-    Three separate failures came from one stale value: a vectorized index applied
-    to an orthogonal map makes it correlated, but the old dependency was carried
-    onto the new array anyway. Readers fall back to that field when the shape
-    alone cannot say, so the wrong axis was believed much later — by a scatter
-    that filed positions under it, which is why the answer depended on how the
-    read was partitioned.
-    """
+    Vectorized and orthogonal composition must preserve the selected values
+    and their placement for each partitioning."""
 
     def test_a_vindex_over_a_fancy_view_is_marked_correlated(self) -> None:
         base = np.arange(6)
-        view = (
-            LazyArray(base)
-            .lazy.oindex[np.array([0, 1])]
-            .lazy.vindex[np.array([[0, 1, 0], [1, 0, 1]])]
-        )
+        view = LazyArray(base).oindex[np.array([0, 1])].vindex[np.array([[0, 1, 0], [1, 0, 1]])]
         np.testing.assert_array_equal(
             np.asarray(view.result()), base[[0, 1]][[[0, 1, 0], [1, 0, 1]]]
         )
@@ -1167,7 +1158,7 @@ def test_the_same_view_resolves_alike_however_it_is_partitioned(self) -> None:
         base = np.arange(36).reshape(6, 6)
 
         def build(array: LazyArray) -> LazyArray:
-            return array.lazy.oindex[np.array([-3, -6, -4]), -4].lazy.vindex[np.array([[-2, -3]])]
+            return array.oindex[np.array([-3, -6, -4]), -4].vindex[np.array([[-2, -3]])]
 
         unpartitioned = np.asarray(build(LazyArray(base)).result())
         partitioned = np.asarray(build(LazyArray(base).with_parts((3, 3))).result())
@@ -1191,17 +1182,12 @@ def test_dependency_axes_are_read_from_the_shape(self) -> None:
 
 
 def test_an_orthogonal_step_over_a_correlated_view_is_an_outer_product() -> None:
-    """`oindex` after `vindex` means the outer product, not a joint gather.
-
-    The reindexing applied its index tuple positionally, which is NumPy's
-    *vectorized* rule, so two arrays collapsed into one axis and the result came
-    back a rank short of what was asked for.
-    """
+    """Orthogonal indexing after vectorized indexing selects an outer product."""
     base = np.arange(14).reshape(7, 2)
-    view = LazyArray(base).lazy.vindex[
+    view = LazyArray(base).vindex[
         np.array([[5, 5], [1, 2], [0, 4]]), np.array([[1, 1], [1, 0], [1, 0]])
     ]
-    result = np.asarray(view.lazy.oindex[np.array([1, 1, 0]), np.array([1, 1, 0, 1])].result())
+    result = np.asarray(view.oindex[np.array([1, 1, 0]), np.array([1, 1, 0, 1])].result())
     assert result.shape == (3, 4)
     np.testing.assert_array_equal(result, np.array([[4, 4, 3, 4], [4, 4, 3, 4], [11, 11, 11, 11]]))
 
@@ -1213,12 +1199,7 @@ def test_an_orthogonal_step_over_a_correlated_view_is_an_outer_product() -> None
 def test_an_index_array_value_just_outside_the_domain_is_refused(
     value: int, description: str
 ) -> None:
-    """The bound checks are probed at the boundary, not comfortably past it.
-
-    Both were only ever exercised from well outside the domain, so relaxing
-    either by one — `lo - 1` instead of `lo` — went unnoticed while letting a
-    view read a cell it does not address.
-    """
+    """Reject the coordinate below the lower bound and the exclusive upper bound."""
     transform = IndexTransform.from_shape((12,))[2:10]
     with pytest.raises(BoundsCheckError, match="out of bounds"):
         transform.oindex[np.array([value, 3])]
@@ -1274,3 +1255,15 @@ def test_index_array_structure_classifies_the_three_shapes() -> None:
         ),
     )
     assert diagonal.index_array_structure == "general"
+
+
+@pytest.mark.parametrize("array_first", [False, True])
+def test_intersect_rejects_array_and_affine_shared_input_axis(array_first: bool) -> None:
+    """Joint filtering of affine and lookup coordinates must not return extra cells."""
+    affine = DimensionMap(0)
+    lookup = ArrayMap(np.array([0, 3, 1, 2]))
+    output = (lookup, affine) if array_first else (affine, lookup)
+    transform = IndexTransform(IndexDomain.from_shape((4,)), output)
+    output_domain = IndexDomain((0, 1), (2, 4)) if array_first else IndexDomain((1, 0), (4, 2))
+    with pytest.raises(NotImplementedError, match="also bound by a slice map"):
+        transform.intersect(output_domain)
diff --git a/packages/zarr-indexing/tests/test_wire_boundaries.py b/packages/zarr-indexing/tests/test_wire_boundaries.py
new file mode 100644
index 0000000000..81074f1c40
--- /dev/null
+++ b/packages/zarr-indexing/tests/test_wire_boundaries.py
@@ -0,0 +1,63 @@
+"""Boundary validation must preserve coordinates and canonical messages."""
+
+from typing import Any
+
+import numpy as np
+import pytest
+
+from zarr_indexing._wire import lower_index_array
+from zarr_indexing.messages import NdselError, normalize_ndsel
+
+
+@pytest.mark.parametrize("raw", [[True, 2], [[0, False]], [True, False]])
+def test_index_array_rejects_boolean_elements(raw: Any) -> None:
+    with pytest.raises(NdselError, match="integers"):
+        lower_index_array(raw, "index_array")
+
+
+@pytest.mark.parametrize("value", [int(np.iinfo(np.intp).max) + 1, int(np.iinfo(np.intp).min) - 1])
+def test_index_array_rejects_out_of_range_coordinates(value: int) -> None:
+    with pytest.raises(NdselError):
+        lower_index_array([value], "index_array")
+
+
+@pytest.mark.parametrize(
+    "raw", [[], [[], []], [0, -1, 2], [int(np.iinfo(np.intp).min), int(np.iinfo(np.intp).max)]]
+)
+def test_index_array_preserves_integer_coordinates(raw: Any) -> None:
+    result = lower_index_array(raw, "index_array")
+    assert result.dtype == np.dtype(np.intp)
+    assert result.tolist() == raw
+
+
+@pytest.mark.parametrize(("start", "stop"), [(-(2**63), -(2**63)), (-(2**63) + 1, -(2**63))])
+def test_slice_rejects_unrepresentable_canonical_bounds(start: int, stop: int) -> None:
+    with pytest.raises(NdselError):
+        normalize_ndsel({"kind": "slice", "start": [start], "stop": [stop], "step": [-1]})
+
+
+@pytest.mark.parametrize(
+    "message",
+    [
+        {"kind": "box", "shape": [1] * 33},
+        {"kind": "slice", "start": [0] * 33, "stop": [1] * 33},
+        {"kind": "transform", "input_shape": [1] * 33},
+    ],
+)
+def test_normalize_rejects_excessive_inferred_rank(message: dict[str, Any]) -> None:
+    with pytest.raises(NdselError, match="rank"):
+        normalize_ndsel(message)
+
+
+@pytest.mark.parametrize(
+    "message",
+    [
+        {"kind": "box", "shape": [1] * 32},
+        {"kind": "transform", "input_rank": 32},
+        {"kind": "slice", "start": [-(2**63) + 1], "stop": [-(2**63) + 1], "step": [-1]},
+        {"kind": "slice", "start": [2**63 - 1], "stop": [-(2**63) + 1], "step": [-(2**63)]},
+    ],
+)
+def test_normalize_boundary_results_are_idempotent(message: dict[str, Any]) -> None:
+    canonical = normalize_ndsel(message)
+    assert normalize_ndsel({"kind": "transform", **canonical}) == canonical
diff --git a/packages/zarr-indexing/tests/test_wire_bounds.py b/packages/zarr-indexing/tests/test_wire_bounds.py
new file mode 100644
index 0000000000..6ae5581f04
--- /dev/null
+++ b/packages/zarr-indexing/tests/test_wire_bounds.py
@@ -0,0 +1,130 @@
+"""Index-array bounds are validated against raw coordinates during loading."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import pytest
+
+from zarr_indexing import ConstantMap, IndexTransform, normalize_ndsel
+from zarr_indexing.messages import NdselError
+from zarr_indexing.output_map import output_index_map_from_json
+
+if TYPE_CHECKING:
+    from zarr_indexing.json import IndexTransformJSON, OutputIndexMapJSON
+
+
+def load(values: Any, bounds: Any, entry: str, offset: int, stride: int) -> Any:
+    output: OutputIndexMapJSON = {"index_array": values, "offset": offset, "stride": stride}
+    if bounds is not None:
+        output["index_array_bounds"] = bounds
+    if entry == "output_map":
+        return output_index_map_from_json(output)
+    body: IndexTransformJSON = {"input_shape": list(np.asarray(values).shape), "output": [output]}
+    return IndexTransform.from_json(body)
+
+
+@pytest.mark.parametrize("entry", ["transform", "output_map"])
+@pytest.mark.parametrize(("offset", "stride"), [(0, 1), (10, -2), (7, 0)])
+@pytest.mark.parametrize(
+    ("values", "bounds"),
+    [
+        ([-3, 0, 4], [-3, 4]),
+        ([-3, 0, 4], ["-inf", 4]),
+        ([-3, 0, 4], [-3, "+inf"]),
+        ([-3, 0, 4], ["-inf", "+inf"]),
+        ([-3, 0, 4], None),
+        ([2], [2, 2]),
+        ([], [2, 2]),
+        ([], ["+inf", "+inf"]),
+        ([], ["-inf", "-inf"]),
+        ([[0, 2], [2, 0]], [0, 2]),
+    ],
+)
+def test_valid_bounds_preserve_values_and_roundtrip(
+    values: Any, bounds: Any, entry: str, offset: int, stride: int
+) -> None:
+    model = np.asarray(values, dtype=np.intp)
+    loaded = load(values, bounds, entry, offset, stride)
+    expected = offset + stride * model
+    if entry == "transform":
+        points = np.array(list(np.ndindex(model.shape)), dtype=np.intp).reshape(-1, model.ndim)
+        restored = IndexTransform.from_json(loaded.to_json())
+        np.testing.assert_array_equal(loaded.apply_many(points).reshape(model.shape), expected)
+        np.testing.assert_array_equal(restored.apply_many(points).reshape(model.shape), expected)
+        # Further selection and affine adjustment operate on validated coordinates.
+        if model.ndim == 1 and model.size > 1:
+            selected = loaded.oindex[[model.size - 1, 0]].translate((3,))
+            np.testing.assert_array_equal(
+                selected.apply_many([[0], [1]]).ravel(), expected[[-1, 0]] + 3
+            )
+    else:
+        restored = output_index_map_from_json(loaded.to_json())
+        if isinstance(restored, ConstantMap):
+            np.testing.assert_array_equal(np.full(model.shape, restored.offset), expected)
+        else:
+            assert restored == loaded
+        np.testing.assert_array_equal(loaded.offset + loaded.stride * loaded.index_array, expected)
+    if bounds is not None:
+        canonical = normalize_ndsel(
+            {
+                "kind": "transform",
+                "input_shape": list(model.shape),
+                "output": [{"index_array": values, "index_array_bounds": bounds}],
+            }
+        )
+        assert canonical["output"][0]["index_array_bounds"] == bounds
+
+
+@pytest.mark.parametrize("entry", ["transform", "output_map"])
+@pytest.mark.parametrize(("offset", "stride"), [(0, 1), (10, -2), (7, 0)])
+@pytest.mark.parametrize(
+    ("values", "bounds"),
+    [
+        ([-1, 0], [0, 2]),
+        ([0, 3], [0, 2]),
+        ([3], [2, 2]),
+        ([-1], [0, "+inf"]),
+        ([3], ["-inf", 2]),
+        ([0], ["+inf", "+inf"]),
+        ([0], ["-inf", "-inf"]),
+        ([[0, 1], [1, 3]], [0, 2]),
+    ],
+)
+def test_out_of_bounds_raw_values_are_rejected(
+    values: Any, bounds: Any, entry: str, offset: int, stride: int
+) -> None:
+    with pytest.raises(NdselError, match="index_array_bounds") as exc:
+        load(values, bounds, entry, offset, stride)
+    assert exc.value.reason == "invalid_json"
+
+
+@pytest.mark.parametrize("entry", ["transform", "output_map"])
+@pytest.mark.parametrize("values", [[], [1]])
+@pytest.mark.parametrize("bounds", [[], [0], [0, 1, 2], [False, 2], [0.5, 2], ["bad", 2]])
+def test_malformed_bounds_are_rejected(values: Any, bounds: Any, entry: str) -> None:
+    with pytest.raises(NdselError) as exc:
+        load(values, bounds, entry, 0, 1)
+    assert exc.value.reason == "invalid_json"
+
+
+@pytest.mark.parametrize("entry", ["transform", "output_map"])
+@pytest.mark.parametrize("values", [[], [1]])
+def test_reversed_bounds_are_rejected(values: Any, entry: str) -> None:
+    with pytest.raises(NdselError) as exc:
+        load(values, [2, 0], entry, 0, 1)
+    assert exc.value.reason == "bounds_out_of_order"
+
+
+@pytest.mark.parametrize("entry", ["transform", "output_map"])
+@pytest.mark.parametrize("value", [int(np.iinfo(np.intp).min), int(np.iinfo(np.intp).max)])
+def test_integer_extreme_bounds_are_exact(entry: str, value: int) -> None:
+    result = load([value], [value, value], entry, 0, 1)
+    if entry == "transform":
+        assert result.apply((0,)) == (value,)
+    else:
+        assert int(result.index_array[0]) == value
+    bounds = [value + 1, "+inf"] if value < 0 else ["-inf", value - 1]
+    with pytest.raises(NdselError, match="index_array_bounds"):
+        load([value], bounds, entry, 0, 1)
diff --git a/packages/zarr-indexing/tests/test_writer.py b/packages/zarr-indexing/tests/test_writer.py
new file mode 100644
index 0000000000..af9623b26e
--- /dev/null
+++ b/packages/zarr-indexing/tests/test_writer.py
@@ -0,0 +1,462 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pytest
+
+from zarr_indexing.domain import IndexDomain
+from zarr_indexing.output_map import ArrayMap, ConstantMap, DimensionMap
+from zarr_indexing.transform import IndexTransform
+from zarr_indexing.writer import write_into
+
+
+class BasicSource:
+    """Reject source reads and advanced writes, recording basic writes."""
+
+    def __init__(self, data: np.ndarray[Any, Any]) -> None:
+        self.data = data
+        self.shape = data.shape
+        self.dtype = data.dtype
+        self.calls: list[tuple[int | slice, ...]] = []
+
+    def __setitem__(self, key: tuple[int | slice, ...], value: Any) -> None:
+        assert all(isinstance(item, (int, slice)) for item in key)
+        assert all(
+            not isinstance(item, slice) or item.step is None or item.step > 0 for item in key
+        )
+        self.calls.append(key)
+        self.data[key] = value
+
+
+@pytest.mark.parametrize(
+    "case",
+    ["reverse", "scalar", "newaxis", "empty", "outer", "composed", "correlated", "transpose"],
+)
+def test_write_coordinates(case: str) -> None:
+    data = np.arange(24).reshape(4, 6)
+    expected = data.copy()
+    # Select flat source identifiers independently of the transform evaluator.
+    identifiers = np.arange(data.size).reshape(data.shape)
+    transform = IndexTransform.from_shape(data.shape)
+    if case == "reverse":
+        transform = transform[::-1, ::2]
+        identifiers = identifiers[::-1, ::2]
+    elif case == "scalar":
+        transform = transform[2, 3]
+        identifiers = identifiers[2, 3]
+    elif case == "newaxis":
+        transform = IndexTransform(
+            IndexDomain.from_shape((1, 4, 6)), (DimensionMap(1), DimensionMap(2))
+        )
+        identifiers = identifiers[None]
+    elif case == "empty":
+        transform = transform[1:1, :]
+        identifiers = identifiers[1:1, :]
+    elif case == "outer":
+        transform = transform.oindex[[3, 1, 3], [5, 0, 5]]
+        identifiers = identifiers[np.ix_([3, 1, 3], [5, 0, 5])]
+    elif case == "composed":
+        transform = transform.oindex[[3, 1, 3], :].oindex[[2, 0], [5, 0]]
+        identifiers = identifiers[[3, 1, 3]][np.ix_([2, 0], [5, 0])]
+    elif case == "correlated":
+        transform = IndexTransform(
+            IndexDomain.from_shape((3, 2)),
+            (
+                ArrayMap(np.array([[3], [0], [3]], dtype=np.intp)),
+                ArrayMap(np.array([[5, 1], [0, 2], [5, 1]], dtype=np.intp)),
+            ),
+        )
+        identifiers = identifiers[np.array([[3], [0], [3]]), np.array([[5, 1], [0, 2], [5, 1]])]
+    else:
+        transform = IndexTransform(
+            IndexDomain.from_shape((6, 4)), (DimensionMap(1), DimensionMap(0))
+        )
+        identifiers = identifiers.T
+    values = np.arange(identifiers.size).reshape(identifiers.shape) + 100
+    for index, value in zip(np.asarray(identifiers).flat, values.flat, strict=True):
+        expected.flat[index] = value
+    source = BasicSource(data)
+    assert write_into(source, transform, values) is None
+    np.testing.assert_array_equal(data, expected)
+    if case in ("reverse", "scalar", "newaxis", "transpose"):
+        assert len(source.calls) == 1
+    elif case == "empty":
+        assert source.calls == []
+
+
+@pytest.mark.parametrize("fancy", [False, True])
+def test_write_alias_and_broadcast(fancy: bool) -> None:
+    data = np.arange(6)
+    expected = data[::-1].copy()
+    transform = IndexTransform.from_shape(data.shape)
+    transform = transform.oindex[[5, 4, 3, 2, 1, 0]] if fancy else transform[::-1]
+    write_into(BasicSource(data), transform, data)
+    np.testing.assert_array_equal(data, expected)
+    write_into(BasicSource(data), transform, np.array([[17]]))
+    np.testing.assert_array_equal(data, np.full(6, 17))
+
+
+def test_write_broadcast_error_before_mutation() -> None:
+    source = BasicSource(np.zeros((4, 6)))
+    with pytest.raises(ValueError):
+        write_into(source, IndexTransform.from_shape(source.shape), [1, 2])
+    assert source.calls == []
+
+
+def test_write_cast_error_before_mutation() -> None:
+    source = BasicSource(np.zeros(2, dtype=np.int64))
+    with pytest.raises(ValueError):
+        write_into(source, IndexTransform.from_shape(source.shape), ["1", "invalid"])
+    assert source.calls == []
+
+
+def test_write_bounds_error_before_mutation() -> None:
+    source = BasicSource(np.zeros(2))
+    transform = IndexTransform(
+        IndexDomain.from_shape((2,)), (ArrayMap(np.array([0, 2], dtype=np.intp)),)
+    )
+    with pytest.raises(IndexError, match="outside"):
+        write_into(source, transform, [1, 2])
+    assert source.calls == []
+
+
+def test_write_readonly_error() -> None:
+    data = np.zeros(2)
+    data.flags.writeable = False
+    with pytest.raises(ValueError, match="read-only"):
+        write_into(data, IndexTransform.from_shape(data.shape), 1)
+
+
+def test_write_constant_repeated_destination() -> None:
+    source = BasicSource(np.zeros(3))
+    transform = IndexTransform(IndexDomain.from_shape((2, 3)), (ConstantMap(1),))
+    write_into(source, transform, [[1], [9]])
+    np.testing.assert_array_equal(source.data, [0, 9, 0])
+    assert len(source.calls) == 6
+
+
+@pytest.mark.parametrize("scalar", [False, True])
+def test_write_scalar_source_and_shared_dimensions(scalar: bool) -> None:
+    if scalar:
+        source = BasicSource(np.array(0))
+        transform = IndexTransform.from_shape(())
+        expected = np.array(7)
+    else:
+        source = BasicSource(np.zeros((3, 3), dtype=np.int64))
+        transform = IndexTransform(IndexDomain.from_shape((3,)), (DimensionMap(0), DimensionMap(0)))
+        expected = np.diag([7, 7, 7])
+    write_into(source, transform, 7)
+    np.testing.assert_array_equal(source.data, expected)
+
+
+def test_write_rank_error_before_mutation() -> None:
+    source = BasicSource(np.zeros((2, 2)))
+    with pytest.raises(ValueError, match="output rank"):
+        write_into(source, IndexTransform.from_shape((2,)), 1)
+    assert source.calls == []
+
+
+@pytest.mark.parametrize("masked_source", [False, True])
+@pytest.mark.parametrize("fancy", [False, True])
+def test_write_masked_values(masked_source: bool, fancy: bool) -> None:
+    data: Any = np.arange(12).reshape(3, 4)
+    if masked_source:
+        data = np.ma.array(data, mask=np.ones(data.shape, dtype=bool))
+    expected = data.copy()
+    values = np.ma.array([[31, 32, 33, 34]], mask=[[False, True, False, True]])
+    transform = IndexTransform.from_shape(data.shape)
+    if fancy:
+        transform = transform.oindex[[2, 0, 2], :]
+        expected[[2, 0, 2], :] = values
+    else:
+        transform = transform[::-1, :]
+        expected[::-1, :] = values
+    write_into(data, transform, values)
+    np.testing.assert_array_equal(np.ma.getdata(data), np.ma.getdata(expected))
+    np.testing.assert_array_equal(np.ma.getmaskarray(data), np.ma.getmaskarray(expected))
+
+
+def test_write_masked_lazy_alias() -> None:
+    from zarr_indexing.lazy_array import LazyArray
+
+    source = np.ma.array(np.arange(6), mask=[True, False, False, True, False, True])
+    expected = source[::-1].copy()
+    array = LazyArray(source)
+    array[::-1] = array
+    np.testing.assert_array_equal(source.data, expected.data)
+    np.testing.assert_array_equal(source.mask, expected.mask)
+
+
+@pytest.mark.parametrize("backend", ["numpy", "zarr"])
+@pytest.mark.parametrize("case", ["basic", "outer", "vector", "newaxis", "empty", "alias"])
+def test_lazy_write_and_assignment(backend: str, case: str) -> None:
+    from zarr_indexing.lazy_array import LazyArray
+
+    initial = np.arange(20).reshape(4, 5)
+    source: Any = initial.copy()
+    if backend == "zarr":
+        zarr = pytest.importorskip("zarr")
+        source = zarr.create_array({}, shape=initial.shape, chunks=(2, 3), dtype="int64")
+        source[:] = initial
+    array = LazyArray(source)
+    identifiers = initial.copy()
+    expected = initial.copy()
+    if case == "basic":
+        view = array[::-1, ::2][1:, 1:]
+        identifiers = identifiers[::-1, ::2][1:, 1:]
+    elif case == "outer":
+        view = array.oindex[[3, 0, 3], [4, 1]].oindex[[2, 0, 1], [1, 0]]
+        identifiers = identifiers[np.ix_([3, 0, 3], [4, 1])][np.ix_([2, 0, 1], [1, 0])]
+    elif case == "vector":
+        view = array.oindex[[3, 0, 3], :].vindex[[2, 0, 1], [4, 4, 1]]
+        identifiers = identifiers[[3, 0, 3], :][[2, 0, 1], [4, 4, 1]]
+    elif case == "newaxis":
+        view = array[None, 1:3, :]
+        identifiers = identifiers[None, 1:3, :]
+    elif case == "empty":
+        view = array[2:2, :]
+        identifiers = identifiers[2:2, :]
+    else:
+        array[::-1, :] = array
+        np.testing.assert_array_equal(source[:], initial[::-1])
+        return
+    values = np.arange(identifiers.size).reshape(identifiers.shape) + 100
+    for identifier, value in zip(identifiers.flat, values.flat, strict=True):
+        expected.flat[identifier] = value
+    assert view.write(values) is None
+    np.testing.assert_array_equal(source[:], expected)
+    # All selector assignment entry points write through to the original source.
+    array.oindex[[0, 3], [1, 4]] = 77
+    expected[np.ix_([0, 3], [1, 4])] = 77
+    array.vindex[[0, 0, 2], [2, 2, 4]] = [10, 11, 12]
+    expected[[0, 0, 2], [2, 2, 4]] = [10, 11, 12]
+    np.testing.assert_array_equal(source[:], expected)
+
+
+@pytest.mark.parametrize("backend", ["numpy", "zarr"])
+def test_random_selection_chain_scatter(backend: str) -> None:
+    """Map selected integer labels back to storage without consulting transforms."""
+    from zarr_indexing.lazy_array import LazyArray
+
+    rng = np.random.default_rng(58123)
+    for _ in range(24):
+        initial = np.arange(30).reshape(5, 6)
+        source: Any = initial.copy()
+        if backend == "zarr":
+            zarr = pytest.importorskip("zarr")
+            source = zarr.create_array({}, shape=initial.shape, chunks=(2, 3), dtype="int64")
+            source[:] = initial
+        view = LazyArray(source)
+        identifiers = initial
+        for _ in range(3):
+            if rng.integers(2):
+                rows = rng.integers(0, view.shape[0], size=4)
+                cols = rng.integers(0, view.shape[1], size=3)
+                view = view.oindex[rows, cols]
+                identifiers = identifiers[np.ix_(rows, cols)]
+            else:
+                step = int(rng.choice([-2, -1, 1, 2]))
+                view = view[::step, ::-1]
+                identifiers = identifiers[::step, ::-1]
+        values = rng.integers(100, 200, size=identifiers.shape)
+        expected = initial.copy()
+        for identifier, value in zip(identifiers.flat, values.flat, strict=True):
+            expected.flat[identifier] = value
+        view.write(values)
+        np.testing.assert_array_equal(source[:], expected)
+
+
+class _ChunkTouches:
+    """Count the storage round trips a zarr array makes, one per chunk key."""
+
+    def __init__(self) -> None:
+        self.gets = 0
+        self.sets = 0
+
+    @classmethod
+    def wrap(cls, zarr: Any) -> tuple[Any, _ChunkTouches]:
+        counter = cls()
+
+        class CountingStore(zarr.storage.MemoryStore):
+            async def get(self, key: str, prototype: Any, byte_range: Any = None) -> Any:
+                counter.gets += 1
+                return await super().get(key, prototype, byte_range)
+
+            async def set(self, key: str, value: Any) -> None:
+                counter.sets += 1
+                await super().set(key, value)
+
+        return CountingStore(), counter
+
+
+@pytest.mark.parametrize("sharded", [False, True])
+@pytest.mark.parametrize("case", ["outer_rows", "vector_points", "duplicates"])
+def test_fancy_writes_touch_each_write_chunk_once(sharded: bool, case: str) -> None:
+    """Storage round trips scale with touched write chunks, not selected elements."""
+    zarr = pytest.importorskip("zarr")
+    from zarr_indexing.lazy_array import LazyArray
+
+    store, touches = _ChunkTouches.wrap(zarr)
+    kwargs: dict[str, Any] = {"chunks": (2, 2), "shards": (4, 4)} if sharded else {"chunks": (4, 4)}
+    source = zarr.create_array(store, shape=(12, 12), dtype="int64", **kwargs)
+    source[:] = 0
+    expected = np.zeros((12, 12), dtype=np.int64)
+    touches.gets = touches.sets = 0
+    view = LazyArray(source)
+    if case == "outer_rows":
+        rows = [1, 5, 11]
+        values = np.arange(3 * 12).reshape(3, 12)
+        view.oindex[rows, :] = values
+        expected[rows, :] = values
+        touched = {(r // 4, c) for r in rows for c in range(3)}
+    elif case == "vector_points":
+        rows, cols = [0, 7, 7, 11, 3], [0, 2, 9, 11, 5]
+        values = np.arange(5) + 10
+        view.vindex[rows, cols] = values
+        expected[rows, cols] = values
+        touched = {(r // 4, c // 4) for r, c in zip(rows, cols, strict=True)}
+    else:
+        view.oindex[[5, 5, 6], 2:5] = np.array([[1] * 3, [2] * 3, [3] * 3])
+        expected[5, 2:5] = 2
+        expected[6, 2:5] = 3
+        touched = {(1, 0), (1, 1)}
+    gets, sets = touches.gets, touches.sets
+    np.testing.assert_array_equal(source[:], expected)
+    assert sets == len(touched), (sets, len(touched))
+    # At most the hull read plus zarr's own partial-chunk read per cell.
+    assert gets <= 2 * len(touched), (gets, len(touched))
+
+
+def test_write_grid_prefers_write_chunk_sizes_over_chunks() -> None:
+    """A source whose write grid is coarser than its read grid is written by the write grid."""
+    from zarr_indexing.lazy_array import LazyArray
+
+    class ShardedSource:
+        chunks = ((2, 2, 2), (3, 3))
+        write_chunk_sizes = ((6,), (3, 3))
+
+        def __init__(self) -> None:
+            self.data = np.zeros((6, 6), dtype=np.int64)
+            self.shape = self.data.shape
+            self.dtype = self.data.dtype
+            self.boxes: list[tuple[slice, ...]] = []
+
+        def __getitem__(self, key: Any) -> Any:
+            return self.data[key]
+
+        def __setitem__(self, key: Any, value: Any) -> None:
+            self.boxes.append(key)
+            self.data[key] = value
+
+    source = ShardedSource()
+    LazyArray(source).oindex[[0, 5], :] = 7
+    expected = np.zeros((6, 6), dtype=np.int64)
+    expected[[0, 5], :] = 7
+    np.testing.assert_array_equal(source.data, expected)
+    # One read-modify-write per touched write cell: two column shards, each
+    # spanning all six rows, rather than the four inner chunks a read grid names.
+    assert len(source.boxes) == 2
+    assert all(box[0] == slice(0, 6) for box in source.boxes)
+
+
+def test_write_only_source_falls_back_to_element_assignment() -> None:
+    source = BasicSource(np.zeros((3, 4), dtype=np.int64))
+    transform = IndexTransform.from_shape(source.shape).oindex[[2, 0], [1, 3]]
+    write_into(source, transform, np.array([[1, 2], [3, 4]]))
+    assert len(source.calls) == 4
+    expected = np.zeros((3, 4), dtype=np.int64)
+    expected[np.ix_([2, 0], [1, 3])] = [[1, 2], [3, 4]]
+    np.testing.assert_array_equal(source.data, expected)
+
+
+def test_masked_zero_rank_affine_write_keeps_payload() -> None:
+    from zarr_indexing.lazy_array import LazyArray
+
+    source = np.ma.array([1, 2, 3])
+    LazyArray(source)[1].write(np.ma.array(7, mask=True))
+    np.testing.assert_array_equal(source.data, [1, 7, 3])
+    np.testing.assert_array_equal(np.ma.getmaskarray(source), [False, True, False])
+
+
+def test_write_rank_error_precedes_value_broadcasting() -> None:
+    source = np.zeros((3, 4), dtype=np.int64)
+    transform = IndexTransform.from_shape((3,))
+    with pytest.raises(ValueError, match="rank"):
+        write_into(source, transform, np.arange(6).reshape(2, 3))
+    np.testing.assert_array_equal(source, 0)
+
+
+def test_empty_selection_still_validates_values() -> None:
+    source = np.zeros(5, dtype=np.int64)
+    with pytest.raises(ValueError, match="broadcast"):
+        write_into(source, IndexTransform.from_shape((5,))[2:2], np.arange(3))
+    with pytest.raises(ValueError):
+        write_into(source, IndexTransform.from_shape((5,))[2:2], ["not a number"])
+    np.testing.assert_array_equal(source, 0)
+
+
+def test_gridless_readable_source_never_reads() -> None:
+    """Without a write grid the hull could be the whole array, so elements are assigned."""
+    from zarr_indexing.lazy_array import LazyArray
+
+    class ReadableSource(BasicSource):
+        def __getitem__(self, key: Any) -> Any:
+            raise AssertionError("gridless writes must not read the source")
+
+    source = ReadableSource(np.zeros((4, 4), dtype=np.int64))
+    LazyArray(source).vindex[[0, 3], [3, 0]] = [1, 2]
+    expected = np.zeros((4, 4), dtype=np.int64)
+    expected[[0, 3], [3, 0]] = [1, 2]
+    np.testing.assert_array_equal(source.data, expected)
+    assert len(source.calls) == 2
+
+
+def test_unfactorable_transform_falls_back_to_elements_on_a_gridded_source() -> None:
+    """A diagonal reads one input axis twice, which the planner rejects; it is still written."""
+
+    class GriddedSource(BasicSource):
+        chunks = ((2, 2), (2, 2))
+
+        def __getitem__(self, key: Any) -> Any:
+            return self.data[key]
+
+    source = GriddedSource(np.zeros((4, 4), dtype=np.int64))
+    diagonal = IndexTransform(IndexDomain.from_shape((4,)), (DimensionMap(0), DimensionMap(0)))
+    write_into(source, diagonal, np.arange(1, 5), write_grid=None)
+    from zarr_indexing.grid import dimension_grids_from_chunks
+
+    source.data[:] = 0
+    source.calls.clear()
+    write_into(
+        source,
+        diagonal,
+        np.arange(1, 5),
+        write_grid=dimension_grids_from_chunks(source.chunks, (4, 4)),
+    )
+    np.testing.assert_array_equal(source.data, np.diag([1, 2, 3, 4]))
+    assert len(source.calls) == 4
+
+
+def test_writes_bypass_the_reader_so_a_caching_reader_serves_stale_values() -> None:
+    """Pins the documented hazard: the reader is not invalidated by `write`."""
+    from zarr_indexing.lazy_array import LazyArray
+    from zarr_indexing.reader import ReadContext, basic_reader
+
+    class CachingReader:
+        def __init__(self) -> None:
+            self.cache: dict[tuple[Any, ...], Any] = {}
+
+        def read_into(self, source: Any, context: ReadContext, out: Any, /) -> None:
+            key = (context.transform.domain.shape, str(context.transform.to_json()))
+            if key not in self.cache:
+                basic_reader.read_into(source, context, out)
+                self.cache[key] = out.copy()
+            out[...] = self.cache[key]
+
+    source = np.arange(6)
+    view = LazyArray(source).with_reader(CachingReader())[1:4]
+    np.testing.assert_array_equal(view.result(), [1, 2, 3])
+    view.write([7, 8, 9])
+    np.testing.assert_array_equal(source, [0, 7, 8, 9, 4, 5])
+    np.testing.assert_array_equal(view.result(), [1, 2, 3])
diff --git a/packages/zarr-metadata/changes/4365.bugfix.md b/packages/zarr-metadata/changes/4365.bugfix.md
new file mode 100644
index 0000000000..6cda30f2d2
--- /dev/null
+++ b/packages/zarr-metadata/changes/4365.bugfix.md
@@ -0,0 +1 @@
+The v2 array validator follows the spec on two points it was stricter than: members outside the `.zarray` definition are tolerated and dropped (the spec says other keys ["SHOULD NOT be present ... and SHOULD be ignored"](https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L91-L92), unlike `.zgroup`'s ["MUST NOT"](https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L313)), and `filters: []` is accepted (["a list of JSON objects providing codec configurations, or null"](https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L76-L79) sets no minimum). The Pydantic schema follows: `ZarrV2ArrayMetadataJSON` is open and the filter pipeline has no minimum length.
diff --git a/packages/zarr-metadata/changes/4378.bugfix.md b/packages/zarr-metadata/changes/4378.bugfix.md
new file mode 100644
index 0000000000..cbe3a1a7ed
--- /dev/null
+++ b/packages/zarr-metadata/changes/4378.bugfix.md
@@ -0,0 +1,25 @@
+Concrete v3 entity types are now assignable to the fields they describe.
+Previously, none of the package's canonical codec / chunk-grid /
+chunk-key-encoding / data-type types (e.g. `BloscCodecMetadata`,
+`RegularChunkGridMetadata`) satisfied `ZarrV3MetadataFieldJSON`, so a
+type checker rejected putting them into the very fields they document
+(`codecs`, `chunk_grid`, `data_type`, ...). Three changes fix this:
+
+- `ZarrV3NamedConfigJSON.name` and `.configuration` are now `ReadOnly`
+  (PEP 705), making them covariant so concrete `name: Literal[...]` and
+  required-`configuration` shapes are accepted.
+- `ZarrV3NamedConfigJSON` is now `closed` (PEP 728): the spec's
+  named-configuration envelope has exactly `name` / `configuration` /
+  `must_understand`, and closing the type also makes it usable as a
+  `JSONValue` (needed for e.g. the `sharding_indexed` inner `codecs`).
+- Every concrete `*Object` / `*Configuration` TypedDict is now `closed`,
+  and object forms declare `must_understand: NotRequired[bool]` (any v3
+  metadata field may carry the extension member).
+
+**Soft-breaking** for type-checking consumers: dicts with keys beyond the
+declared shape no longer satisfy the closed types, and `name` /
+`configuration` can no longer be mutated through `ZarrV3NamedConfigJSON`.
+Both were previously accepted by type checkers but produced documents
+outside the spec's shapes. `zarr_metadata.pydantic` serializers now
+declare their return schema via the pydantic-facing shadow types, so
+pydantic schema generation stays warning-free.
diff --git a/packages/zarr-metadata/changes/4378.misc.1.md b/packages/zarr-metadata/changes/4378.misc.1.md
new file mode 100644
index 0000000000..5f5eb1f238
--- /dev/null
+++ b/packages/zarr-metadata/changes/4378.misc.1.md
@@ -0,0 +1,5 @@
+`ZarrV2ConsolidatedMetadataJSON.zarr_consolidated_format` is typed
+`Literal[1]` rather than `int`. Format 1 is the only defined `.zmetadata`
+format and the runtime validator already rejected anything else, so the
+type now carries the constraint the validator enforces instead of
+contradicting it.
diff --git a/packages/zarr-metadata/changes/4378.misc.md b/packages/zarr-metadata/changes/4378.misc.md
new file mode 100644
index 0000000000..ed9167064f
--- /dev/null
+++ b/packages/zarr-metadata/changes/4378.misc.md
@@ -0,0 +1,6 @@
+**Breaking:** every `validate_*` function in `zarr_metadata.model` now
+returns `tuple[ValidationProblem, ...]` instead of `list[ValidationProblem]`,
+and `MetadataValidationError.problems` is a tuple. Iteration and indexing are
+unchanged; callers that mutate reports must first copy them with
+`list(problems)`. `MetadataValidationError` still accepts any problem
+sequence.
diff --git a/packages/zarr-metadata/justfile b/packages/zarr-metadata/justfile
index 0f1861ed7d..843286b89f 100644
--- a/packages/zarr-metadata/justfile
+++ b/packages/zarr-metadata/justfile
@@ -2,12 +2,15 @@
 # directory as the working directory regardless of where `just` is invoked.
 
 # List available recipes
+# Quoted arguments must survive delegation from the root Justfile.
+set positional-arguments
+
 default:
     @just --list
 
 # Run the test suite; extra args are passed to pytest
 test *args:
-    uv run --group test pytest tests {{ args }}
+    uv run --group test pytest tests "$@"
 
 # Lint with the same invocation CI uses
 lint:
diff --git a/packages/zarr-metadata/pyproject.toml b/packages/zarr-metadata/pyproject.toml
index 8900f96dc5..6e7b0e4f52 100644
--- a/packages/zarr-metadata/pyproject.toml
+++ b/packages/zarr-metadata/pyproject.toml
@@ -95,6 +95,14 @@ include = [
 extend = "../../pyproject.toml"
 target-version = "py311"
 
+[tool.ruff.lint]
+# `Any` defeats the point of a package whose product is precise types, so it
+# is banned in annotations here rather than merely discouraged. Use `object`
+# for "any value" (the caller must narrow) and the document TypedDicts where
+# the shape is known; a genuinely dynamic annotation needs an explicit noqa
+# saying why.
+extend-select = ["ANN401"]
+
 [tool.pytest.ini_options]
 minversion = "7"
 testpaths = ["tests"]
diff --git a/packages/zarr-metadata/src/zarr_metadata/_common.py b/packages/zarr-metadata/src/zarr_metadata/_common.py
index 08c143107f..0751d56563 100644
--- a/packages/zarr-metadata/src/zarr_metadata/_common.py
+++ b/packages/zarr-metadata/src/zarr_metadata/_common.py
@@ -6,14 +6,21 @@
 `zarr_metadata.v3.data_type`.
 """
 
-from collections.abc import Mapping, Sequence
+from collections.abc import Mapping
 from typing import NotRequired
 
-from typing_extensions import TypeAliasType, TypedDict
+from typing_extensions import ReadOnly, TypeAliasType, TypedDict
 
 JSONValue = TypeAliasType(
     "JSONValue",
-    int | float | bool | str | Sequence["JSONValue"] | Mapping[str, "JSONValue"] | None,
+    int
+    | float
+    | bool
+    | str
+    | list["JSONValue"]
+    | tuple["JSONValue", ...]
+    | Mapping[str, "JSONValue"]
+    | None,
 )
 """A recursive type alias for JSON-encodable values.
 
@@ -21,30 +28,37 @@
 self-reference is a named recursion point that pydantic can resolve when
 building a `TypeAdapter`; a bare recursive `TypeAlias` raises
 `PydanticUserError`/`RecursionError` at validation time.
-
-The array arm is the covariant `Sequence` rather than the invariant
-`list["JSONValue"] | tuple["JSONValue", ...]`, so values typed with a
-*narrower* element type still count as JSON values: a `list[str]` field on a
-TypedDict is assignable to `JSONValue` under `Sequence` but not under
-`list[JSONValue]` (`list` is invariant in its element type, and pyright's
-diagnostic for that failure suggests exactly this change). This is what lets
-downstream TypedDicts give their fields precise types (`Sequence[str]`,
-`list[int]`, ...) while remaining assignable to `Mapping[str, JSONValue]`.
-The type-level cost, accepted deliberately: `Sequence` says nothing about the
-concrete container, and it admits `str`/`bytes` (`str` was already a union
-arm); runtime code narrowing a JSON array must exclude `str`/`bytes`/
-`bytearray` regardless of how this alias is spelled.
 """
 
 
-class ZarrV3NamedConfigJSON(TypedDict):
+class ZarrV3NamedConfigJSON(TypedDict, closed=True):
     """
     Externally-tagged union member for a metadata field.
 
     The optional `configuration` mapping holds arbitrary JSON-encodable
     values. `must_understand` is implicitly true when absent.
+
+    `name` and `configuration` are `ReadOnly` (PEP 705) so that concrete
+    entity types — `BloscCodecObject`, `RegularChunkGridObject`, and the
+    rest — are assignable to this type, and therefore to
+    `ZarrV3MetadataFieldJSON`. Without `ReadOnly` both items are invariant,
+    so a concrete `name: Literal["blosc"]` does not satisfy `name: str`, and
+    a required `configuration` does not satisfy a `NotRequired` one. That
+    made the package's own codec types unusable in the very fields they
+    describe (`codecs`, `data_type`, `chunk_grid`, ...), and made
+    `TypeIs`-based codec classification impossible to declare, since `TypeIs`
+    requires the narrowed type to be assignable to the input type.
+
+    `must_understand` stays writable: nothing needs to narrow it, and
+    keeping it mutable lets writers set it on an already-constructed field.
+
+    The type is `closed` (PEP 728): the spec's named-configuration envelope
+    has exactly these three members, and closing it is also what makes this
+    type — and every concrete entity type embedding it, e.g. the
+    `sharding_indexed` configuration's inner `codecs` list — assignable to
+    `Mapping[str, JSONValue]` (i.e. usable as a `JSONValue`).
     """
 
-    name: str
-    configuration: NotRequired[Mapping[str, JSONValue]]
+    name: ReadOnly[str]
+    configuration: NotRequired[ReadOnly[Mapping[str, JSONValue]]]
     must_understand: NotRequired[bool]
diff --git a/packages/zarr-metadata/src/zarr_metadata/_pydantic_schema.py b/packages/zarr-metadata/src/zarr_metadata/_pydantic_schema.py
index e9792d6931..51ec633b82 100644
--- a/packages/zarr-metadata/src/zarr_metadata/_pydantic_schema.py
+++ b/packages/zarr-metadata/src/zarr_metadata/_pydantic_schema.py
@@ -38,7 +38,7 @@ class ZarrV3MandatoryNamedConfigJSON(TypedDict, closed=True):
 ZarrV3MetadataFieldJSON = str | ZarrV3NamedConfigJSON
 ZarrV3MandatoryMetadataFieldJSON = str | ZarrV3MandatoryNamedConfigJSON
 ZarrV3CodecPipelineJSON = Annotated[tuple[ZarrV3MetadataFieldJSON, ...], Field(min_length=1)]
-ZarrV2FilterPipelineJSON = Annotated[tuple[ZarrV2CodecMetadata, ...], Field(min_length=1)]
+ZarrV2FilterPipelineJSON = tuple[ZarrV2CodecMetadata, ...]
 
 
 class ZarrV3ArrayMetadataJSON(TypedDict, extra_items=JSONValue):
@@ -74,8 +74,14 @@ class ZarrV3GroupMetadataJSON(TypedDict, extra_items=JSONValue):
     consolidated_metadata: NotRequired[ZarrV3ConsolidatedMetadataJSON | None]
 
 
-class ZarrV2ArrayMetadataJSON(TypedDict, closed=True):
-    """Schema input for the closed, merged v2 array representation."""
+class ZarrV2ArrayMetadataJSON(TypedDict, extra_items=JSONValue):
+    """Schema input for the merged v2 array representation.
+
+    Open, like the runtime validator: the v2 spec says other keys "SHOULD NOT
+    be present ... and SHOULD be ignored by implementations"
+    (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L91-L92); the group document's "MUST NOT" (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L313) keeps
+    `ZarrV2GroupMetadataJSON` closed.
+    """
 
     zarr_format: Literal[2]
     shape: tuple[NonNegativeInt, ...]
diff --git a/packages/zarr-metadata/src/zarr_metadata/model/_array.py b/packages/zarr-metadata/src/zarr_metadata/model/_array.py
index 0b562bc188..26a69a304a 100644
--- a/packages/zarr-metadata/src/zarr_metadata/model/_array.py
+++ b/packages/zarr-metadata/src/zarr_metadata/model/_array.py
@@ -51,7 +51,7 @@ class ZarrV3NamedConfig:
 
     Bare names and missing configurations normalize to an empty configuration.
     Bare names and missing `must_understand` members normalize to the spec's
-    implicit `True` value.
+    implicit `True` value (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1571-L1573).
     """
 
     name: str
@@ -61,10 +61,14 @@ class ZarrV3NamedConfig:
     def to_json(self) -> ZarrV3MetadataFieldJSON:
         if not self.configuration and self.must_understand:
             return self.name
-        out: ZarrV3NamedConfigJSON = {"name": self.name}
-        if self.configuration:
-            # to_json output shares no mutable state with the model.
-            out["configuration"] = copy.deepcopy(self.configuration)
+        # `configuration` is ReadOnly, so it is set in the literal rather than
+        # assigned afterwards. to_json output shares no mutable state with the
+        # model.
+        out: ZarrV3NamedConfigJSON = (
+            {"name": self.name, "configuration": copy.deepcopy(self.configuration)}
+            if self.configuration
+            else {"name": self.name}
+        )
         if not self.must_understand:
             out["must_understand"] = False
         return out
@@ -107,8 +111,8 @@ def must_understand_subset(
 ) -> dict[str, ZarrV3ExtensionField]:
     """The subset of `extra_fields` the reader is obligated to understand.
 
-    Per the v3 spec, an extension field is implicitly `must_understand: True`
-    unless it explicitly says otherwise, and an implementation MUST fail to
+    Per the v3 spec (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1571-L1578), an extension field is implicitly `must_understand:
+    True` unless it explicitly says otherwise, and an implementation MUST fail to
     open a group or array carrying fields it does not recognize that are not
     explicitly `must_understand: false`. A non-mapping field value cannot
     carry the explicit waiver, so it always requires understanding (the
@@ -310,7 +314,7 @@ def must_understand_fields(self) -> dict[str, ZarrV3ExtensionField]:
         """Extra fields the reader is obligated to understand.
 
         Everything in `extra_fields` not explicitly waived with
-        `must_understand: false` (the spec's implicit-true rule). A compliant
+        `must_understand: false` (the spec's implicit-true rule, https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1571-L1578). A compliant
         reader MUST fail to open the array if this contains any field it does
         not recognize; the model layer only partitions by obligation, since
         recognition is reader-specific.
@@ -428,7 +432,8 @@ def to_json(self) -> ZarrV2ArrayMetadataJSON:
         `attributes` is included when set (even empty). This is not the
         on-disk `.zarray` content: a conforming `.zarray` must exclude
         `attributes` (they live in the sibling `.zattrs` file). Use
-        `to_key_value` to produce the spec-conforming split for storage.
+        `to_key_value` to produce the spec-conforming split for storage
+        (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L323-L330).
         """
         # to_json output shares no mutable state with the model: every value
         # that can hold a mutable container is deep-copied.
@@ -464,7 +469,7 @@ def from_json(cls, data: object) -> ZarrV2ArrayMetadata:
 
     @classmethod
     def from_key_value(cls, mapping: Mapping[str, bytes]) -> ZarrV2ArrayMetadata:
-        zarray_raw = cast("object", load_store_json(mapping, ZARR_V2_ARRAY_METADATA_STORE_KEY))
+        zarray_raw = load_store_json(mapping, ZARR_V2_ARRAY_METADATA_STORE_KEY)
         if not isinstance(zarray_raw, Mapping):
             return cls.from_json(zarray_raw)
         zarray = cast("Mapping[str, object]", zarray_raw)
@@ -479,7 +484,7 @@ def from_key_value(cls, mapping: Mapping[str, bytes]) -> ZarrV2ArrayMetadata:
                 ]
             )
         if ZARR_V2_ATTRIBUTES_STORE_KEY in mapping:
-            zattrs = cast("object", load_store_json(mapping, ZARR_V2_ATTRIBUTES_STORE_KEY))
+            zattrs = load_store_json(mapping, ZARR_V2_ATTRIBUTES_STORE_KEY)
             return cls.from_json({**zarray, "attributes": zattrs})
         return cls.from_json(zarray)
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/model/_group.py b/packages/zarr-metadata/src/zarr_metadata/model/_group.py
index 63dfe5611f..5519e6fbb9 100644
--- a/packages/zarr-metadata/src/zarr_metadata/model/_group.py
+++ b/packages/zarr-metadata/src/zarr_metadata/model/_group.py
@@ -168,7 +168,7 @@ def must_understand_fields(self) -> dict[str, ZarrV3ExtensionField]:
         """Extra fields the reader is obligated to understand.
 
         Everything in `extra_fields` not explicitly waived with
-        `must_understand: false` (the spec's implicit-true rule). A compliant
+        `must_understand: false` (the spec's implicit-true rule, https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1571-L1578). A compliant
         reader MUST fail to open the group if this contains any field it does
         not recognize; the model layer only partitions by obligation, since
         recognition is reader-specific.
@@ -226,7 +226,7 @@ def to_json(self) -> ZarrV3ConsolidatedMetadataJSON:
     def from_json(cls, data: object) -> ZarrV3ConsolidatedMetadata:
         normalized = arrays_to_tuples(data)
         problems = validate_consolidated_metadata_v3(normalized)
-        if problems:
+        if len(problems) != 0:
             raise MetadataValidationError(problems)
         env = cast("Mapping[str, object]", normalized)
         entries: dict[str, ZarrV3ArrayMetadata | ZarrV3GroupMetadata] = {}
@@ -299,7 +299,8 @@ def to_json(self) -> ZarrV2GroupMetadataJSON:
         `attributes` is included when set (even empty). This is not the
         on-disk `.zgroup` content: a conforming `.zgroup` must exclude
         `attributes` (they live in the sibling `.zattrs` file). Use
-        `to_key_value` to produce the spec-conforming split for storage.
+        `to_key_value` to produce the spec-conforming split for storage
+        (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L313; https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L323-L330).
         """
         # to_json output shares no mutable state with the model.
         out: ZarrV2GroupMetadataJSON = {"zarr_format": self.zarr_format}
@@ -314,7 +315,7 @@ def from_json(cls, data: object) -> ZarrV2GroupMetadata:
 
     @classmethod
     def from_key_value(cls, mapping: Mapping[str, bytes]) -> ZarrV2GroupMetadata:
-        zgroup_raw = cast("object", load_store_json(mapping, ZARR_V2_GROUP_METADATA_STORE_KEY))
+        zgroup_raw = load_store_json(mapping, ZARR_V2_GROUP_METADATA_STORE_KEY)
         if not isinstance(zgroup_raw, Mapping):
             return cls.from_json(zgroup_raw)
         zgroup = cast("Mapping[str, object]", zgroup_raw)
@@ -329,7 +330,7 @@ def from_key_value(cls, mapping: Mapping[str, bytes]) -> ZarrV2GroupMetadata:
                 ]
             )
         if ZARR_V2_ATTRIBUTES_STORE_KEY in mapping:
-            zattrs = cast("object", load_store_json(mapping, ZARR_V2_ATTRIBUTES_STORE_KEY))
+            zattrs = load_store_json(mapping, ZARR_V2_ATTRIBUTES_STORE_KEY)
             return cls.from_json({**zgroup, "attributes": zattrs})
         return cls.from_json(zgroup)
 
@@ -416,7 +417,7 @@ def from_json(cls, data: object) -> ZarrV2ConsolidatedMetadata:
                         )
                         for problem in validate_json(value)
                     )
-        if problems:
+        if len(problems) != 0:
             raise MetadataValidationError(problems)
         entries_tupled = cast(
             "dict[str, JSONValue]",
diff --git a/packages/zarr-metadata/src/zarr_metadata/model/_validation.py b/packages/zarr-metadata/src/zarr_metadata/model/_validation.py
index a12e1911b1..f927851e4c 100644
--- a/packages/zarr-metadata/src/zarr_metadata/model/_validation.py
+++ b/packages/zarr-metadata/src/zarr_metadata/model/_validation.py
@@ -17,7 +17,7 @@
 import math
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Final, Literal, NoReturn, cast
+from typing import Final, Literal, NoReturn, cast
 
 from typing_extensions import TypeIs
 
@@ -62,27 +62,33 @@ def __str__(self) -> str:
 class MetadataValidationError(ValueError):
     """Raised when a value fails structural metadata validation.
 
-    Carries every problem found (not just the first) in `.problems`.
+    Carries every problem found (not just the first) in `.problems`, as an
+    immutable tuple: a raised error is a finished report, and a caller
+    inspecting it must not be able to edit the record.
     """
 
-    def __init__(self, problems: list[ValidationProblem]) -> None:
-        self.problems = problems
-        super().__init__("\n".join(str(problem) for problem in problems))
+    problems: tuple[ValidationProblem, ...]
 
+    def __init__(self, problems: Sequence[ValidationProblem]) -> None:
+        self.problems = tuple(problems)
+        super().__init__("\n".join(str(problem) for problem in self.problems))
 
-def _prefix(loc_head: str | int, problems: list[ValidationProblem]) -> list[ValidationProblem]:
+
+def _prefix(
+    loc_head: str | int, problems: Sequence[ValidationProblem]
+) -> tuple[ValidationProblem, ...]:
     """Prepend `loc_head` to the `loc` of every problem (for nested validators)."""
-    return [ValidationProblem((loc_head, *p.loc), p.message, p.kind) for p in problems]
+    return tuple(ValidationProblem((loc_head, *p.loc), p.message, p.kind) for p in problems)
 
 
-def validate_json(value: object) -> list[ValidationProblem]:
+def validate_json(value: object) -> tuple[ValidationProblem, ...]:
     """Return every reason `value` is not JSON-serializable (recursively)."""
     if isinstance(value, float):
         if math.isfinite(value):
-            return []
-        return [ValidationProblem((), f"non-finite float {value!r} is not JSON", "invalid_value")]
+            return ()
+        return (ValidationProblem((), f"non-finite float {value!r} is not JSON", "invalid_value"),)
     if isinstance(value, (str, int, bool)) or value is None:
-        return []
+        return ()
     problems: list[ValidationProblem] = []
     if isinstance(value, Mapping):
         for key, item in cast("Mapping[object, object]", value).items():
@@ -92,12 +98,12 @@ def validate_json(value: object) -> list[ValidationProblem]:
                 )
                 continue
             problems.extend(_prefix(key, validate_json(item)))
-        return problems
+        return tuple(problems)
     if isinstance(value, Sequence) and not isinstance(value, (bytes, bytearray)):
         for index, item in enumerate(cast("Sequence[object]", value)):
             problems.extend(_prefix(index, validate_json(item)))
-        return problems
-    return [ValidationProblem((), f"not a JSON-serializable value: {value!r}", "invalid_type")]
+        return tuple(problems)
+    return (ValidationProblem((), f"not a JSON-serializable value: {value!r}", "invalid_type"),)
 
 
 def _is_canonical_json(value: object) -> TypeIs[JSONValue]:
@@ -126,7 +132,7 @@ def parse_json(value: object) -> JSONValue:
     """Return a canonical `JSONValue`, or raise `MetadataValidationError`."""
     normalized = arrays_to_tuples(value)
     problems = validate_json(normalized)
-    if problems:
+    if len(problems) != 0:
         raise MetadataValidationError(problems)
     return cast(JSONValue, normalized)
 
@@ -177,17 +183,19 @@ def parse_json(value: object) -> JSONValue:
 )
 
 
-def _missing_keys(required: frozenset[str], doc: Mapping[str, object]) -> list[ValidationProblem]:
+def _missing_keys(
+    required: frozenset[str], doc: Mapping[str, object]
+) -> tuple[ValidationProblem, ...]:
     """One `missing_key` problem per required key absent from `doc`."""
-    return [
+    return tuple(
         ValidationProblem((key,), "missing required key", "missing_key")
         for key in sorted(required - doc.keys())
-    ]
+    )
 
 
 def _unexpected_keys(
     allowed: frozenset[str], doc: Mapping[object, object]
-) -> list[ValidationProblem]:
+) -> tuple[ValidationProblem, ...]:
     """One problem per member outside a closed document's declared shape."""
     problems: list[ValidationProblem] = []
     for key in doc:
@@ -199,18 +207,18 @@ def _unexpected_keys(
             problems.append(
                 ValidationProblem((key,), "unexpected document member", "invalid_value")
             )
-    return problems
+    return tuple(problems)
 
 
 def _check_literal(
     doc: Mapping[str, object], key: str, expected: object
-) -> list[ValidationProblem]:
+) -> tuple[ValidationProblem, ...]:
     """One `invalid_value` problem if `doc[key]` is present but not `expected`."""
     if key in doc and (type(doc[key]) is not type(expected) or doc[key] != expected):
-        return [
-            ValidationProblem((key,), f"expected {expected!r}, got {doc[key]!r}", "invalid_value")
-        ]
-    return []
+        return (
+            ValidationProblem((key,), f"expected {expected!r}, got {doc[key]!r}", "invalid_value"),
+        )
+    return ()
 
 
 def _validate_extension_fields_v3(
@@ -218,7 +226,7 @@ def _validate_extension_fields_v3(
     standard_keys: frozenset[str],
     *,
     additional_reserved_keys: frozenset[str] = frozenset(),
-) -> list[ValidationProblem]:
+) -> tuple[ValidationProblem, ...]:
     """Validate v3 top-level key types and unknown-field JSON payloads."""
     problems: list[ValidationProblem] = []
     reserved_keys = standard_keys | additional_reserved_keys
@@ -231,27 +239,27 @@ def _validate_extension_fields_v3(
         if key in reserved_keys:
             continue
         problems.extend(_prefix(key, validate_json(value)))
-    return problems
+    return tuple(problems)
 
 
 def validate_metadata_field_v3(
     value: object, *, allow_must_understand_false: bool = True
-) -> list[ValidationProblem]:
+) -> tuple[ValidationProblem, ...]:
     """Return every reason `value` is not a v3 metadata field.
 
     A metadata field is a bare name string or a mapping containing `name` and
     optional `configuration` and `must_understand` members.
     """
     if isinstance(value, str):
-        return []
+        return ()
     if not isinstance(value, Mapping):
-        return [
+        return (
             ValidationProblem(
                 (),
                 "expected a metadata field (string or extension object)",
                 "invalid_type",
-            )
-        ]
+            ),
+        )
     field = cast("Mapping[object, object]", value)
     problems: list[ValidationProblem] = []
     allowed_keys = frozenset({"name", "configuration", "must_understand"})
@@ -293,7 +301,7 @@ def validate_metadata_field_v3(
                     "invalid_value",
                 )
             )
-    return problems
+    return tuple(problems)
 
 
 def is_metadata_field_v3(value: object) -> TypeIs[ZarrV3MetadataFieldJSON]:
@@ -310,7 +318,7 @@ def parse_metadata_field_v3(value: object) -> ZarrV3MetadataFieldJSON:
     """Return `value` narrowed to `ZarrV3MetadataFieldJSON`, or raise `MetadataValidationError`."""
     normalized = arrays_to_tuples(value)
     problems = validate_metadata_field_v3(normalized)
-    if problems:
+    if len(problems) != 0:
         raise MetadataValidationError(problems)
     return cast(ZarrV3MetadataFieldJSON, normalized)
 
@@ -331,19 +339,19 @@ def _is_int_sequence(value: object) -> bool:
     )
 
 
-def _validate_dim_sequence(doc: Mapping[str, object], key: str) -> list[ValidationProblem]:
+def _validate_dim_sequence(doc: Mapping[str, object], key: str) -> tuple[ValidationProblem, ...]:
     """Validate a dimension sequence (`shape` / `chunks`) if present in `doc`.
 
     Dimension lengths are non-negative integers.
     """
     if key not in doc:
-        return []
+        return ()
     value = doc[key]
     if not _is_int_sequence(value):
-        return [ValidationProblem((key,), "expected a sequence of int", "invalid_type")]
+        return (ValidationProblem((key,), "expected a sequence of int", "invalid_type"),)
     if any(item < 0 for item in cast("Sequence[int]", value)):
-        return [ValidationProblem((key,), "expected non-negative integers", "invalid_value")]
-    return []
+        return (ValidationProblem((key,), "expected non-negative integers", "invalid_value"),)
+    return ()
 
 
 def _is_dtype_v2(value: object) -> bool:
@@ -447,18 +455,18 @@ def _is_codec_v2(value: object) -> bool:
     )
 
 
-def _validate_codec_v2(value: object) -> list[ValidationProblem]:
+def _validate_codec_v2(value: object) -> tuple[ValidationProblem, ...]:
     """Validate a v2 codec's required shape and JSON-valued configuration."""
     if not _is_codec_v2(value):
-        return [
+        return (
             ValidationProblem(
                 (), "expected a codec configuration with a string 'id'", "invalid_type"
-            )
-        ]
+            ),
+        )
     return validate_json(value)
 
 
-def _validate_attributes(value: object) -> list[ValidationProblem]:
+def _validate_attributes(value: object) -> tuple[ValidationProblem, ...]:
     """Validate an `attributes` value: a mapping with string keys.
 
     Returns a problem at `("attributes",)` if it is not, else `[]`. Shared by the
@@ -470,27 +478,27 @@ def _validate_attributes(value: object) -> list[ValidationProblem]:
     if not isinstance(value, Mapping) or not all(
         isinstance(k, str) for k in cast("Mapping[object, object]", value)
     ):
-        return [
+        return (
             ValidationProblem(
                 ("attributes",), "expected a mapping with string keys", "invalid_type"
-            )
-        ]
+            ),
+        )
     problems: list[ValidationProblem] = []
     for key, item in cast("Mapping[str, object]", value).items():
         problems.extend(_prefix("attributes", _prefix(key, validate_json(item))))
-    return problems
+    return tuple(problems)
 
 
-def validate_array_metadata_v3(value: object) -> list[ValidationProblem]:
+def validate_array_metadata_v3(value: object) -> tuple[ValidationProblem, ...]:
     """Return every reason `value` is not a structurally-valid v3 array doc.
 
     Checks structure, not domain validity. Unknown top-level keys are allowed
     (they map to `extra_fields`).
     """
     if not isinstance(value, Mapping):
-        return [ValidationProblem((), "expected a mapping", "invalid_type")]
+        return (ValidationProblem((), "expected a mapping", "invalid_type"),)
     doc = cast("Mapping[str, object]", value)
-    problems: list[ValidationProblem] = _missing_keys(ARRAY_METADATA_REQUIRED_KEYS_V3, doc)
+    problems: list[ValidationProblem] = list(_missing_keys(ARRAY_METADATA_REQUIRED_KEYS_V3, doc))
     problems.extend(
         _validate_extension_fields_v3(
             cast("Mapping[object, object]", value), ARRAY_METADATA_STANDARD_KEYS_V3
@@ -552,7 +560,7 @@ def validate_array_metadata_v3(value: object) -> list[ValidationProblem]:
                     "invalid_value",
                 )
             )
-    return problems
+    return tuple(problems)
 
 
 def is_array_metadata_v3(value: object) -> TypeIs[ZarrV3ArrayMetadataJSON]:
@@ -568,12 +576,12 @@ def parse_array_metadata_v3(value: object) -> ZarrV3ArrayMetadataJSON:
     """Return `value` as `ZarrV3ArrayMetadataJSON`, or raise `MetadataValidationError`."""
     normalized = arrays_to_tuples(value)
     problems = validate_array_metadata_v3(normalized)
-    if problems:
+    if len(problems) != 0:
         raise MetadataValidationError(problems)
     return cast("ZarrV3ArrayMetadataJSON", normalized)
 
 
-def validate_array_metadata_v2(value: object) -> list[ValidationProblem]:
+def validate_array_metadata_v2(value: object) -> tuple[ValidationProblem, ...]:
     """Return every reason `value` is not a structurally-valid v2 array doc.
 
     Checks structure, not domain validity: `dtype` must be a string or field
@@ -582,20 +590,22 @@ def validate_array_metadata_v2(value: object) -> list[ValidationProblem]:
     codec configurations (mappings with a string `id`).
     """
     if not isinstance(value, Mapping):
-        return [ValidationProblem((), "expected a mapping", "invalid_type")]
+        return (ValidationProblem((), "expected a mapping", "invalid_type"),)
     doc = cast("Mapping[str, object]", value)
-    problems: list[ValidationProblem] = _missing_keys(ARRAY_METADATA_REQUIRED_KEYS_V2, doc)
-    problems.extend(
-        _unexpected_keys(ARRAY_METADATA_STANDARD_KEYS_V2, cast("Mapping[object, object]", value))
-    )
+    # Unlike the group document ("Other keys MUST NOT be present",
+    # https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L313), the v2 array document is open: other keys "SHOULD NOT be
+    # present within the metadata object and SHOULD be ignored by
+    # implementations" (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L91-L92), so members outside
+    # ARRAY_METADATA_STANDARD_KEYS_V2 are not problems.
+    problems: list[ValidationProblem] = list(_missing_keys(ARRAY_METADATA_REQUIRED_KEYS_V2, doc))
     problems.extend(_check_literal(doc, "zarr_format", 2))
     shape_problems = _validate_dim_sequence(doc, "shape")
     chunks_problems = _validate_dim_sequence(doc, "chunks")
     problems.extend(shape_problems)
     problems.extend(chunks_problems)
     if (
-        not shape_problems
-        and not chunks_problems
+        len(shape_problems) == 0
+        and len(chunks_problems) == 0
         and _is_int_sequence(doc.get("shape"))
         and _is_int_sequence(doc.get("chunks"))
     ):
@@ -642,10 +652,8 @@ def validate_array_metadata_v2(value: object) -> list[ValidationProblem]:
                 )
             )
         elif filters is not None:
-            if len(cast("Sequence[object]", filters)) == 0:
-                problems.append(
-                    ValidationProblem(("filters",), "expected at least one filter", "invalid_value")
-                )
+            # "A list of JSON objects providing codec configurations, or
+            # null" (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L76-L79): an empty list is a list.
             for index, item in enumerate(cast("Sequence[object]", filters)):
                 problems.extend(_prefix("filters", _prefix(index, validate_json(item))))
     if "dimension_separator" in doc and doc["dimension_separator"] not in (".", "/"):
@@ -660,7 +668,7 @@ def validate_array_metadata_v2(value: object) -> list[ValidationProblem]:
         problems.extend(_prefix("fill_value", validate_json(doc["fill_value"])))
     if "attributes" in doc:
         problems.extend(_validate_attributes(doc["attributes"]))
-    return problems
+    return tuple(problems)
 
 
 def is_array_metadata_v2(value: object) -> TypeIs[ZarrV2ArrayMetadataJSON]:
@@ -676,12 +684,12 @@ def parse_array_metadata_v2(value: object) -> ZarrV2ArrayMetadataJSON:
     """Return `value` as `ZarrV2ArrayMetadataJSON`, or raise `MetadataValidationError`."""
     normalized = arrays_to_tuples(value)
     problems = validate_array_metadata_v2(normalized)
-    if problems:
+    if len(problems) != 0:
         raise MetadataValidationError(problems)
     return cast("ZarrV2ArrayMetadataJSON", normalized)
 
 
-def validate_consolidated_metadata_v3(value: object) -> list[ValidationProblem]:
+def validate_consolidated_metadata_v3(value: object) -> tuple[ValidationProblem, ...]:
     """Return every reason `value` is not a valid inline consolidated envelope.
 
     Locs are value-relative (the caller prefixes with `consolidated_metadata`
@@ -690,7 +698,7 @@ def validate_consolidated_metadata_v3(value: object) -> list[ValidationProblem]:
     `ZarrV3ConsolidatedMetadata.from_json` accepts.
     """
     if not isinstance(value, Mapping):
-        return [ValidationProblem((), "expected a mapping", "invalid_type")]
+        return (ValidationProblem((), "expected a mapping", "invalid_type"),)
     env = cast("Mapping[str, object]", value)
     problems: list[ValidationProblem] = [
         ValidationProblem((key,), "missing required key", "missing_key")
@@ -737,10 +745,10 @@ def validate_consolidated_metadata_v3(value: object) -> list[ValidationProblem]:
                             "invalid_value",
                         )
                     )
-    return problems
+    return tuple(problems)
 
 
-def validate_group_metadata_v3(value: object) -> list[ValidationProblem]:
+def validate_group_metadata_v3(value: object) -> tuple[ValidationProblem, ...]:
     """Return every reason `value` is not a structurally-valid v3 group doc.
 
     Checks structure, not domain validity. Unknown top-level keys are allowed
@@ -749,9 +757,9 @@ def validate_group_metadata_v3(value: object) -> list[ValidationProblem]:
     `validate_consolidated_metadata_v3`.
     """
     if not isinstance(value, Mapping):
-        return [ValidationProblem((), "expected a mapping", "invalid_type")]
+        return (ValidationProblem((), "expected a mapping", "invalid_type"),)
     doc = cast("Mapping[str, object]", value)
-    problems: list[ValidationProblem] = _missing_keys(GROUP_METADATA_REQUIRED_KEYS_V3, doc)
+    problems: list[ValidationProblem] = list(_missing_keys(GROUP_METADATA_REQUIRED_KEYS_V3, doc))
     problems.extend(
         _validate_extension_fields_v3(
             cast("Mapping[object, object]", value),
@@ -773,7 +781,7 @@ def validate_group_metadata_v3(value: object) -> list[ValidationProblem]:
                 validate_consolidated_metadata_v3(doc["consolidated_metadata"]),
             )
         )
-    return problems
+    return tuple(problems)
 
 
 def is_group_metadata_v3(value: object) -> TypeIs[ZarrV3GroupMetadataJSON]:
@@ -785,28 +793,28 @@ def parse_group_metadata_v3(value: object) -> ZarrV3GroupMetadataJSON:
     """Return `value` narrowed to `ZarrV3GroupMetadataJSON`, or raise `MetadataValidationError`."""
     normalized = arrays_to_tuples(value)
     problems = validate_group_metadata_v3(normalized)
-    if problems:
+    if len(problems) != 0:
         raise MetadataValidationError(problems)
     return cast(ZarrV3GroupMetadataJSON, normalized)
 
 
-def validate_group_metadata_v2(value: object) -> list[ValidationProblem]:
+def validate_group_metadata_v2(value: object) -> tuple[ValidationProblem, ...]:
     """Return every reason `value` is not a structurally-valid v2 group doc.
 
     Validates the in-memory merged form: the `.zgroup` fields plus an
     optional `attributes` mapping folded in from `.zattrs`.
     """
     if not isinstance(value, Mapping):
-        return [ValidationProblem((), "expected a mapping", "invalid_type")]
+        return (ValidationProblem((), "expected a mapping", "invalid_type"),)
     doc = cast("Mapping[str, object]", value)
-    problems: list[ValidationProblem] = _missing_keys(GROUP_METADATA_REQUIRED_KEYS_V2, doc)
+    problems: list[ValidationProblem] = list(_missing_keys(GROUP_METADATA_REQUIRED_KEYS_V2, doc))
     problems.extend(
         _unexpected_keys(GROUP_METADATA_STANDARD_KEYS_V2, cast("Mapping[object, object]", value))
     )
     problems.extend(_check_literal(doc, "zarr_format", 2))
     if "attributes" in doc:
         problems.extend(_validate_attributes(doc["attributes"]))
-    return problems
+    return tuple(problems)
 
 
 def is_group_metadata_v2(value: object) -> TypeIs[ZarrV2GroupMetadataJSON]:
@@ -818,7 +826,7 @@ def parse_group_metadata_v2(value: object) -> ZarrV2GroupMetadataJSON:
     """Return `value` narrowed to `ZarrV2GroupMetadataJSON`, or raise `MetadataValidationError`."""
     normalized = arrays_to_tuples(value)
     problems = validate_group_metadata_v2(normalized)
-    if problems:
+    if len(problems) != 0:
         raise MetadataValidationError(problems)
     return cast(ZarrV2GroupMetadataJSON, normalized)
 
@@ -828,9 +836,13 @@ def _reject_json_constant(constant: str) -> NoReturn:
     raise ValueError(f"non-standard JSON constant {constant!r}")
 
 
-def load_store_json(mapping: Mapping[str, bytes], key: str) -> Any:
+def load_store_json(mapping: Mapping[str, bytes], key: str) -> object:
     """Decode the JSON document stored at `key` in `mapping`.
 
+    Returns `object`, not `Any`: what a store holds is unknown until a
+    validator says otherwise, and `Any` would let unchecked values flow
+    into typed positions silently. Narrow the result with a `parse_*`.
+
     Every ingestion failure surfaces as `MetadataValidationError`: a missing
     store key is a `missing_key` problem and undecodable bytes are an
     `invalid_json` problem, rather than leaking `KeyError` /
diff --git a/packages/zarr-metadata/src/zarr_metadata/pydantic.py b/packages/zarr-metadata/src/zarr_metadata/pydantic.py
index 8584efa570..5b0c9e5b57 100644
--- a/packages/zarr-metadata/src/zarr_metadata/pydantic.py
+++ b/packages/zarr-metadata/src/zarr_metadata/pydantic.py
@@ -54,17 +54,6 @@ class ArrayManifest(BaseModel):
 from zarr_metadata._pydantic_schema import (
     ZarrV3MetadataFieldJSON as _ZarrV3MetadataFieldSchema,
 )
-from zarr_metadata.v2.array import ZarrV2ArrayMetadataJSON as _ZarrV2ArrayMetadataJSON
-from zarr_metadata.v2.consolidated import (
-    ZarrV2ConsolidatedMetadataJSON as _ZarrV2ConsolidatedMetadataJSON,
-)
-from zarr_metadata.v2.group import ZarrV2GroupMetadataJSON as _ZarrV2GroupMetadataJSON
-from zarr_metadata.v3._common import ZarrV3MetadataFieldJSON as _ZarrV3MetadataFieldJSON
-from zarr_metadata.v3.array import ZarrV3ArrayMetadataJSON as _ZarrV3ArrayMetadataJSON
-from zarr_metadata.v3.consolidated import (
-    ZarrV3ConsolidatedMetadataJSON as _ZarrV3ConsolidatedMetadataJSON,
-)
-from zarr_metadata.v3.group import ZarrV3GroupMetadataJSON as _ZarrV3GroupMetadataJSON
 
 if TYPE_CHECKING:
     from collections.abc import Callable
@@ -89,7 +78,7 @@ def coerce(value: object) -> _M:
         _coerce_to(_model.ZarrV3ArrayMetadata, _model.ZarrV3ArrayMetadata.from_json),
         json_schema_input_type=_ZarrV3ArrayMetadataSchema,
     ),
-    PlainSerializer(_model.ZarrV3ArrayMetadata.to_json, return_type=_ZarrV3ArrayMetadataJSON),
+    PlainSerializer(_model.ZarrV3ArrayMetadata.to_json, return_type=_ZarrV3ArrayMetadataSchema),
 ]
 """Field type for a v3 array metadata document (`zarr.json` content)."""
 
@@ -99,7 +88,7 @@ def coerce(value: object) -> _M:
         _coerce_to(_model.ZarrV2ArrayMetadata, _model.ZarrV2ArrayMetadata.from_json),
         json_schema_input_type=_ZarrV2ArrayMetadataSchema,
     ),
-    PlainSerializer(_model.ZarrV2ArrayMetadata.to_json, return_type=_ZarrV2ArrayMetadataJSON),
+    PlainSerializer(_model.ZarrV2ArrayMetadata.to_json, return_type=_ZarrV2ArrayMetadataSchema),
 ]
 """Field type for a v2 array metadata document (merged `.zarray` + `.zattrs` form)."""
 
@@ -109,7 +98,7 @@ def coerce(value: object) -> _M:
         _coerce_to(_model.ZarrV3GroupMetadata, _model.ZarrV3GroupMetadata.from_json),
         json_schema_input_type=_ZarrV3GroupMetadataSchema,
     ),
-    PlainSerializer(_model.ZarrV3GroupMetadata.to_json, return_type=_ZarrV3GroupMetadataJSON),
+    PlainSerializer(_model.ZarrV3GroupMetadata.to_json, return_type=_ZarrV3GroupMetadataSchema),
 ]
 """Field type for a v3 group metadata document (`zarr.json` content)."""
 
@@ -119,7 +108,7 @@ def coerce(value: object) -> _M:
         _coerce_to(_model.ZarrV2GroupMetadata, _model.ZarrV2GroupMetadata.from_json),
         json_schema_input_type=_ZarrV2GroupMetadataSchema,
     ),
-    PlainSerializer(_model.ZarrV2GroupMetadata.to_json, return_type=_ZarrV2GroupMetadataJSON),
+    PlainSerializer(_model.ZarrV2GroupMetadata.to_json, return_type=_ZarrV2GroupMetadataSchema),
 ]
 """Field type for a v2 group metadata document (merged `.zgroup` + `.zattrs` form)."""
 
@@ -134,7 +123,7 @@ def coerce(value: object) -> _M:
     ),
     PlainSerializer(
         _model.ZarrV3ConsolidatedMetadata.to_json,
-        return_type=_ZarrV3ConsolidatedMetadataJSON,
+        return_type=_ZarrV3ConsolidatedMetadataSchema,
     ),
 ]
 """Field type for v3 inline consolidated metadata."""
@@ -150,7 +139,7 @@ def coerce(value: object) -> _M:
     ),
     PlainSerializer(
         _model.ZarrV2ConsolidatedMetadata.to_json,
-        return_type=_ZarrV2ConsolidatedMetadataJSON,
+        return_type=_ZarrV2ConsolidatedMetadataSchema,
     ),
 ]
 """Field type for a v2 `.zmetadata` document."""
@@ -161,7 +150,7 @@ def coerce(value: object) -> _M:
         _coerce_to(_model.ZarrV3NamedConfig, _model.ZarrV3NamedConfig.from_json),
         json_schema_input_type=_ZarrV3MetadataFieldSchema,
     ),
-    PlainSerializer(_model.ZarrV3NamedConfig.to_json, return_type=_ZarrV3MetadataFieldJSON),
+    PlainSerializer(_model.ZarrV3NamedConfig.to_json, return_type=_ZarrV3MetadataFieldSchema),
 ]
 """Field type for one normalized v3 metadata extension envelope."""
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/v2/array.py b/packages/zarr-metadata/src/zarr_metadata/v2/array.py
index e026e5c655..7e4f87be7c 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v2/array.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v2/array.py
@@ -81,8 +81,8 @@ class ZarrV2ArrayMetadataJSON(TypedDict):
     """
     Zarr v2 array metadata document, in-memory merged form.
 
-    Models the union of `.zarray` (the spec-defined fields) and `.zattrs`
-    (user attributes). On disk, attributes live in a sibling `.zattrs` file
+    Models the union of `.zarray` (the spec-defined fields, https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L51-L92)
+    and `.zattrs` (user attributes, https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L323-L330). On disk, attributes live in a sibling `.zattrs` file
     and are not part of `.zarray`; this type folds them in as the
     `attributes` field so a single TypedDict represents the complete
     in-memory state of a v2 array node. Consumers that read or write a
@@ -126,8 +126,10 @@ class ZarrV2ArrayMetadataJSONPartial(TypedDict, total=False):
     `tests/test_partial_equivalence.py` passes without special-casing those
     fields (PEP 655 explicitly permits `NotRequired` inside `total=False`).
 
-    Note: v2 array metadata has no `extra_items` setting (the v2 spec has no
-    extension-field concept), so this partial inherits the same closed shape.
+    Note: v2 array metadata has no `extra_items` setting: the v2 spec has no
+    extension-field concept, and other `.zarray` keys "SHOULD be ignored by
+    implementations" (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L91-L92), so nothing beyond the spec-defined
+    fields is modeled.
 
     Drift between this type and `ZarrV2ArrayMetadataJSON` is prevented by
     `tests/test_partial_equivalence.py`.
diff --git a/packages/zarr-metadata/src/zarr_metadata/v2/attributes.py b/packages/zarr-metadata/src/zarr_metadata/v2/attributes.py
index 68785d1660..74e9fe938f 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v2/attributes.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v2/attributes.py
@@ -15,6 +15,7 @@
 Spec-defined keys for arrays / groups live in sibling `.zarray` / `.zgroup`
 files (modeled by `ZarrV2ZArrayJSON` / `ZarrV2ZGroupJSON`). This type does not
 constrain the keys or values of the attributes mapping.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L323-L330
 """
 
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/v2/consolidated.py b/packages/zarr-metadata/src/zarr_metadata/v2/consolidated.py
index 999c9131da..a6b8e4a58e 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v2/consolidated.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v2/consolidated.py
@@ -34,7 +34,7 @@ class ZarrV2ConsolidatedMetadataJSON(TypedDict):
     `key.endswith(".zarray")` etc.
     """
 
-    zarr_consolidated_format: int
+    zarr_consolidated_format: Literal[1]
     metadata: Mapping[str, ZarrV2ZArrayJSON | ZarrV2ZGroupJSON | ZarrV2ZAttrsJSON]
 
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/v2/group.py b/packages/zarr-metadata/src/zarr_metadata/v2/group.py
index 34d72742c2..3a645dc29b 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v2/group.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v2/group.py
@@ -16,9 +16,10 @@ class ZarrV2ZGroupJSON(TypedDict):
     On-disk `.zgroup` file content.
 
     Strict shape of the JSON document persisted at `<path>/.zgroup` for
-    a v2 group. The spec defines exactly one field. User attributes live
-    in a sibling `.zattrs` file and are NOT part of this type; see
-    `ZarrV2ZAttrsJSON`.
+    a v2 group. The spec defines exactly one field and forbids others. User
+    attributes live in a sibling `.zattrs` file and are NOT part of this
+    type; see `ZarrV2ZAttrsJSON`.
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L306-L313
 
     See https://zarr-specs.readthedocs.io/en/latest/v2/v2.0.html
     """
@@ -30,8 +31,8 @@ class ZarrV2GroupMetadataJSON(TypedDict):
     """
     Zarr v2 group metadata document, in-memory merged form.
 
-    Models the union of `.zgroup` (the spec-defined `zarr_format` field)
-    and `.zattrs` (user attributes). On disk these are persisted as two
+    Models the union of `.zgroup` (the spec-defined `zarr_format` field,
+    https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L306-L313) and `.zattrs` (user attributes, https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L323-L330). On disk these are persisted as two
     separate files; this type folds them so a single TypedDict represents
     the complete in-memory state of a v2 group node. Consumers that read
     or write the real on-disk files should use `ZarrV2ZGroupJSON` (strict
@@ -64,7 +65,8 @@ class ZarrV2GroupMetadataJSONPartial(TypedDict, total=False):
     `total=False`).
 
     Note: v2 group metadata has no `extra_items` setting (the v2 spec has no
-    extension-field concept), so this partial inherits the same closed shape.
+    extension-field concept, and `.zgroup` forbids other keys outright:
+    https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L313), so this partial inherits the same closed shape.
 
     Drift between this type and `ZarrV2GroupMetadataJSON` is prevented by
     `tests/test_partial_equivalence.py`.
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/rectilinear.py b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/rectilinear.py
index e3551e3c72..78c38b702a 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/rectilinear.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/rectilinear.py
@@ -1,10 +1,10 @@
 """
 Rectilinear chunk grid (zarr-extensions).
 
-See https://github.com/zarr-developers/zarr-extensions/tree/main/chunk-grids/rectilinear
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/chunk-grids/rectilinear/README.md
 """
 
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import TypedDict
 
@@ -23,18 +23,19 @@
 """
 
 
-class RectilinearChunkGridConfiguration(TypedDict):
+class RectilinearChunkGridConfiguration(TypedDict, closed=True):
     """Configuration for the rectilinear chunk grid."""
 
     kind: Literal["inline"]
     chunk_shapes: tuple[RectilinearDimSpec, ...]
 
 
-class RectilinearChunkGridObject(TypedDict):
+class RectilinearChunkGridObject(TypedDict, closed=True):
     """Rectilinear chunk grid metadata in object form."""
 
     name: RectilinearChunkGridName
     configuration: RectilinearChunkGridConfiguration
+    must_understand: NotRequired[bool]
 
 
 RectilinearChunkGridMetadata = RectilinearChunkGridObject
@@ -42,6 +43,8 @@ class RectilinearChunkGridObject(TypedDict):
 
 `kind` and `chunk_shapes` are required, so only the object form is valid;
 the short-hand-name form is not permitted by the spec for this grid.
+  https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/chunk-grids/rectilinear/README.md#L59-L62
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564
 """
 
 __all__ = [
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/regular.py b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/regular.py
index 2f7a089934..bdcd9e06c5 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/regular.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_grid/regular.py
@@ -4,7 +4,7 @@
 See https://zarr-specs.readthedocs.io/en/latest/v3/core/index.html#regular-grids
 """
 
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import TypedDict
 
@@ -15,17 +15,18 @@
 """Literal type of the `name` field of the regular chunk grid."""
 
 
-class RegularChunkGridConfiguration(TypedDict):
+class RegularChunkGridConfiguration(TypedDict, closed=True):
     """Configuration for the regular chunk grid."""
 
     chunk_shape: tuple[int, ...]
 
 
-class RegularChunkGridObject(TypedDict):
+class RegularChunkGridObject(TypedDict, closed=True):
     """Regular chunk grid metadata in object form."""
 
     name: RegularChunkGridName
     configuration: RegularChunkGridConfiguration
+    must_understand: NotRequired[bool]
 
 
 RegularChunkGridMetadata = RegularChunkGridObject
@@ -33,6 +34,8 @@ class RegularChunkGridObject(TypedDict):
 
 `chunk_shape` is required and has no default, so only the object form is
 valid; the short-hand-name form is not permitted by the spec for this grid.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L528-L537 ("must be an object with the names name and configuration")
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564
 """
 
 __all__ = [
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/__init__.py b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/__init__.py
index b6774efbe3..fa4a2aaf84 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/__init__.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/__init__.py
@@ -6,7 +6,9 @@
 - `default` -- v3 default encoding (`/`-separated)
 - `v2`      -- v2-compatibility encoding (`.`-separated by default)
 
-Both are defined by the v3 core spec.
+Both are defined by the v3 core spec:
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/chunk-key-encodings/default/index.rst
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/chunk-key-encodings/v2/index.rst
 
 The `<X>ChunkKeyEncodingMetadata` aliases re-exported here are the canonical
 type for each encoding's permitted JSON shapes. For the underlying
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/default.py b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/default.py
index c783861b34..10a7c0cb55 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/default.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/default.py
@@ -27,20 +27,22 @@
 """Tuple of permitted values for the `separator` field of the default chunk key encoding."""
 
 
-class DefaultChunkKeyEncodingConfiguration(TypedDict):
+class DefaultChunkKeyEncodingConfiguration(TypedDict, closed=True):
     """Configuration for the default chunk key encoding.
 
     `separator` is optional and defaults to `"/"` per spec.
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/chunk-key-encodings/default/index.rst#L27-L29
     """
 
     separator: NotRequired[DefaultChunkKeyEncodingSeparator]
 
 
-class DefaultChunkKeyEncodingObject(TypedDict):
+class DefaultChunkKeyEncodingObject(TypedDict, closed=True):
     """Default chunk key encoding metadata in object form."""
 
     name: DefaultChunkKeyEncodingName
     configuration: NotRequired[DefaultChunkKeyEncodingConfiguration]
+    must_understand: NotRequired[bool]
 
 
 DefaultChunkKeyEncodingMetadata = DefaultChunkKeyEncodingObject | DefaultChunkKeyEncodingName
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/v2.py b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/v2.py
index e2783d296d..63cdf26783 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/v2.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/chunk_key_encoding/v2.py
@@ -33,20 +33,22 @@
 """Tuple of permitted values for the `separator` field of the v2 chunk key encoding."""
 
 
-class V2ChunkKeyEncodingConfiguration(TypedDict):
+class V2ChunkKeyEncodingConfiguration(TypedDict, closed=True):
     """Configuration for the v2 chunk key encoding.
 
     `separator` is optional and defaults to `"."` per spec.
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/chunk-key-encodings/v2/index.rst#L27-L29
     """
 
     separator: NotRequired[V2ChunkKeyEncodingSeparator]
 
 
-class V2ChunkKeyEncodingObject(TypedDict):
+class V2ChunkKeyEncodingObject(TypedDict, closed=True):
     """v2-compatibility chunk key encoding metadata in object form."""
 
     name: V2ChunkKeyEncodingName
     configuration: NotRequired[V2ChunkKeyEncodingConfiguration]
+    must_understand: NotRequired[bool]
 
 
 V2ChunkKeyEncodingMetadata = V2ChunkKeyEncodingObject | V2ChunkKeyEncodingName
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/blosc.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/blosc.py
index 5a986c8260..3387a7c285 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/blosc.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/blosc.py
@@ -27,7 +27,7 @@
 """Tuple of permitted values for the `cname` field of the `blosc` codec."""
 
 
-class BloscCodecConfiguration(TypedDict):
+class BloscCodecConfiguration(TypedDict, closed=True):
     """Configuration for the Zarr v3 `blosc` codec."""
 
     cname: BloscCName
@@ -37,11 +37,12 @@ class BloscCodecConfiguration(TypedDict):
     typesize: NotRequired[int]
 
 
-class BloscCodecObject(TypedDict):
+class BloscCodecObject(TypedDict, closed=True):
     """`blosc` codec metadata in object form."""
 
     name: BloscCodecName
     configuration: BloscCodecConfiguration
+    must_understand: NotRequired[bool]
 
 
 BloscCodecMetadata = BloscCodecObject
@@ -50,6 +51,8 @@ class BloscCodecObject(TypedDict):
 The configuration has multiple required keys (`cname`, `clevel`, `shuffle`,
 `blocksize`), so only the object form is valid; the short-hand-name form
 is not permitted by the spec for this codec.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/blosc/index.rst#L57-L98 (configuration parameters)
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564 (short-hand names only "if no configuration metadata is required")
 """
 
 __all__ = [
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/bytes.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/bytes.py
index 04e746f898..4feb6b8c1c 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/bytes.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/bytes.py
@@ -21,7 +21,7 @@
 """Tuple of permitted values for the `endian` field of the `bytes` codec."""
 
 
-class BytesCodecConfiguration(TypedDict):
+class BytesCodecConfiguration(TypedDict, closed=True):
     """
     Configuration for the Zarr v3 `bytes` codec.
 
@@ -31,7 +31,7 @@ class BytesCodecConfiguration(TypedDict):
     endian: NotRequired[Endianness]
 
 
-class BytesCodecObject(TypedDict):
+class BytesCodecObject(TypedDict, closed=True):
     """`bytes` codec metadata in object form.
 
     `configuration` is itself optional — when no configuration fields are
@@ -42,6 +42,7 @@ class BytesCodecObject(TypedDict):
 
     name: BytesCodecName
     configuration: NotRequired[BytesCodecConfiguration]
+    must_understand: NotRequired[bool]
 
 
 BytesCodecMetadata = BytesCodecObject | BytesCodecName
@@ -51,6 +52,8 @@ class BytesCodecObject(TypedDict):
 at runtime based on data type), so the spec's short-hand-name form is
 permitted in addition to the object form, and the object form may itself
 omit `configuration` entirely.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/bytes/index.rst#L64-L69 ("endian: Required for data types for which endianness is applicable")
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564
 """
 
 __all__ = [
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/cast_value.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/cast_value.py
index 96c39e5916..656a509ed7 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/cast_value.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/cast_value.py
@@ -1,7 +1,7 @@
 """
 Cast-value codec types.
 
-See https://github.com/zarr-developers/zarr-extensions/tree/main/codecs/cast_value
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/codecs/cast_value/README.md
 """
 
 from typing import Final, Literal, NotRequired
@@ -55,14 +55,14 @@
 """
 
 
-class ScalarMap(TypedDict):
+class ScalarMap(TypedDict, closed=True):
     """Optional encode/decode scalar overrides for the cast_value codec."""
 
     encode: NotRequired[tuple[ScalarMapEntry, ...]]
     decode: NotRequired[tuple[ScalarMapEntry, ...]]
 
 
-class CastValueCodecConfiguration(TypedDict):
+class CastValueCodecConfiguration(TypedDict, closed=True):
     """
     Configuration for the Zarr v3 `cast_value` codec.
 
@@ -77,11 +77,12 @@ class CastValueCodecConfiguration(TypedDict):
     scalar_map: NotRequired[ScalarMap]
 
 
-class CastValueCodecObject(TypedDict):
+class CastValueCodecObject(TypedDict, closed=True):
     """`cast_value` codec metadata in object form."""
 
     name: CastValueCodecName
     configuration: CastValueCodecConfiguration
+    must_understand: NotRequired[bool]
 
 
 CastValueCodecMetadata = CastValueCodecObject
@@ -89,6 +90,8 @@ class CastValueCodecObject(TypedDict):
 
 `configuration.data_type` is required, so only the object form is valid;
 the short-hand-name form is not permitted by the spec for this codec.
+  https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/codecs/cast_value/README.md#L33-L36 and #L46-L48 (required fields)
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564 (short-hand names only "if no configuration metadata is required")
 """
 
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/crc32c.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/crc32c.py
index 6b9b46c43d..05661d0b59 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/crc32c.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/crc32c.py
@@ -22,15 +22,17 @@ class Empty(TypedDict, closed=True):
     """An empty mapping"""
 
 
-class Crc32cCodecObject(TypedDict):
+class Crc32cCodecObject(TypedDict, closed=True):
     """`crc32c` codec metadata in object form.
 
     Per spec the codec has no configuration fields. `configuration` is
     optional and, if present, should be an empty mapping.
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/crc32c/index.rst#L63-L66
     """
 
     name: Crc32cCodecName
     configuration: NotRequired[Empty]
+    must_understand: NotRequired[bool]
 
 
 Crc32cCodecMetadata = Crc32cCodecObject | Crc32cCodecName
@@ -39,6 +41,7 @@ class Crc32cCodecObject(TypedDict):
 The spec's Extension definition allows extensions with no required
 configuration to be encoded as a bare short-hand name. CRC32C has no
 configuration, so both forms are valid.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564
 """
 
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/gzip.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/gzip.py
index 3b9936f8cd..d516088f99 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/gzip.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/gzip.py
@@ -4,7 +4,7 @@
 See https://zarr-specs.readthedocs.io/en/latest/v3/codecs/gzip/index.html
 """
 
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import TypedDict
 
@@ -15,7 +15,7 @@
 """Literal type of the `name` field of the `gzip` codec."""
 
 
-class GzipCodecConfiguration(TypedDict):
+class GzipCodecConfiguration(TypedDict, closed=True):
     """
     Configuration for the Zarr v3 `gzip` codec.
 
@@ -26,16 +26,18 @@ class GzipCodecConfiguration(TypedDict):
     is required for the metadata to fulfill its reproducibility role,
     even though the spec text does not mark it required with RFC 2119
     keywords.
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/gzip/index.rst#L57-L66
     """
 
     level: int
 
 
-class GzipCodecObject(TypedDict):
+class GzipCodecObject(TypedDict, closed=True):
     """`gzip` codec metadata in object form."""
 
     name: GzipCodecName
     configuration: GzipCodecConfiguration
+    must_understand: NotRequired[bool]
 
 
 GzipCodecMetadata = GzipCodecObject
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/scale_offset.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/scale_offset.py
index 9701db8497..344a4c435c 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/scale_offset.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/scale_offset.py
@@ -1,7 +1,7 @@
 """
 Scale-offset codec types.
 
-See https://github.com/zarr-developers/zarr-extensions/tree/main/codecs/scale_offset
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/codecs/scale_offset/README.md
 """
 
 from typing import Final, Literal, NotRequired
@@ -17,7 +17,7 @@
 """Literal type of the `name` field of the `scale_offset` codec."""
 
 
-class ScaleOffsetCodecConfiguration(TypedDict):
+class ScaleOffsetCodecConfiguration(TypedDict, closed=True):
     """
     Configuration for the Zarr v3 `scale_offset` codec.
 
@@ -32,16 +32,18 @@ class ScaleOffsetCodecConfiguration(TypedDict):
     scale: NotRequired[JSONValue]
 
 
-class ScaleOffsetCodecObject(TypedDict):
+class ScaleOffsetCodecObject(TypedDict, closed=True):
     """`scale_offset` codec metadata in object form.
 
     `configuration` is itself optional per spec — when both `offset` and
     `scale` are at their identity defaults, the codec is a no-op and the
     entire `configuration` field may be omitted.
+      https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/codecs/scale_offset/README.md#L18 and #L35
     """
 
     name: ScaleOffsetCodecName
     configuration: NotRequired[ScaleOffsetCodecConfiguration]
+    must_understand: NotRequired[bool]
 
 
 ScaleOffsetCodecMetadata = ScaleOffsetCodecObject | ScaleOffsetCodecName
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/sharding_indexed.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/sharding_indexed.py
index a8c9247ec4..0ce466b5cf 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/sharding_indexed.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/sharding_indexed.py
@@ -23,7 +23,7 @@
 """Tuple of permitted values for the `index_location` field of the `sharding_indexed` codec."""
 
 
-class ShardingIndexedCodecConfiguration(TypedDict):
+class ShardingIndexedCodecConfiguration(TypedDict, closed=True):
     """
     Configuration for the Zarr v3 `sharding_indexed` codec.
 
@@ -35,8 +35,10 @@ class ShardingIndexedCodecConfiguration(TypedDict):
 
     `index_codecs` is the codec pipeline applied to the shard index;
     it must be deterministic (no variable-size compression).
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/sharding-indexed/index.rst#L147-L155
 
     `index_location` defaults to `"end"` per the spec.
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/sharding-indexed/index.rst#L157-L161
     """
 
     chunk_shape: tuple[int, ...]
@@ -45,11 +47,12 @@ class ShardingIndexedCodecConfiguration(TypedDict):
     index_location: NotRequired[ShardingIndexLocation]
 
 
-class ShardingIndexedCodecObject(TypedDict):
+class ShardingIndexedCodecObject(TypedDict, closed=True):
     """`sharding_indexed` codec metadata in object form."""
 
     name: ShardingIndexedCodecName
     configuration: ShardingIndexedCodecConfiguration
+    must_understand: NotRequired[bool]
 
 
 ShardingIndexedCodecMetadata = ShardingIndexedCodecObject
@@ -58,6 +61,8 @@ class ShardingIndexedCodecObject(TypedDict):
 The configuration has multiple required keys (`chunk_shape`, `codecs`,
 `index_codecs`), so only the object form is valid; the short-hand-name
 form is not permitted by the spec for this codec.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/sharding-indexed/index.rst#L141-L155 (required members)
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564 (short-hand names only "if no configuration metadata is required")
 """
 
 __all__ = [
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/transpose.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/transpose.py
index ac469b356a..8024174605 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/transpose.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/transpose.py
@@ -4,7 +4,7 @@
 See https://zarr-specs.readthedocs.io/en/latest/v3/codecs/transpose/index.html
 """
 
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import TypedDict
 
@@ -15,7 +15,7 @@
 """Literal type of the `name` field of the `transpose` codec."""
 
 
-class TransposeCodecConfiguration(TypedDict):
+class TransposeCodecConfiguration(TypedDict, closed=True):
     """
     Configuration for the Zarr v3 `transpose` codec.
 
@@ -26,11 +26,12 @@ class TransposeCodecConfiguration(TypedDict):
     order: tuple[int, ...]
 
 
-class TransposeCodecObject(TypedDict):
+class TransposeCodecObject(TypedDict, closed=True):
     """`transpose` codec metadata in object form."""
 
     name: TransposeCodecName
     configuration: TransposeCodecConfiguration
+    must_understand: NotRequired[bool]
 
 
 TransposeCodecMetadata = TransposeCodecObject
@@ -38,6 +39,8 @@ class TransposeCodecObject(TypedDict):
 
 `order` is required, so only the object form is valid; the short-hand-name
 form is not permitted by the spec for this codec.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/codecs/transpose/index.rst#L60-L66 ("order: Required")
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564 (short-hand names only "if no configuration metadata is required")
 """
 
 __all__ = [
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/codec/zstd.py b/packages/zarr-metadata/src/zarr_metadata/v3/codec/zstd.py
index c0faa64bed..b7ee3f5685 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/codec/zstd.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/codec/zstd.py
@@ -1,12 +1,12 @@
 """
 Zstandard codec types.
 
-See https://github.com/zarr-developers/zarr-specs/pull/256 (unmerged at
-time of writing; the configuration shape below reflects the proposed
-specification).
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/codecs/zstd/README.md
+(the zarr-extensions registry entry; zarr-specs PR #256, which first
+proposed the codec, was never merged).
 """
 
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import TypedDict
 
@@ -17,29 +17,34 @@
 """Literal type of the `name` field of the `zstd` codec."""
 
 
-class ZstdCodecConfiguration(TypedDict):
+class ZstdCodecConfiguration(TypedDict, closed=True):
     """
     Configuration for the Zarr v3 `zstd` codec.
 
-    Both fields are required per the proposed specification.
+    `level` is required; `checksum` is optional ("Should be omitted if
+    false").
+      https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/codecs/zstd/README.md#L9-L19
     """
 
     level: int
-    checksum: bool
+    checksum: NotRequired[bool]
 
 
-class ZstdCodecObject(TypedDict):
+class ZstdCodecObject(TypedDict, closed=True):
     """`zstd` codec metadata in object form."""
 
     name: ZstdCodecName
     configuration: ZstdCodecConfiguration
+    must_understand: NotRequired[bool]
 
 
 ZstdCodecMetadata = ZstdCodecObject
 """Permitted JSON shape for `zstd` codec metadata.
 
-Both `level` and `checksum` are required, so only the object form is
-valid; the short-hand-name form is not permitted by the spec for this codec.
+`level` is required, so only the object form is valid; the short-hand-name
+form is not permitted by the spec for this codec.
+  https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/codecs/zstd/README.md#L9-L19
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1562-L1564 (short-hand names only "if no configuration metadata is required")
 """
 
 __all__ = [
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/consolidated.py b/packages/zarr-metadata/src/zarr_metadata/v3/consolidated.py
index a9fe0c1f8f..274af507b7 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/consolidated.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/consolidated.py
@@ -20,13 +20,16 @@
 from zarr_metadata.v3.group import ZarrV3GroupMetadataJSON
 
 
-class ZarrV3ConsolidatedMetadataJSON(TypedDict):
+class ZarrV3ConsolidatedMetadataJSON(TypedDict, closed=True):
     """
     Inline consolidated metadata embedded in a v3 group.
 
     The `metadata` map contains only v3 array and group entries. V2 entries
-    are excluded from this interoperability convention by design; the v3 core
-    specification does not define consolidated metadata.
+    are excluded from this interoperability convention by design. The v3 core
+    specification acknowledges `consolidated_metadata` as a historical
+    additional field and fixes this envelope, but leaves the entries to the
+    reference implementation:
+      https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L802-L816
     """
 
     kind: Literal["inline"]
@@ -38,8 +41,12 @@ class ZarrV3ConsolidatedMetadataJSON(TypedDict):
 """The key under which consolidated metadata is embedded in a v3 group document.
 
 Unlike the v2 `.zmetadata` file, this is not a store key: consolidated metadata
-is carried as an extension field inside the group's own `zarr.json`. Like its v2
-counterpart it is a reference-implementation convention, not a spec artifact.
+is carried as an additional field inside the group's own `zarr.json`. The core
+spec names the field and its envelope ("For historical reasons, group metadata
+documents may contain an additional field named ``consolidated_metadata``");
+the entry format, like the v2 counterpart, is a reference-implementation
+convention.
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L802-L816
 """
 
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/bytes.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/bytes.py
index c7eed64f0f..5892a1bdaa 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/bytes.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/bytes.py
@@ -1,7 +1,7 @@
 """
 Zarr `bytes` data type (variable-length raw bytes, zarr-extensions).
 
-See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/bytes
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/data-types/bytes/README.md
 """
 
 import re
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float16.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float16.py
index 41eec441df..264b2c262c 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float16.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float16.py
@@ -14,7 +14,10 @@
 """Literal type of the `data_type` field for `float16`."""
 
 Float16SpecialFillValue = Literal["NaN", "Infinity", "-Infinity"]
-"""Named non-finite fill values permitted by the spec for IEEE 754 floats."""
+"""Named non-finite fill values permitted by the spec for IEEE 754 floats.
+
+https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L63-L79
+"""
 
 HexFloat16 = NewType("HexFloat16", str)
 """A 6-character hex string (`0x` + 4 hex digits) encoding the
@@ -45,7 +48,7 @@ def hex_float16(value: str) -> HexFloat16:
 CANONICAL_NAN_HEX_FLOAT16: Final = "0x7e00"
 """Canonical hex form of the float16 NaN sentinel `"NaN"`.
 
-Per spec the named `"NaN"` sentinel denotes the float with sign=0, the
+Per spec (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L72-L74) the named `"NaN"` sentinel denotes the float with sign=0, the
 most significant mantissa bit set, and all other mantissa bits zero
 (the IEEE 754 default quiet NaN). Other NaN bit patterns must be
 encoded with the explicit hex-string form.
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float32.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float32.py
index 37b7d4f6e8..3b2e786f07 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float32.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float32.py
@@ -14,7 +14,10 @@
 """Literal type of the `data_type` field for `float32`."""
 
 Float32SpecialFillValue = Literal["NaN", "Infinity", "-Infinity"]
-"""Named non-finite fill values permitted by the spec for IEEE 754 floats."""
+"""Named non-finite fill values permitted by the spec for IEEE 754 floats.
+
+https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L63-L79
+"""
 
 HexFloat32 = NewType("HexFloat32", str)
 """A 10-character hex string (`0x` + 8 hex digits) encoding the
@@ -45,7 +48,7 @@ def hex_float32(value: str) -> HexFloat32:
 CANONICAL_NAN_HEX_FLOAT32: Final = "0x7fc00000"
 """Canonical hex form of the float32 NaN sentinel `"NaN"`.
 
-Per spec the named `"NaN"` sentinel denotes the float with sign=0, the
+Per spec (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L72-L74) the named `"NaN"` sentinel denotes the float with sign=0, the
 most significant mantissa bit set, and all other mantissa bits zero
 (the IEEE 754 default quiet NaN). Other NaN bit patterns must be
 encoded with the explicit hex-string form.
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float64.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float64.py
index 9a5cf98288..21373d63f6 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float64.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/float64.py
@@ -14,7 +14,10 @@
 """Literal type of the `data_type` field for `float64`."""
 
 Float64SpecialFillValue = Literal["NaN", "Infinity", "-Infinity"]
-"""Named non-finite fill values permitted by the spec for IEEE 754 floats."""
+"""Named non-finite fill values permitted by the spec for IEEE 754 floats.
+
+https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L63-L79
+"""
 
 HexFloat64 = NewType("HexFloat64", str)
 """An 18-character hex string (`0x` + 16 hex digits) encoding the
@@ -46,7 +49,7 @@ def hex_float64(value: str) -> HexFloat64:
 CANONICAL_NAN_HEX_FLOAT64: Final = "0x7ff8000000000000"
 """Canonical hex form of the float64 NaN sentinel `"NaN"`.
 
-Per spec the named `"NaN"` sentinel denotes the float with sign=0, the
+Per spec (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L72-L74) the named `"NaN"` sentinel denotes the float with sign=0, the
 most significant mantissa bit set, and all other mantissa bits zero
 (the IEEE 754 default quiet NaN). Other NaN bit patterns must be
 encoded with the explicit hex-string form.
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_datetime64.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_datetime64.py
index 8784160f71..4f9a6415c5 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_datetime64.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_datetime64.py
@@ -1,10 +1,10 @@
 """
 Zarr `numpy.datetime64` data type (zarr-extensions).
 
-See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/numpy.datetime64
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/data-types/numpy.datetime64/README.md
 """
 
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import ReadOnly, TypedDict
 
@@ -20,7 +20,7 @@
 """Time unit codes used by numpy.datetime64."""
 
 
-class NumpyDatetime64Configuration(TypedDict):
+class NumpyDatetime64Configuration(TypedDict, closed=True):
     """
     Configuration for the `numpy.datetime64` data type.
 
@@ -36,11 +36,12 @@ class NumpyDatetime64Configuration(TypedDict):
     scale_factor: ReadOnly[int]
 
 
-class NumpyDatetime64(TypedDict):
+class NumpyDatetime64(TypedDict, closed=True):
     """`numpy.datetime64` data type metadata."""
 
     name: NumpyDatetime64DataTypeName
     configuration: NumpyDatetime64Configuration
+    must_understand: NotRequired[bool]
 
 
 NumpyDatetime64FillValue = int | Literal["NaT"]
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_timedelta64.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_timedelta64.py
index f5c8c77bf8..a1c4fef772 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_timedelta64.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/numpy_timedelta64.py
@@ -1,10 +1,10 @@
 """
 Zarr `numpy.timedelta64` data type (zarr-extensions).
 
-See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/numpy.timedelta64
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/data-types/numpy.timedelta64/README.md
 """
 
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import ReadOnly, TypedDict
 
@@ -39,7 +39,7 @@
 """Runtime tuple of the permitted `numpy.timedelta64`/`numpy.datetime64` unit strings."""
 
 
-class NumpyTimedelta64Configuration(TypedDict):
+class NumpyTimedelta64Configuration(TypedDict, closed=True):
     """
     Configuration for the `numpy.timedelta64` data type.
 
@@ -55,11 +55,12 @@ class NumpyTimedelta64Configuration(TypedDict):
     scale_factor: ReadOnly[int]
 
 
-class NumpyTimedelta64(TypedDict):
+class NumpyTimedelta64(TypedDict, closed=True):
     """`numpy.timedelta64` data type metadata."""
 
     name: NumpyTimedelta64DataTypeName
     configuration: NumpyTimedelta64Configuration
+    must_understand: NotRequired[bool]
 
 
 NumpyTimedelta64FillValue = int | Literal["NaT"]
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/raw.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/raw.py
index c9c688c9fa..66e69c9b53 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/raw.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/raw.py
@@ -4,14 +4,19 @@
 The `data_type` value is a string of the form `r<N>` where `N` is a
 positive multiple of 8 (e.g. `r8`, `r16`, `r24`).
 
-See https://zarr-specs.readthedocs.io/en/latest/v3/core/index.html
+See https://zarr-specs.readthedocs.io/en/latest/v3/data-types/index.html
+(https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L46-L47; fill value: https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L97-L99)
 """
 
 import re
 from typing import Final, NewType
 
 RawBytesDataTypeName = NewType("RawBytesDataTypeName", str)
-"""A spec-conformant `r<N>` raw-bytes name (e.g. `"r8"`, `"r16"`)."""
+"""A spec-conformant `r<N>` raw-bytes name (e.g. `"r8"`, `"r16"`).
+
+"raw bits, variable size given by *, limited to be a multiple of 8":
+  https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L46-L47
+"""
 
 _RAW_BYTES_RE: Final = re.compile(r"^r(\d+)$")
 
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/string.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/string.py
index 0a778ccecc..1e93a95d50 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/string.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/string.py
@@ -1,7 +1,7 @@
 """
 Zarr `string` data type (variable-length utf-8, zarr-extensions).
 
-See https://github.com/zarr-developers/zarr-extensions/tree/main/data-types/string
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/data-types/string/README.md
 """
 
 from typing import Final, Literal
diff --git a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/struct.py b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/struct.py
index b1b6b50308..87a437951d 100644
--- a/packages/zarr-metadata/src/zarr_metadata/v3/data_type/struct.py
+++ b/packages/zarr-metadata/src/zarr_metadata/v3/data_type/struct.py
@@ -1,11 +1,11 @@
 """
 Zarr `struct` data type (heterogeneous record, zarr-extensions).
 
-See https://github.com/zarr-developers/zarr-extensions/blob/main/data-types/struct/README.md
+See https://github.com/zarr-developers/zarr-extensions/blob/4da7b37a84f76e660902f6d3de3eaef0e0febae6/data-types/struct/README.md
 """
 
 from collections.abc import Mapping
-from typing import Final, Literal
+from typing import Final, Literal, NotRequired
 
 from typing_extensions import ReadOnly, TypedDict
 
@@ -19,7 +19,7 @@
 """Literal type of the `name` field of the `struct` data type."""
 
 
-class StructField(TypedDict):
+class StructField(TypedDict, closed=True):
     """
     A single field entry inside a structured dtype.
 
@@ -36,17 +36,18 @@ class StructField(TypedDict):
     data_type: ReadOnly[ZarrV3MetadataFieldJSON]
 
 
-class StructConfiguration(TypedDict):
+class StructConfiguration(TypedDict, closed=True):
     """Configuration for the `struct` data type."""
 
     fields: ReadOnly[tuple[StructField, ...]]
 
 
-class Struct(TypedDict):
+class Struct(TypedDict, closed=True):
     """`struct` data type metadata."""
 
     name: StructDataTypeName
     configuration: StructConfiguration
+    must_understand: NotRequired[bool]
 
 
 StructFillValue = Mapping[str, JSONValue]
diff --git a/packages/zarr-metadata/tests/model/test_array.py b/packages/zarr-metadata/tests/model/test_array.py
index 95dc7aea3a..69a3823b6f 100644
--- a/packages/zarr-metadata/tests/model/test_array.py
+++ b/packages/zarr-metadata/tests/model/test_array.py
@@ -180,6 +180,7 @@ def test_json_value_type_accepts_json_shapes() -> None:
 def test_string_nan_fill_value_roundtrips() -> None:
     # Non-finite floats are represented as the spec strings ("NaN", "Infinity",
     # "-Infinity") by the caller — the metadata layer does not interpret dtypes.
+    #   https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/data-types/index.rst#L63-L79
     # The string form round-trips cleanly under default dataclass equality,
     # unlike a raw float('nan') (which is an invalid fill_value the caller must
     # not pass).
@@ -384,7 +385,7 @@ def test_v3_create_default_is_valid_empty_array() -> None:
     assert m.attributes == {}
     assert m.extra_fields == {}
     # the default document is structurally valid and round-trips
-    assert validate_array_metadata_v3(m.to_json()) == []
+    assert validate_array_metadata_v3(m.to_json()) == ()
     assert ZarrV3ArrayMetadata.from_json(m.to_json()) == m
 
 
@@ -406,7 +407,7 @@ def test_v2_create_default_is_valid_empty_array() -> None:
     assert m.compressor is None
     assert m.filters is None
     assert m.attributes is UNSET
-    assert validate_array_metadata_v2(m.to_json()) == []
+    assert validate_array_metadata_v2(m.to_json()) == ()
     assert ZarrV2ArrayMetadata.from_json(m.to_json()) == m
 
 
@@ -759,7 +760,7 @@ def test_v3_parser_accepts_bare_string_data_type() -> None:
 @pytest.mark.parametrize("name", ["bytes", "ANY string", "urn:example:codec"])
 def test_metadata_field_accepts_any_string_name(name: str) -> None:
     """The structural layer checks the name type, not syntax or registration."""
-    assert validate_metadata_field_v3({"name": name}) == []
+    assert validate_metadata_field_v3({"name": name}) == ()
 
 
 @pytest.mark.parametrize("value", [0, 1, "false", None])
@@ -782,7 +783,7 @@ def test_optional_extension_points_allow_must_understand_false(field: str) -> No
     """Codecs and storage transformers may be explicitly ignorable."""
     doc: dict[str, object] = dict(ZarrV3ArrayMetadata.create_default().to_json())
     doc[field] = ({"name": "optional", "must_understand": False},)
-    assert validate_array_metadata_v3(doc) == []
+    assert validate_array_metadata_v3(doc) == ()
 
 
 @pytest.mark.parametrize("field", ["data_type", "chunk_grid", "chunk_key_encoding"])
@@ -850,21 +851,31 @@ def test_v2_from_key_value_remerges_zattrs() -> None:
     assert model.shape == (10,)
 
 
-@pytest.mark.parametrize("extra_key", ["attributes", "vendor_extension"])
-def test_v2_from_key_value_rejects_zarray_extra_members(extra_key: str) -> None:
-    """Raw `.zarray` documents reject every non-spec member."""
+def test_v2_from_key_value_rejects_zarray_attributes() -> None:
+    """A raw `.zarray` document must not carry `attributes`: they live in `.zattrs`."""
     doc: dict[str, object] = dict(ZarrV2ArrayMetadata.create_default().to_json())
     doc.pop("attributes", None)
-    doc[extra_key] = {}
+    doc["attributes"] = {}
 
     with pytest.raises(MetadataValidationError) as exc_info:
         ZarrV2ArrayMetadata.from_key_value({".zarray": json.dumps(doc).encode()})
 
     assert [(problem.loc, problem.kind) for problem in exc_info.value.problems] == [
-        ((extra_key,), "invalid_value")
+        (("attributes",), "invalid_value")
     ]
 
 
+def test_v2_from_key_value_ignores_zarray_extra_members() -> None:
+    """Other raw `.zarray` members "SHOULD be ignored by implementations" (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L91-L92)."""
+    doc: dict[str, object] = dict(ZarrV2ArrayMetadata.create_default().to_json())
+    doc.pop("attributes", None)
+    doc["vendor_extension"] = {}
+
+    model = ZarrV2ArrayMetadata.from_key_value({".zarray": json.dumps(doc).encode()})
+
+    assert "vendor_extension" not in model.to_json()
+
+
 def test_v2_zattrs_presence_round_trips() -> None:
     """The .zattrs file's presence is part of the store: an absent file reads
     as UNSET and emits no .zattrs; an explicit empty file reads as {} and
@@ -925,7 +936,7 @@ def test_is_json(case: Expect[object, frozenset[tuple[str | int, ...]]]) -> None
 def test_validate_json(case: Expect[object, frozenset[tuple[str | int, ...]]]) -> None:
     """validate_json reports the problems (and their locs) for a value."""
     problems = validate_json(case.input)
-    assert (problems == []) is (case.output == frozenset())
+    assert (problems == ()) is (case.output == frozenset())
     assert {p.loc for p in problems} >= case.output
 
 
@@ -1016,7 +1027,7 @@ def test_validate_metadata_field_v3(
 ) -> None:
     """validate_metadata_field_v3 reports the problems for a metadata-field value."""
     problems = validate_metadata_field_v3(case.input)
-    assert (problems == []) is (case.output == frozenset())
+    assert (problems == ()) is (case.output == frozenset())
     assert {p.loc for p in problems} >= case.output
 
 
@@ -1167,7 +1178,7 @@ def test_array_metadata_guards(
     valid = case.output == frozenset()
     assert is_fn(doc) is valid
     problems = validate_fn(doc)
-    assert (problems == []) is valid
+    assert (problems == ()) is valid
     assert {p.loc for p in problems} >= case.output
     if valid:
         assert parse_fn(doc) is doc
@@ -1247,7 +1258,7 @@ def test_metadata_validation_error_holds_problems() -> None:
         ),
     ]
     err = MetadataValidationError(problems)
-    assert err.problems == problems
+    assert err.problems == tuple(problems)
     assert "shape: missing required key" in str(err)
     assert "data_type: expected a metadata field" in str(err)
 
@@ -1256,9 +1267,9 @@ def test_prefix_prepends_loc_head() -> None:
     """_prefix prepends a loc head to each problem's loc."""
     problems = [ValidationProblem(loc=("name",), message="expected str", kind="invalid_type")]
     prefixed = _prefix(0, problems)
-    assert prefixed == [
-        ValidationProblem(loc=(0, "name"), message="expected str", kind="invalid_type")
-    ]
+    assert prefixed == (
+        ValidationProblem(loc=(0, "name"), message="expected str", kind="invalid_type"),
+    )
 
 
 # --- Stricter v2/v3 field validation and error kinds -------------------------
@@ -1275,7 +1286,7 @@ def test_v2_structured_dtype_records_accepted() -> None:
     """A structured v2 dtype (field records, optionally nested/shaped) validates."""
     dtype = (("a", "<i4"), ("b", (("c", "|u1"),)), ("d", "<f8", (2, 2)))
     doc = dict(ZarrV2ArrayMetadata.create_default().to_json()) | {"dtype": dtype}
-    assert validate_array_metadata_v2(doc) == []
+    assert validate_array_metadata_v2(doc) == ()
 
 
 def test_v2_structured_dtype_malformed_record_rejected() -> None:
@@ -1326,16 +1337,16 @@ def test_v2_shape_and_chunks_must_have_equal_rank() -> None:
         ZarrV2ArrayMetadata.from_key_value({".zarray": json.dumps(doc).encode()})
 
 
-def test_v2_filters_must_be_nonempty_when_present() -> None:
-    """A non-null v2 filter sequence contains one or more codec configurations."""
+def test_v2_filters_may_be_empty() -> None:
+    """An empty filter list is a list: the spec says "a list ... or null", with no minimum.
+
+    https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L76-L79
+    """
     doc = dict(ZarrV2ArrayMetadata.create_default().to_json())
     doc["filters"] = ()
 
-    assert [(p.loc, p.kind) for p in validate_array_metadata_v2(doc)] == [
-        (("filters",), "invalid_value")
-    ]
-    with pytest.raises(MetadataValidationError, match="at least one filter"):
-        ZarrV2ArrayMetadata.from_key_value({".zarray": json.dumps(doc).encode()})
+    assert validate_array_metadata_v2(doc) == ()
+    assert ZarrV2ArrayMetadata.from_key_value({".zarray": json.dumps(doc).encode()}).filters == ()
 
 
 def test_v2_dimension_separator_literal_enforced() -> None:
@@ -1381,13 +1392,15 @@ def test_array_zarr_format_rejects_float(
     assert [(p.loc, p.kind) for p in validate(document)] == [(("zarr_format",), "invalid_value")]
 
 
-def test_array_v2_rejects_unknown_document_member() -> None:
-    """The closed v2 merged-document shape rejects undeclared members."""
+def test_array_v2_ignores_unknown_document_member() -> None:
+    """Other .zarray keys "SHOULD NOT be present ... and SHOULD be ignored": tolerated, dropped.
+
+    https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L91-L92
+    """
     doc = dict(ZarrV2ArrayMetadata.create_default().to_json()) | {"unexpected": 1}
 
-    assert [(p.loc, p.kind) for p in validate_array_metadata_v2(doc)] == [
-        (("unexpected",), "invalid_value")
-    ]
+    assert validate_array_metadata_v2(doc) == ()
+    assert "unexpected" not in ZarrV2ArrayMetadata.from_json(doc).to_json()
 
 
 def test_array_v3_from_json_materializes_abstract_containers() -> None:
@@ -1431,9 +1444,9 @@ def test_missing_key_kind_is_machine_readable() -> None:
     doc = dict(ZarrV3ArrayMetadata.create_default().to_json())
     del doc["chunk_key_encoding"]
     problems = validate_array_metadata_v3(doc)
-    assert problems == [
-        ValidationProblem(("chunk_key_encoding",), "missing required key", "missing_key")
-    ]
+    assert problems == (
+        ValidationProblem(("chunk_key_encoding",), "missing required key", "missing_key"),
+    )
 
 
 # --- Unified error channels ---------------------------------------------------
@@ -1466,9 +1479,9 @@ def test_from_key_value_missing_key_kind() -> None:
     """A missing store key surfaces as a missing_key problem at the store-key loc."""
     with pytest.raises(MetadataValidationError) as exc_info:
         ZarrV2ArrayMetadata.from_key_value({})
-    assert exc_info.value.problems == [
-        ValidationProblem((".zarray",), "missing store key", "missing_key")
-    ]
+    assert exc_info.value.problems == (
+        ValidationProblem((".zarray",), "missing store key", "missing_key"),
+    )
 
 
 def test_extra_fields_overlap_raises_metadata_error() -> None:
@@ -1603,8 +1616,8 @@ def test_array_parsers_normalize_json_lists_before_narrowing() -> None:
     v3_raw = json.loads(json.dumps(ZarrV3ArrayMetadata.create_default(shape=(2,)).to_json()))
     v2_raw = json.loads(json.dumps(ZarrV2ArrayMetadata.create_default(shape=(2,)).to_json()))
 
-    assert validate_array_metadata_v3(v3_raw) == []
-    assert validate_array_metadata_v2(v2_raw) == []
+    assert validate_array_metadata_v3(v3_raw) == ()
+    assert validate_array_metadata_v2(v2_raw) == ()
     assert not is_array_metadata_v3(v3_raw)
     assert not is_array_metadata_v2(v2_raw)
 
@@ -1636,7 +1649,10 @@ def test_must_understand_fields_partition() -> None:
     """must_understand_fields contains every extra field not explicitly waived
     with must_understand: false, including implicitly-true and non-mapping
     fields, so a reader can discharge the spec's fail-to-open duty by
-    subtracting the extensions it recognizes."""
+    subtracting the extensions it recognizes.
+
+    https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1575-L1578
+    """
     model = ZarrV3ArrayMetadata.create_default(
         extra_fields={
             "ext_a": {"name": "a", "must_understand": False},
@@ -1662,7 +1678,10 @@ def test_dimension_names_null_field_rejected() -> None:
     """A dimension_names field whose VALUE is null is invalid: the spec permits
     null as an element (an unnamed dimension), never as the field value — "not
     specified" is spelled by omitting the key. Consumers bridging from an
-    in-memory None sentinel must drop the key, not write null."""
+    in-memory None sentinel must drop the key, not write null.
+
+    https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L635-L638
+    """
     doc = dict(ZarrV3ArrayMetadata.create_default().to_json()) | {"dimension_names": None}
     problems = validate_array_metadata_v3(doc)
     assert [(p.loc, p.kind) for p in problems] == [(("dimension_names",), "invalid_type")]
diff --git a/packages/zarr-metadata/tests/model/test_group.py b/packages/zarr-metadata/tests/model/test_group.py
index 4b8c22b84d..b0e451b0a0 100644
--- a/packages/zarr-metadata/tests/model/test_group.py
+++ b/packages/zarr-metadata/tests/model/test_group.py
@@ -474,7 +474,7 @@ def test_group_v3_valid_consolidated_passes_validator() -> None:
             "metadata": {"a": child, "g": {"zarr_format": 3, "node_type": "group"}},
         },
     }
-    assert validate_group_metadata_v3(doc) == []
+    assert validate_group_metadata_v3(doc) == ()
 
 
 def test_v3_consolidated_rejects_unknown_envelope_member() -> None:
@@ -503,7 +503,10 @@ def test_v2_consolidated_rejects_unknown_document_member() -> None:
 
 def test_group_must_understand_fields_partition() -> None:
     """The group model partitions extra fields by the spec's implicit-true rule,
-    like the array model."""
+    like the array model.
+
+    https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v3/core/index.rst#L1571-L1573
+    """
     model = ZarrV3GroupMetadata.create_default(
         extra_fields={
             "waived": {"name": "w", "must_understand": False},
@@ -519,7 +522,7 @@ def test_group_v3_null_consolidated_metadata_repaired_to_absence() -> None:
     it is read as absence (UNSET) and never written back — the round-trip
     deliberately repairs the document rather than preserving the bug."""
     null_doc = {"zarr_format": 3, "node_type": "group", "consolidated_metadata": None}
-    assert validate_group_metadata_v3(null_doc) == []
+    assert validate_group_metadata_v3(null_doc) == ()
     model = ZarrV3GroupMetadata.from_json(null_doc)
     assert model.consolidated_metadata is UNSET
     assert "consolidated_metadata" not in model.to_json()
diff --git a/packages/zarr-metadata/tests/model/test_pydantic_module.py b/packages/zarr-metadata/tests/model/test_pydantic_module.py
index d15b3f118c..80067e81ae 100644
--- a/packages/zarr-metadata/tests/model/test_pydantic_module.py
+++ b/packages/zarr-metadata/tests/model/test_pydantic_module.py
@@ -182,12 +182,14 @@ def test_array_schemas_reject_negative_dimensions() -> None:
         _assert_runtime_and_schema_reject(field_type, doc)
 
 
-def test_v2_array_schema_rejects_empty_filters() -> None:
-    """The v2 schema mirrors the runtime one-or-more filter rule."""
+def test_v2_array_schema_allows_empty_filters() -> None:
+    """The v2 schema, like the runtime, takes "a list ... or null" at its word (https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L76-L79)."""
     doc = json.loads(json.dumps(V2_ARRAY_DOC))
     doc["filters"] = []
+    adapter = TypeAdapter(zmp.ZarrV2ArrayMetadata)
 
-    _assert_runtime_and_schema_reject(zmp.ZarrV2ArrayMetadata, doc)
+    assert adapter.validate_python(doc).filters == ()
+    assert Draft202012Validator(adapter.json_schema()).is_valid(doc)
 
 
 @pytest.mark.parametrize("field", ["data_type", "chunk_grid", "chunk_key_encoding"])
@@ -210,7 +212,6 @@ def test_metadata_field_schema_rejects_unknown_members() -> None:
 @pytest.mark.parametrize(
     ("field_type", "source"),
     [
-        (zmp.ZarrV2ArrayMetadata, V2_ARRAY_DOC),
         (zmp.ZarrV2GroupMetadata, V2_GROUP_DOC),
         (zmp.ZarrV2ConsolidatedMetadata, V2_CONSOLIDATED_DOC),
     ],
@@ -225,6 +226,16 @@ def test_v2_schema_rejects_unknown_document_members(
     _assert_runtime_and_schema_reject(field_type, doc)
 
 
+def test_v2_array_schema_allows_unknown_document_members() -> None:
+    """The v2 array document is open ("SHOULD be ignored", https://github.com/zarr-developers/zarr-specs/blob/fc7dd9c9beb5a50b87f9b08b00bf50fc0048482f/docs/v2/v2.0.rst#L91-L92), in runtime and schema."""
+    doc = json.loads(json.dumps(V2_ARRAY_DOC))
+    doc["unexpected"] = 1
+    adapter = TypeAdapter(zmp.ZarrV2ArrayMetadata)
+
+    assert "unexpected" not in adapter.validate_python(doc).to_json()
+    assert Draft202012Validator(adapter.json_schema()).is_valid(doc)
+
+
 def test_v3_array_schema_allows_unknown_extension_fields() -> None:
     """Schema constraints do not close the v3 top-level extension namespace."""
     doc = json.loads(json.dumps(V3_ARRAY_DOC))
diff --git a/packages/zarr-metadata/tests/test_partial_equivalence.py b/packages/zarr-metadata/tests/test_partial_equivalence.py
index 33492b2356..b364fce091 100644
--- a/packages/zarr-metadata/tests/test_partial_equivalence.py
+++ b/packages/zarr-metadata/tests/test_partial_equivalence.py
@@ -10,8 +10,6 @@
 
 from __future__ import annotations
 
-from typing import Any
-
 import pytest
 
 from zarr_metadata.v2.array import ZarrV2ArrayMetadataJSON, ZarrV2ArrayMetadataJSONPartial
@@ -29,7 +27,7 @@
 
 
 @pytest.mark.parametrize(("full", "partial"), PAIRS, ids=lambda p: p.__name__)
-def test_partial_matches_full(full: Any, partial: Any) -> None:
+def test_partial_matches_full(full: type, partial: type) -> None:
     """Partial TypedDict has identical fields and extra_items, only total differs."""
     assert full.__annotations__ == partial.__annotations__, (
         f"{partial.__name__} fields drifted from {full.__name__}: "
diff --git a/pyproject.toml b/pyproject.toml
index 57443aed80..a4dafe4d6d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -19,6 +19,8 @@ include = [
   "/examples",
   "/mkdocs.yml",
   "/mkdocs_hooks.py",
+  "/Justfile",
+  "/ci",
 ]
 
 [project]
@@ -113,13 +115,13 @@ test = [
     "pytest-cov==7.1.0",
     "pytest-accept==0.3.0",
     "numpydoc==1.10.0",
-    "hypothesis==6.167.1",
+    "hypothesis==6.168.0",
     "pytest-reportlog==1.0.0",
     "pytest-xdist==3.8.0",
     "pytest-benchmark==5.3.0",
     "pytest-codspeed==5.0.3",
     "tomlkit==0.15.1",
-    "uv==0.12.9",
+    "uv==0.12.12",
 ]
 remote-tests = [
     {include-group = "test"},
@@ -131,7 +133,7 @@ remote-tests = [
     "requests==2.34.2",
 ]
 release = [
-    "towncrier==25.8.0",
+    "towncrier==26.9.0",
 ]
 docs = [
     # Doc building
@@ -143,7 +145,7 @@ docs = [
     "mkdocs-redirects==1.2.3",
     "markdown-exec[ansi]==1.12.3",
     "griffe-inherited-docstrings==1.1.3",
-    "ruff==0.16.5",
+    "ruff==0.16.6",
     # Changelog generation
     {include-group = "release"},
     # Optional dependencies to run examples
@@ -205,25 +207,6 @@ matrix.deps.dependency-groups = [
   {value = "remote-tests", if = ["optional"]},
 ]
 
-[tool.hatch.envs.test.scripts]
-run-coverage = [
-    "coverage run --source=src -m pytest --ignore tests/benchmarks --junitxml=junit.xml -o junit_family=legacy {args:}",
-    "coverage xml",
-]
-run-coverage-html = [
-    "coverage run --source=src -m pytest --ignore tests/benchmarks {args:}",
-    "coverage html",
-]
-run = "pytest --ignore tests/benchmarks"
-run-verbose = "run-coverage --verbose"
-run-hypothesis = [
-    "coverage run --source=src -m pytest -nauto --run-slow-hypothesis tests/test_properties.py tests/test_store/test_stateful* {args:}",
-    "coverage xml",
-]
-run-benchmark = "pytest --benchmark-enable tests/benchmarks"
-serve-coverage-html = "python -m http.server -d htmlcov 8000"
-list-env = "pip list"
-
 [tool.hatch.envs.gputest]
 template = "test"
 extra-dependencies = [
@@ -238,13 +221,6 @@ features = ["gpu"]
 [[tool.hatch.envs.gputest.matrix]]
 python = ["3.12", "3.13"]
 
-[tool.hatch.envs.gputest.scripts]
-run-coverage = [
-    "coverage run --source=src -m pytest -m gpu --junitxml=junit.xml -o junit_family=legacy --ignore tests/benchmarks {args:}",
-    "coverage xml",
-]
-run = "pytest -m gpu --ignore tests/benchmarks"
-
 [tool.hatch.envs.upstream]
 template = 'test'
 python = "3.14"
@@ -289,20 +265,6 @@ extra-dependencies = [
 [tool.hatch.envs.default]
 installer = "uv"
 
-[tool.hatch.envs.docs]
-features = ['remote']
-dependency-groups = ['docs']
-
-[tool.hatch.envs.docs.env-vars]
-DISABLE_MKDOCS_2_WARNING = "true"
-NO_MKDOCS_2_WARNING = "true"
-
-[tool.hatch.envs.docs.scripts]
-serve = "mkdocs serve --watch src"
-build = "mkdocs build"
-check = "mkdocs build --strict"
-readthedocs = "rm -rf $READTHEDOCS_OUTPUT/html && cp -r site $READTHEDOCS_OUTPUT/html"
-
 [tool.hatch.envs.doctest]
 description = "Test environment for validating executable code blocks in documentation"
 features = ['remote']
@@ -311,10 +273,6 @@ extra-dependencies = [
     "pytest-examples",
 ]
 
-[tool.hatch.envs.doctest.scripts]
-test = "pytest tests/test_docs.py -v"
-list-env = "pip list"
-
 [tool.ruff]
 line-length = 100
 force-exclude = true
@@ -361,6 +319,7 @@ extend-select = [
     "RET",  # flake8-return
     "RSE",  # flake8-raise
     "RUF",
+    "S101", # flake8-bandit: no assert in runtime code
     "SIM",  # flake8-simplify
     "SLOT", # flake8-slots
     "TC",  # flake8-type-checking
@@ -395,6 +354,12 @@ ignore = [
 
 [tool.ruff.lint.extend-per-file-ignores]
 "tests/**" = ["ANN001", "ANN201", "RUF029", "SIM117", "SIM300"]
+# S101 (no assert) is for runtime code only. Tests, examples, and test-support
+# packages (store conformance suite, hypothesis strategies) assert on purpose.
+# The globs cover the root package and every package under packages/.
+"**/tests/**" = ["S101"]
+"**/examples/**" = ["S101"]
+"**/testing/**" = ["S101"]
 
 [tool.mypy]
 files = ["src", "tests"]
diff --git a/src/zarr/__init__.py b/src/zarr/__init__.py
index cdf3840c3b..f305245f4e 100644
--- a/src/zarr/__init__.py
+++ b/src/zarr/__init__.py
@@ -39,7 +39,10 @@
 from zarr.core.group import AsyncGroup, Group
 
 # in case setuptools scm screw up and find version to be 0.0.0
-assert not __version__.startswith("0.0.0")
+if __version__.startswith("0.0.0"):
+    raise RuntimeError(
+        f"zarr resolved its own version to {__version__!r}; the build metadata is broken."
+    )
 
 _logger = logging.getLogger(__name__)
 
diff --git a/src/zarr/api/asynchronous.py b/src/zarr/api/asynchronous.py
index 3bdc254ea5..1fc10cdd1e 100644
--- a/src/zarr/api/asynchronous.py
+++ b/src/zarr/api/asynchronous.py
@@ -403,7 +403,7 @@ async def open(
                 return AsyncArray(
                     store_path=store_path, metadata=_metadata_dict, config=kwargs.get("config")
                 )
-        except (AssertionError, FileNotFoundError, NodeTypeValidationError):
+        except (FileNotFoundError, NodeTypeValidationError):
             pass
         return await open_group(store=store_path, zarr_format=zarr_format, mode=mode, **kwargs)
 
diff --git a/src/zarr/codecs/bytes.py b/src/zarr/codecs/bytes.py
index fae762fd08..622161c458 100644
--- a/src/zarr/codecs/bytes.py
+++ b/src/zarr/codecs/bytes.py
@@ -7,7 +7,6 @@
 
 from zarr.abc.codec import ArrayBytesCodec
 from zarr.codecs._deprecated_enum import _coerce_enum_input, _DeprecatedStrEnumMeta
-from zarr.core.buffer import Buffer, NDBuffer
 from zarr.core.common import JSON, parse_named_configuration
 from zarr.core.dtype.common import HasEndianness
 from zarr.core.dtype.npy.structured import Struct
@@ -16,6 +15,7 @@
     from typing import Self
 
     from zarr.core.array_spec import ArraySpec
+    from zarr.core.buffer import Buffer, NDBuffer
 
 
 EndianLiteral = Literal["little", "big"]
@@ -142,7 +142,6 @@ def _encode_sync(
         chunk_array: NDBuffer,
         chunk_spec: ArraySpec,
     ) -> Buffer | None:
-        assert isinstance(chunk_array, NDBuffer)
         if chunk_array.dtype.itemsize > 1 and self.endian is not None:
             # Compare full dtypes rather than the top-level byteorder: numpy reports
             # byteorder '|' for structured dtypes even when their fields are
diff --git a/src/zarr/codecs/cast_value.py b/src/zarr/codecs/cast_value.py
index b19a10c873..629b4e7a27 100644
--- a/src/zarr/codecs/cast_value.py
+++ b/src/zarr/codecs/cast_value.py
@@ -311,7 +311,9 @@ def _validate_scalar_map(
         target_zdtype: ZDType[TBaseDType, TBaseScalar],
     ) -> None:
         """Validate that scalar map entries are compatible with source/target dtypes."""
-        assert self.scalar_map is not None
+        scalar_map = self.scalar_map
+        if scalar_map is None:
+            return
         # For encode: keys are source values, values are target values.
         # For decode: keys are target values, values are source values.
         direction_dtypes: dict[
@@ -321,9 +323,9 @@ def _validate_scalar_map(
             "decode": (target_zdtype, source_zdtype),
         }
         for direction, (key_zdtype, val_zdtype) in direction_dtypes.items():
-            if direction not in self.scalar_map:
+            if direction not in scalar_map:
                 continue
-            sub_map = self.scalar_map[direction]  # type: ignore[literal-required]
+            sub_map = scalar_map[direction]  # type: ignore[literal-required]
             for k, v in sub_map.items():
                 _check_representable(k, key_zdtype, f"scalar_map {direction} key")
                 _check_representable(v, val_zdtype, f"scalar_map {direction} value")
diff --git a/src/zarr/codecs/sharding.py b/src/zarr/codecs/sharding.py
index bd0760f7e3..3d5057cecd 100644
--- a/src/zarr/codecs/sharding.py
+++ b/src/zarr/codecs/sharding.py
@@ -160,9 +160,11 @@ class _ShardingByteGetter(ByteGetter):
     def get_sync(
         self, prototype: BufferPrototype | None = None, byte_range: ByteRequest | None = None
     ) -> Buffer | None:
-        assert prototype is None or prototype == default_buffer_prototype(), (
-            f"prototype is not supported within shards currently. diff: {prototype} != {default_buffer_prototype()}"
-        )
+        if prototype is not None and prototype != default_buffer_prototype():
+            raise ValueError(
+                "Non-default buffer prototypes are not supported within shards. "
+                f"Got {prototype}, expected {default_buffer_prototype()}."
+            )
         value = self.shard_dict.get(self.chunk_coords)
         if value is None:
             return None
@@ -193,7 +195,8 @@ def delete_sync(self) -> None:
         del self.shard_dict[self.chunk_coords]
 
     async def set(self, value: Buffer, byte_range: ByteRequest | None = None) -> None:
-        assert byte_range is None, "byte_range is not supported within shards"
+        if byte_range is not None:
+            raise NotImplementedError("byte_range is not supported within shards.")
         self.set_sync(value)
 
     async def delete(self) -> None:
@@ -656,7 +659,8 @@ def _encode_shard_index_sync(self, index: _ShardIndex) -> Buffer:
         index_spec = self._get_index_chunk_spec(index.chunks_per_shard)
         index_nd = get_ndbuffer_class().from_numpy_array(index.offsets_and_lengths)
         result: Buffer | None = index_transform.encode_chunk(index_nd, index_spec)
-        assert result is not None
+        if result is None:
+            raise RuntimeError("Encoding the shard index produced no bytes.")
         return result
 
     def _shard_reader_from_bytes_sync(
@@ -1531,7 +1535,8 @@ async def _decode_shard_index(
                 .decode([(index_bytes, self._get_index_chunk_spec(chunks_per_shard))])
             )
         )
-        assert index_array is not None  # the bytes are already in hand
+        if index_array is None:
+            raise RuntimeError("Decoding the shard index produced no array.")
         return _ShardIndex(chunks_per_shard, index_array.as_numpy_array())
 
     async def _encode_shard_index(self, index: _ShardIndex) -> Buffer:
@@ -1553,7 +1558,8 @@ async def _encode_shard_index(self, index: _ShardIndex) -> Buffer:
                 )
             )
         )
-        assert index_bytes is not None
+        if index_bytes is None:
+            raise RuntimeError("Encoding the shard index produced no bytes.")
         return index_bytes
 
     def _shard_index_size(self, chunks_per_shard: tuple[int, ...]) -> int:
diff --git a/src/zarr/codecs/vlen_utf8.py b/src/zarr/codecs/vlen_utf8.py
index 078e6032fc..6433c80be4 100644
--- a/src/zarr/codecs/vlen_utf8.py
+++ b/src/zarr/codecs/vlen_utf8.py
@@ -8,13 +8,13 @@
 
 from zarr._compat import _reshape_view
 from zarr.abc.codec import ArrayBytesCodec
-from zarr.core.buffer import Buffer, NDBuffer
 from zarr.core.common import JSON, parse_named_configuration
 
 if TYPE_CHECKING:
     from typing import Self
 
     from zarr.core.array_spec import ArraySpec
+    from zarr.core.buffer import Buffer, NDBuffer
 
 
 # can use a global because there are no parameters
@@ -45,11 +45,8 @@ def _decode_sync(
         chunk_bytes: Buffer,
         chunk_spec: ArraySpec,
     ) -> NDBuffer:
-        assert isinstance(chunk_bytes, Buffer)
-
         raw_bytes = chunk_bytes.as_array_like()
         decoded = _vlen_utf8_codec.decode(raw_bytes)
-        assert decoded.dtype == np.object_
         decoded = _reshape_view(decoded, chunk_spec.shape)
         as_string_dtype = decoded.astype(chunk_spec.dtype.to_native_dtype(), copy=False)
         return chunk_spec.prototype.nd_buffer.from_numpy_array(as_string_dtype)
@@ -66,7 +63,6 @@ def _encode_sync(
         chunk_array: NDBuffer,
         chunk_spec: ArraySpec,
     ) -> Buffer | None:
-        assert isinstance(chunk_array, NDBuffer)
         # numcodecs vlen codecs flatten with order="A", so an F-contiguous chunk
         # would be encoded in transposed element order (gh-3558)
         return chunk_spec.prototype.buffer.from_bytes(
@@ -106,11 +102,8 @@ def _decode_sync(
         chunk_bytes: Buffer,
         chunk_spec: ArraySpec,
     ) -> NDBuffer:
-        assert isinstance(chunk_bytes, Buffer)
-
         raw_bytes = chunk_bytes.as_array_like()
         decoded = _vlen_bytes_codec.decode(raw_bytes)
-        assert decoded.dtype == np.object_
         decoded = _reshape_view(decoded, chunk_spec.shape)
         return chunk_spec.prototype.nd_buffer.from_numpy_array(decoded)
 
@@ -126,7 +119,6 @@ def _encode_sync(
         chunk_array: NDBuffer,
         chunk_spec: ArraySpec,
     ) -> Buffer | None:
-        assert isinstance(chunk_array, NDBuffer)
         # numcodecs vlen codecs flatten with order="A", so an F-contiguous chunk
         # would be encoded in transposed element order (gh-3558)
         return chunk_spec.prototype.buffer.from_bytes(
diff --git a/src/zarr/core/array.py b/src/zarr/core/array.py
index 047e7bb3b3..5a8d6bf57e 100644
--- a/src/zarr/core/array.py
+++ b/src/zarr/core/array.py
@@ -158,6 +158,7 @@
     from zarr.abc.codec import CodecPipeline
     from zarr.abc.store import Store
     from zarr.codecs.sharding import IndexLocation, ShardingCodec
+    from zarr.core.buffer import Buffer
     from zarr.core.dtype.wrapper import TBaseDType, TBaseScalar
     from zarr.storage import StoreLike
     from zarr.types import AnyArray, AnyAsyncArray, ArrayV2, ArrayV3, AsyncArrayV2, AsyncArrayV3
@@ -282,6 +283,7 @@ async def get_array_metadata(
                 f"{store_path.store!r} at path {store_path.path!r}."
             )
             raise ArrayNotFoundError(msg)
+        return _array_metadata_dict_v2(zarray_bytes, zattrs_bytes)
     elif zarr_format == 3:
         zarr_json_bytes = await (store_path / ZARR_JSON).get(prototype=cpu_buffer_prototype)
         if zarr_json_bytes is None:
@@ -290,6 +292,7 @@ async def get_array_metadata(
                 f"{store_path.store!r} at path {store_path.path!r}."
             )
             raise ArrayNotFoundError(msg)
+        return _array_metadata_dict_v3(zarr_json_bytes)
     elif zarr_format is None:
         zarr_json_bytes, zarray_bytes, zattrs_bytes = await gather(
             (store_path / ZARR_JSON).get(prototype=cpu_buffer_prototype),
@@ -300,35 +303,34 @@ async def get_array_metadata(
             # warn and favor v3
             msg = f"Both zarr.json (Zarr format 3) and .zarray (Zarr format 2) metadata objects exist at {store_path}. Zarr v3 will be used."
             warnings.warn(msg, category=ZarrUserWarning, stacklevel=1)
-        if zarr_json_bytes is None and zarray_bytes is None:
-            msg = (
-                f"Neither Zarr V3 nor Zarr V2 array metadata documents "
-                f"were found in store {store_path.store!r} at path {store_path.path!r}."
-            )
-            raise ArrayNotFoundError(msg)
-        # set zarr_format based on which keys were found
+        # favor v3 when both are present
         if zarr_json_bytes is not None:
-            zarr_format = 3
-        else:
-            zarr_format = 2
+            return _array_metadata_dict_v3(zarr_json_bytes)
+        if zarray_bytes is not None:
+            return _array_metadata_dict_v2(zarray_bytes, zattrs_bytes)
+        msg = (
+            f"Neither Zarr V3 nor Zarr V2 array metadata documents "
+            f"were found in store {store_path.store!r} at path {store_path.path!r}."
+        )
+        raise ArrayNotFoundError(msg)
     else:
         msg = f"Invalid value for 'zarr_format'. Expected 2, 3, or None. Got '{zarr_format}'."  # type: ignore[unreachable]
         raise MetadataValidationError(msg)
 
-    metadata_dict: dict[str, JSON]
-    if zarr_format == 2:
-        # V2 arrays are comprised of a .zarray and .zattrs objects
-        assert zarray_bytes is not None
-        metadata_dict = buffer_to_json_object(zarray_bytes)
-        zattrs_dict = buffer_to_json_object(zattrs_bytes) if zattrs_bytes is not None else {}
-        metadata_dict["attributes"] = zattrs_dict
-    else:
-        # V3 arrays are comprised of a zarr.json object
-        assert zarr_json_bytes is not None
-        metadata_dict = buffer_to_json_object(zarr_json_bytes)
 
-        parse_node_type_array(metadata_dict.get("node_type"))
+def _array_metadata_dict_v2(zarray_bytes: Buffer, zattrs_bytes: Buffer | None) -> dict[str, JSON]:
+    """Combine a `.zarray` document and an optional `.zattrs` document into one metadata dict."""
+    metadata_dict: dict[str, JSON] = buffer_to_json_object(zarray_bytes)
+    metadata_dict["attributes"] = (
+        buffer_to_json_object(zattrs_bytes) if zattrs_bytes is not None else {}
+    )
+    return metadata_dict
 
+
+def _array_metadata_dict_v3(zarr_json_bytes: Buffer) -> dict[str, JSON]:
+    """Parse a `zarr.json` document, checking that it describes an array."""
+    metadata_dict: dict[str, JSON] = buffer_to_json_object(zarr_json_bytes)
+    parse_node_type_array(metadata_dict.get("node_type"))
     return metadata_dict
 
 
@@ -5896,7 +5898,11 @@ async def _resize(
         If False, the data in those chunks will be preserved.
     """
     new_shape = parse_shapelike(new_shape)
-    assert len(new_shape) == len(array.metadata.shape)
+    if len(new_shape) != len(array.metadata.shape):
+        raise ValueError(
+            f"The new shape must have the same number of dimensions as the array. "
+            f"Got {len(new_shape)} dimension(s), expected {len(array.metadata.shape)}."
+        )
 
     new_metadata = array.metadata.update_shape(new_shape)
     new_chunk_grid = ChunkGrid.from_metadata(new_metadata)
diff --git a/src/zarr/core/buffer/cpu.py b/src/zarr/core/buffer/cpu.py
index 8994281b58..f987ef9dfe 100644
--- a/src/zarr/core/buffer/cpu.py
+++ b/src/zarr/core/buffer/cpu.py
@@ -111,7 +111,6 @@ def combine(self, others: Iterable[core.Buffer]) -> Self:
         data = [np.asanyarray(self._data)]
         for buf in others:
             other_array = buf.as_array_like()
-            assert other_array.dtype == np.dtype("B")
             data.append(np.asanyarray(other_array))
         return self.__class__(np.concatenate(data))
 
diff --git a/src/zarr/core/buffer/gpu.py b/src/zarr/core/buffer/gpu.py
index 8672942364..6f0e4aec12 100644
--- a/src/zarr/core/buffer/gpu.py
+++ b/src/zarr/core/buffer/gpu.py
@@ -111,7 +111,6 @@ def combine(self, others: Iterable[core.Buffer]) -> Self:
         data = [cp.asanyarray(self._data)]
         for other in others:
             other_array = other.as_array_like()
-            assert other_array.dtype == np.dtype("B")
             gpu_other = Buffer(other_array)
             gpu_other_array = gpu_other.as_array_like()
             data.append(cp.asanyarray(gpu_other_array))
@@ -149,8 +148,8 @@ def __init__(self, array: NDArrayLike) -> None:
                 "Cannot use zarr.buffer.gpu.NDBuffer without cupy. Please install cupy."
             )
 
-        # assert array.ndim > 0
-        assert array.dtype != object
+        if array.dtype == object:
+            raise TypeError("zarr.buffer.gpu.NDBuffer does not support arrays with object dtype.")
         self._data = array
 
         if not hasattr(array, "__cuda_array_interface__"):
diff --git a/src/zarr/core/codec_pipeline.py b/src/zarr/core/codec_pipeline.py
index 597f338c42..9ed16bc381 100644
--- a/src/zarr/core/codec_pipeline.py
+++ b/src/zarr/core/codec_pipeline.py
@@ -5,7 +5,7 @@
 from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass, field
 from itertools import batched, chain, pairwise
-from typing import TYPE_CHECKING, Any, cast
+from typing import TYPE_CHECKING, Any
 from warnings import warn
 
 from zarr.abc.codec import (
@@ -397,9 +397,8 @@ async def _async_write_fallback(
     sync IO / sync transform is unavailable).
     """
 
-    if use_sync := (
-        isinstance(pipeline, FusedCodecPipeline) and pipeline.sync_transform is not None
-    ):
+    sync_transform = pipeline.sync_transform if isinstance(pipeline, FusedCodecPipeline) else None
+    if sync_transform is not None:
         # Read each chunk's existing bytes (skipping complete chunks) and decode
         # as fetches complete, overlapping the sync decode with in-flight reads.
         chunk_array_decoded: Iterable[NDBuffer | None] = await _fetch_and_decode_as_completed(
@@ -407,7 +406,7 @@ async def _async_write_fallback(
                 (None if is_complete_chunk else byte_setter, chunk_spec)
                 for byte_setter, chunk_spec, _, _, is_complete_chunk in batch
             ],
-            pipeline.sync_transform,
+            sync_transform,
         )
     else:
 
@@ -460,9 +459,7 @@ async def _read_key(
         for chunk_array, (_, chunk_spec, *_) in zip(chunk_array_merged, batch, strict=False)
     ]
 
-    if use_sync:
-        sync_transform = cast(FusedCodecPipeline, pipeline).sync_transform
-        assert sync_transform is not None
+    if sync_transform is not None:
         await _encode_and_write_as_completed(
             [
                 (byte_setter, chunk_array, chunk_spec)
@@ -709,9 +706,12 @@ async def decode_partial_batch(
         self,
         batch_info: Iterable[tuple[ByteGetter, SelectorTuple, ArraySpec]],
     ) -> Iterable[NDBuffer | None]:
-        assert self.supports_partial_decode
-        assert isinstance(self.array_bytes_codec, ArrayBytesCodecPartialDecodeMixin)
-        return await self.array_bytes_codec.decode_partial(batch_info)
+        codec = self.array_bytes_codec
+        if not self.supports_partial_decode or not isinstance(
+            codec, ArrayBytesCodecPartialDecodeMixin
+        ):
+            raise ValueError("This codec pipeline does not support partial decoding.")
+        return await codec.decode_partial(batch_info)
 
     async def encode_batch(
         self,
@@ -744,9 +744,12 @@ async def encode_partial_batch(
         self,
         batch_info: Iterable[tuple[ByteSetter, NDBuffer, SelectorTuple, ArraySpec]],
     ) -> None:
-        assert self.supports_partial_encode
-        assert isinstance(self.array_bytes_codec, ArrayBytesCodecPartialEncodeMixin)
-        await self.array_bytes_codec.encode_partial(batch_info)
+        codec = self.array_bytes_codec
+        if not self.supports_partial_encode or not isinstance(
+            codec, ArrayBytesCodecPartialEncodeMixin
+        ):
+            raise ValueError("This codec pipeline does not support partial encoding.")
+        await codec.encode_partial(batch_info)
 
     async def read_batch(
         self,
@@ -1117,8 +1120,12 @@ def read_sync(
         the read selection. Otherwise the pipeline fetches the full
         blob and decodes the whole chunk.
         """
-        assert self.sync_transform is not None
         transform = self.sync_transform
+        if transform is None:
+            raise RuntimeError(
+                "This codec pipeline contains codecs without synchronous support; "
+                "use the async read/write path instead."
+            )
 
         batch = list(batch_info)
         if not batch:
@@ -1193,8 +1200,12 @@ def write_sync(
         the full write cycle — reading existing data, merging, encoding,
         and writing — matching the async `BatchedCodecPipeline` path.
         """
-        assert self.sync_transform is not None
         transform = self.sync_transform
+        if transform is None:
+            raise RuntimeError(
+                "This codec pipeline contains codecs without synchronous support; "
+                "use the async read/write path instead."
+            )
 
         batch = list(batch_info)
         if not batch:
@@ -1294,9 +1305,9 @@ async def read(
         # inner-chunk byte ranges (coalesced via get_ranges), matching
         # BatchedCodecPipeline. Without this, the whole-shard _async_read_fallback
         # below would over-read and diverge from the batched pipeline's IO.
-        if self.supports_partial_decode:
-            assert isinstance(self.array_bytes_codec, ArrayBytesCodecPartialDecodeMixin)
-            chunk_array_batch = await self.array_bytes_codec.decode_partial(
+        codec = self.array_bytes_codec
+        if self.supports_partial_decode and isinstance(codec, ArrayBytesCodecPartialDecodeMixin):
+            chunk_array_batch = await codec.decode_partial(
                 [
                     (byte_getter, chunk_selection, chunk_spec)
                     for byte_getter, chunk_spec, chunk_selection, *_ in batch
diff --git a/src/zarr/core/group.py b/src/zarr/core/group.py
index d061e1a5c6..d734e6b7cd 100644
--- a/src/zarr/core/group.py
+++ b/src/zarr/core/group.py
@@ -56,6 +56,7 @@
     ContainsGroupError,
     GroupNotFoundError,
     MetadataValidationError,
+    NodeTypeValidationError,
     ZarrUserWarning,
 )
 from zarr.storage import StoreLike, StorePath
@@ -372,7 +373,11 @@ def to_buffer_dict(self, prototype: BufferPrototype) -> dict[str, Buffer]:
                     ZATTRS_JSON: self.attributes,
                 }
                 consolidated_metadata = self.consolidated_metadata.to_dict()["metadata"]
-                assert isinstance(consolidated_metadata, dict)
+                if not isinstance(consolidated_metadata, dict):
+                    raise TypeError(
+                        "Expected consolidated metadata to serialize to a dict, "
+                        f"got {type(consolidated_metadata).__name__}."
+                    )
                 for k, v in consolidated_metadata.items():
                     attrs = v.pop("attributes", {})
                     d[f"{k}/{ZATTRS_JSON}"] = attrs
@@ -412,7 +417,11 @@ def __init__(
     @classmethod
     def from_dict(cls, data: dict[str, Any]) -> GroupMetadata:
         data = dict(data)
-        assert data.pop("node_type", None) in ("group", None)
+        node_type = data.pop("node_type", None)
+        if node_type not in ("group", None):
+            raise NodeTypeValidationError(
+                f"Invalid value for 'node_type'. Expected 'group' or None. Got {node_type!r}."
+            )
         consolidated_metadata = data.pop("consolidated_metadata", None)
         if consolidated_metadata:
             data["consolidated_metadata"] = ConsolidatedMetadata.from_dict(consolidated_metadata)
@@ -583,8 +592,8 @@ async def open(
             raise MetadataValidationError(msg)
 
         if zarr_format == 2:
-            # this is checked above, asserting here for mypy
-            assert zgroup_bytes is not None
+            if zgroup_bytes is None:
+                raise FileNotFoundError(store_path)
 
             if use_consolidated and maybe_consolidated_metadata_bytes is None:
                 # the user requested consolidated metadata, but it was missing
@@ -600,7 +609,8 @@ async def open(
             )
         else:
             # V3 groups are comprised of a zarr.json object
-            assert zarr_json_bytes is not None
+            if zarr_json_bytes is None:
+                raise FileNotFoundError(store_path)
             if not isinstance(use_consolidated, bool | None):
                 raise TypeError("use_consolidated must be a bool or None for Zarr format 3.")
 
@@ -742,9 +752,6 @@ def _getitem_consolidated(
         # Note that this is a regular def (non async) function.
         # This shouldn't do any additional I/O.
 
-        # the caller needs to verify this!
-        assert self.metadata.consolidated_metadata is not None
-
         # we support nested getitems like group/subgroup/array
         indexers = normalize_path(key).split("/")
         indexers.reverse()
@@ -1049,7 +1056,6 @@ async def require_group(self, name: str, overwrite: bool = False) -> AsyncGroup:
                     raise TypeError(
                         f"Incompatible object ({item.__class__.__name__}) already exists"
                     )
-                assert isinstance(item, AsyncGroup)  # make mypy happy
                 grp = item
             except KeyError:
                 grp = await self.create_group(name)
diff --git a/src/zarr/core/sync.py b/src/zarr/core/sync.py
index 724b31a464..16b1c577ff 100644
--- a/src/zarr/core/sync.py
+++ b/src/zarr/core/sync.py
@@ -149,7 +149,6 @@ def sync[T](
     finished, unfinished = wait([future], return_when=asyncio.ALL_COMPLETED, timeout=timeout)
     if len(unfinished) > 0:
         raise TimeoutError(f"Coroutine {coro} failed to finish within {timeout} s")
-    assert len(finished) == 1
     return_result = next(iter(finished)).result()
 
     if isinstance(return_result, BaseException):
@@ -163,20 +162,21 @@ def _get_loop() -> asyncio.AbstractEventLoop:
 
     The loop will be running on a separate thread.
     """
-    if loop[0] is None:
+    current = loop[0]
+    if current is None:
         with _get_lock():
             # repeat the check just in case the loop got filled between the
             # previous two calls from another thread
-            if loop[0] is None:
+            current = loop[0]
+            if current is None:
                 logger.debug("Creating Zarr event loop")
-                new_loop = asyncio.new_event_loop()
-                loop[0] = new_loop
-                iothread[0] = threading.Thread(target=new_loop.run_forever, name="zarr_io")
-                assert iothread[0] is not None
-                iothread[0].daemon = True
-                iothread[0].start()
-    assert loop[0] is not None
-    return loop[0]
+                current = asyncio.new_event_loop()
+                loop[0] = current
+                thread = threading.Thread(target=current.run_forever, name="zarr_io")
+                thread.daemon = True
+                iothread[0] = thread
+                thread.start()
+    return current
 
 
 async def _collect_aiterator[T](data: AsyncIterator[T]) -> tuple[T, ...]:
diff --git a/src/zarr/registry.py b/src/zarr/registry.py
index a7537e5023..307c323153 100644
--- a/src/zarr/registry.py
+++ b/src/zarr/registry.py
@@ -53,31 +53,100 @@
 #
 # The two Zarr formats resolve codecs through different registries, so they get different
 # tables: a name can mean one thing as a Zarr format 3 codec name and another as a Zarr
-# format 2 codec id. `imagecodecs_*` is exactly that -- `virtual-tiff` declares 15 of those
-# names under `zarr.codecs`, while `imagecodecs-numcodecs` declares all 81 under
-# `numcodecs.codecs`, so the format 2 side can use a prefix and the format 3 side cannot.
+# format 2 codec id. For example, `imagecodecs_*` names are registered by
+# `imagecodecs-zarr` and `virtual-tiff` under `zarr.codecs`, and by
+# `imagecodecs-numcodecs` under `numcodecs.codecs`.
 
 # Zarr format 3 codec names (entry point group "zarr.codecs").
 _CODEC_PACKAGES: dict[str, tuple[str, ...]] = {
     "gribberish": ("gribberish",),
-    # `virtual-tiff` declares these 15 `imagecodecs_*` names, out of the 81 that exist as
-    # numcodecs ids. They are listed exactly rather than by prefix so that the other 66 get no
-    # hint instead of a hint pointing at a package that does not provide them.
-    "imagecodecs_deflate": ("virtual-tiff",),
-    "imagecodecs_delta": ("virtual-tiff",),
-    "imagecodecs_floatpred": ("virtual-tiff",),
+    # Verified against imagecodecs-zarr 2026.8.16's published zarr.codecs entry points:
+    # https://pypi.org/project/imagecodecs-zarr/2026.8.16/
+    # virtual-tiff also provides 13 of these names, plus jpeg8 and jetraw.
+    # Keep exact names: neither package provides every possible imagecodecs_* name.
+    "imagecodecs_aec": ("imagecodecs-zarr",),
+    "imagecodecs_apng": ("imagecodecs-zarr",),
+    "imagecodecs_avif": ("imagecodecs-zarr",),
+    "imagecodecs_b2nd": ("imagecodecs-zarr",),
+    "imagecodecs_bfloat16": ("imagecodecs-zarr",),
+    "imagecodecs_bitorder": ("imagecodecs-zarr",),
+    "imagecodecs_bitshuffle": ("imagecodecs-zarr",),
+    "imagecodecs_blosc": ("imagecodecs-zarr",),
+    "imagecodecs_blosc2": ("imagecodecs-zarr",),
+    "imagecodecs_bmp": ("imagecodecs-zarr",),
+    "imagecodecs_brotli": ("imagecodecs-zarr",),
+    "imagecodecs_byteshuffle": ("imagecodecs-zarr",),
+    "imagecodecs_bz2": ("imagecodecs-zarr",),
+    "imagecodecs_ccittfax3": ("imagecodecs-zarr",),
+    "imagecodecs_ccittfax4": ("imagecodecs-zarr",),
+    "imagecodecs_ccittrle": ("imagecodecs-zarr",),
+    "imagecodecs_checksum": ("imagecodecs-zarr",),
+    "imagecodecs_chunked": ("imagecodecs-zarr",),
+    "imagecodecs_cms": ("imagecodecs-zarr",),
+    "imagecodecs_dds": ("imagecodecs-zarr",),
+    "imagecodecs_deflate": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_delta": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_dicomrle": ("imagecodecs-zarr",),
+    "imagecodecs_eer": ("imagecodecs-zarr",),
+    "imagecodecs_exr": ("imagecodecs-zarr",),
+    "imagecodecs_float24": ("imagecodecs-zarr",),
+    "imagecodecs_floatpred": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_gif": ("imagecodecs-zarr",),
+    "imagecodecs_hcomp": ("imagecodecs-zarr",),
+    "imagecodecs_heif": ("imagecodecs-zarr",),
+    "imagecodecs_htj2k": ("imagecodecs-zarr",),
+    "imagecodecs_isal": ("imagecodecs-zarr",),
     "imagecodecs_jetraw": ("virtual-tiff",),
-    "imagecodecs_jpeg": ("virtual-tiff",),
-    "imagecodecs_jpeg2k": ("virtual-tiff",),
+    "imagecodecs_jpeg": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_jpeg2k": ("imagecodecs-zarr", "virtual-tiff"),
     "imagecodecs_jpeg8": ("virtual-tiff",),
-    "imagecodecs_jpegxl": ("virtual-tiff",),
-    "imagecodecs_jpegxr": ("virtual-tiff",),
-    "imagecodecs_lerc": ("virtual-tiff",),
-    "imagecodecs_lzw": ("virtual-tiff",),
-    "imagecodecs_packbits": ("virtual-tiff",),
-    "imagecodecs_png": ("virtual-tiff",),
-    "imagecodecs_webp": ("virtual-tiff",),
-    "imagecodecs_zstd": ("virtual-tiff",),
+    "imagecodecs_jpegls": ("imagecodecs-zarr",),
+    "imagecodecs_jpegxl": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_jpegxr": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_jpegxs": ("imagecodecs-zarr",),
+    "imagecodecs_lerc": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_ljpeg": ("imagecodecs-zarr",),
+    "imagecodecs_lz4": ("imagecodecs-zarr",),
+    "imagecodecs_lz4f": ("imagecodecs-zarr",),
+    "imagecodecs_lz4h5": ("imagecodecs-zarr",),
+    "imagecodecs_lzf": ("imagecodecs-zarr",),
+    "imagecodecs_lzfse": ("imagecodecs-zarr",),
+    "imagecodecs_lzham": ("imagecodecs-zarr",),
+    "imagecodecs_lzma": ("imagecodecs-zarr",),
+    "imagecodecs_lzo": ("imagecodecs-zarr",),
+    "imagecodecs_lzw": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_meshopt": ("imagecodecs-zarr",),
+    "imagecodecs_openzl": ("imagecodecs-zarr",),
+    "imagecodecs_packbits": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_packints": ("imagecodecs-zarr",),
+    "imagecodecs_pcodec": ("imagecodecs-zarr",),
+    "imagecodecs_pcx": ("imagecodecs-zarr",),
+    "imagecodecs_pglz": ("imagecodecs-zarr",),
+    "imagecodecs_pixarlog": ("imagecodecs-zarr",),
+    "imagecodecs_plio": ("imagecodecs-zarr",),
+    "imagecodecs_png": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_qoi": ("imagecodecs-zarr",),
+    "imagecodecs_quantize": ("imagecodecs-zarr",),
+    "imagecodecs_rcomp": ("imagecodecs-zarr",),
+    "imagecodecs_rgbe": ("imagecodecs-zarr",),
+    "imagecodecs_snappy": ("imagecodecs-zarr",),
+    "imagecodecs_sperr": ("imagecodecs-zarr",),
+    "imagecodecs_spng": ("imagecodecs-zarr",),
+    "imagecodecs_sz3": ("imagecodecs-zarr",),
+    "imagecodecs_szip": ("imagecodecs-zarr",),
+    "imagecodecs_tga": ("imagecodecs-zarr",),
+    "imagecodecs_tiff": ("imagecodecs-zarr",),
+    "imagecodecs_ultrahdr": ("imagecodecs-zarr",),
+    "imagecodecs_wavpack": ("imagecodecs-zarr",),
+    "imagecodecs_webp": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_wic": ("imagecodecs-zarr",),
+    "imagecodecs_xor": ("imagecodecs-zarr",),
+    "imagecodecs_zfp": ("imagecodecs-zarr",),
+    "imagecodecs_zlib": ("imagecodecs-zarr",),
+    "imagecodecs_zlibng": ("imagecodecs-zarr",),
+    "imagecodecs_zopfli": ("imagecodecs-zarr",),
+    "imagecodecs_zstd": ("imagecodecs-zarr", "virtual-tiff"),
+    "imagecodecs_zstd1": ("imagecodecs-zarr",),
     "n5_default": ("zarr-n5",),
 }
 
diff --git a/src/zarr/storage/_common.py b/src/zarr/storage/_common.py
index 72b5fc8a40..df08968e5c 100644
--- a/src/zarr/storage/_common.py
+++ b/src/zarr/storage/_common.py
@@ -360,7 +360,8 @@ async def make_store(
                 "'storage_options' is only used when the store is passed as an FSSpec URI string.",
             )
 
-    assert mode in (None, "r", "r+", "a", "w", "w-")
+    if mode is not None and mode not in ANY_ACCESS_MODE:
+        raise ValueError(f"Invalid mode: {mode}, expected one of {ANY_ACCESS_MODE}")
     _read_only = mode == "r"
 
     if isinstance(store_like, StorePath):
diff --git a/src/zarr/storage/_local.py b/src/zarr/storage/_local.py
index 1627c1a6b5..c34ca44cc1 100644
--- a/src/zarr/storage/_local.py
+++ b/src/zarr/storage/_local.py
@@ -6,6 +6,7 @@
 import os
 import shutil
 import sys
+import time
 import uuid
 from pathlib import Path
 from typing import TYPE_CHECKING, BinaryIO, Literal, Self
@@ -22,7 +23,7 @@
 from zarr.core.common import AccessModeLiteral, concurrent_map
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncIterator, Iterable, Iterator
+    from collections.abc import AsyncIterator, Callable, Iterable, Iterator
 
     from zarr.core.buffer import BufferPrototype
 
@@ -58,6 +59,51 @@ def _safe_move(src: Path, dst: Path) -> None:
         os.unlink(src)
 
 
+# Windows error codes that MoveFileEx reports when the destination could not be
+# superseded. Replacing a name that was itself replaced moments earlier
+# intermittently fails this way with no second process and no open handle
+# involved, and a retry clears it in well under a millisecond. Zarr v2 hit the
+# same thing and fixed it in #698.
+#
+# ERROR_ACCESS_DENIED is also what Windows reports for conditions that will not
+# clear (the destination is a directory, is read-only, or is ACL-denied). Those
+# are retried too and surface the same error after the bounded delay below.
+#
+# Nothing else is retried. In particular the FileExistsError that the exclusive
+# path relies on to report an existing node is ERROR_ALREADY_EXISTS (183), so it
+# still propagates on the first attempt.
+_TRANSIENT_WINERRORS = frozenset(
+    {
+        5,  # ERROR_ACCESS_DENIED
+        32,  # ERROR_SHARING_VIOLATION
+    }
+)
+
+# Delay before each retry. The sequence sums to well under a second so that a
+# genuine failure still surfaces promptly; in practice most transient failures
+# clear on the first retry.
+_RETRY_DELAYS = (0.001, 0.005, 0.02, 0.05, 0.2)
+
+
+def _move_with_retry(tmp_path: Path, path: Path, move: Callable[[Path, Path], object]) -> None:
+    """Run `move(tmp_path, path)`, retrying while the destination is busy.
+
+    This is a single attempt on every platform but Windows, without needing to
+    test for one: only `winerror` values are ever retried, and off Windows an
+    `OSError` does not carry one.
+    """
+    for delay in _RETRY_DELAYS:
+        try:
+            move(tmp_path, path)
+        except OSError as e:
+            if getattr(e, "winerror", None) not in _TRANSIENT_WINERRORS:
+                raise
+            time.sleep(delay)
+        else:
+            return
+    move(tmp_path, path)
+
+
 @contextlib.contextmanager
 def _atomic_write(
     path: Path,
@@ -69,9 +115,9 @@ def _atomic_write(
         with tmp_path.open(mode) as f:
             yield f
         if exclusive:
-            _safe_move(tmp_path, path)
+            _move_with_retry(tmp_path, path, _safe_move)
         else:
-            tmp_path.replace(path)
+            _move_with_retry(tmp_path, path, Path.replace)
     except Exception:
         tmp_path.unlink(missing_ok=True)
         raise
@@ -209,7 +255,6 @@ def get_sync(
         if prototype is None:
             prototype = default_buffer_prototype()
         self._ensure_open_sync()
-        assert isinstance(key, str)
         path = self.root / key
         try:
             return _get(path, prototype, byte_range)
@@ -219,7 +264,6 @@ def get_sync(
     def set_sync(self, key: str, value: Buffer) -> None:
         self._ensure_open_sync()
         self._check_writable()
-        assert isinstance(key, str)
         if not isinstance(value, Buffer):
             raise TypeError(
                 f"LocalStore.set(): `value` must be a Buffer instance. "
@@ -248,7 +292,6 @@ async def get(
             prototype = default_buffer_prototype()
         if not self._is_open:
             await self._open()
-        assert isinstance(key, str)
         path = self.root / key
 
         try:
@@ -264,7 +307,6 @@ async def get_partial_values(
         # docstring inherited
         args = []
         for key, byte_range in key_ranges:
-            assert isinstance(key, str)
             path = self.root / key
             args.append((_get, path, prototype, byte_range))
         return await concurrent_map(args, asyncio.to_thread, limit=None)  # TODO: fix limit
@@ -284,7 +326,6 @@ async def _set(self, key: str, value: Buffer, exclusive: bool = False) -> None:
         if not self._is_open:
             await self._open()
         self._check_writable()
-        assert isinstance(key, str)
         if not isinstance(value, Buffer):
             raise TypeError(
                 f"LocalStore.set(): `value` must be a Buffer instance. Got an instance of {type(value)} instead."
diff --git a/src/zarr/storage/_memory.py b/src/zarr/storage/_memory.py
index f42c38df69..3bece0e841 100644
--- a/src/zarr/storage/_memory.py
+++ b/src/zarr/storage/_memory.py
@@ -118,7 +118,6 @@ def get_sync(
             prototype = default_buffer_prototype()
         if not self._is_open:
             self._is_open = True
-        assert isinstance(key, str)
         try:
             value = self._store_dict[key]
             start, stop = _normalize_byte_range_index(value, byte_range)
@@ -130,7 +129,6 @@ def set_sync(self, key: str, value: Buffer) -> None:
         self._check_writable()
         if not self._is_open:
             self._is_open = True
-        assert isinstance(key, str)
         if not isinstance(value, Buffer):
             raise TypeError(
                 f"MemoryStore.set(): `value` must be a Buffer instance. Got an instance of {type(value)} instead."
@@ -157,7 +155,6 @@ async def get(
             prototype = default_buffer_prototype()
         if not self._is_open:
             await self._open()
-        assert isinstance(key, str)
         try:
             value = self._store_dict[key]
             start, stop = _normalize_byte_range_index(value, byte_range)
@@ -186,7 +183,6 @@ async def set(self, key: str, value: Buffer, byte_range: tuple[int, int] | None
         # docstring inherited
         self._check_writable()
         await self._ensure_open()
-        assert isinstance(key, str)
         if not isinstance(value, Buffer):
             raise TypeError(
                 f"MemoryStore.set(): `value` must be a Buffer instance. Got an instance of {type(value)} instead."
@@ -305,7 +301,6 @@ def from_dict(cls, store_dict: MutableMapping[str, Buffer]) -> Self:
     async def set(self, key: str, value: Buffer, byte_range: tuple[int, int] | None = None) -> None:
         # docstring inherited
         self._check_writable()
-        assert isinstance(key, str)
         if not isinstance(value, Buffer):
             raise TypeError(
                 f"GpuMemoryStore.set(): `value` must be a Buffer instance. Got an instance of {type(value)} instead."
@@ -317,7 +312,6 @@ async def set(self, key: str, value: Buffer, byte_range: tuple[int, int] | None
     def set_sync(self, key: str, value: Buffer) -> None:
         # docstring inherited
         self._check_writable()
-        assert isinstance(key, str)
         if not isinstance(value, Buffer):
             raise TypeError(
                 f"GpuMemoryStore.set(): `value` must be a Buffer instance. Got an instance of {type(value)} instead."
diff --git a/src/zarr/storage/_zip.py b/src/zarr/storage/_zip.py
index 69ae18bc2c..6b9ebca561 100644
--- a/src/zarr/storage/_zip.py
+++ b/src/zarr/storage/_zip.py
@@ -271,7 +271,6 @@ async def get(
         byte_range: ByteRequest | None = None,
     ) -> Buffer | None:
         # docstring inherited
-        assert isinstance(key, str)
 
         with self._lock:
             return self._get(key, prototype=prototype, byte_range=byte_range)
@@ -306,7 +305,6 @@ async def set(self, key: str, value: Buffer) -> None:
         self._check_writable()
         if not self._is_open:
             self._sync_open()
-        assert isinstance(key, str)
         if not isinstance(value, Buffer):
             raise TypeError(
                 f"ZipStore.set(): `value` must be a Buffer instance. Got an instance of {type(value)} instead."
diff --git a/tests/test_array.py b/tests/test_array.py
index 560941b101..3ae502a4e8 100644
--- a/tests/test_array.py
+++ b/tests/test_array.py
@@ -676,6 +676,16 @@ async def test_info_complete_async(
             )
 
 
+@pytest.mark.parametrize("store", ["memory"], indirect=True)
+def test_resize_wrong_ndim_raises(store: MemoryStore, zarr_format: ZarrFormat) -> None:
+    """
+    Resizing to a shape with a different number of dimensions is a ValueError.
+    """
+    z = zarr.create(shape=(10, 10), chunks=(5, 5), dtype="i4", store=store, zarr_format=zarr_format)
+    with pytest.raises(ValueError, match="same number of dimensions"):
+        z.resize((20,))
+
+
 @pytest.mark.parametrize("store", ["memory"], indirect=True)
 def test_resize_1d(store: MemoryStore, zarr_format: ZarrFormat) -> None:
     z = zarr.create(
diff --git a/tests/test_docs.py b/tests/test_docs.py
index 874d90d4e5..6361591a5e 100644
--- a/tests/test_docs.py
+++ b/tests/test_docs.py
@@ -210,7 +210,7 @@ def test_test_only_blocks_come_last() -> None:
     Because we cannot statically tell which later blocks are state-dependent, this guard
     enforces the simple, safe convention only for the blocks we author this way
     (test="true" marker-bound examples like s3/gpu). It is NOT a complete build-hazard
-    check -- the authoritative check is `mkdocs build --strict` (the docs:check CI job),
+    check -- the authoritative check is `mkdocs build --strict` (`just docs-build` in CI),
     which catches the exec="false" case too. This guard just turns the common test-only
     case into a fast, local failure."""
     # Collect, per published-docs file, the start lines of test-only and exec blocks.
diff --git a/tests/test_group.py b/tests/test_group.py
index 4ce326621f..31fbd138cd 100644
--- a/tests/test_group.py
+++ b/tests/test_group.py
@@ -47,6 +47,7 @@
     ContainsGroupError,
     GroupNotFoundError,
     MetadataValidationError,
+    NodeTypeValidationError,
     ZarrUserWarning,
 )
 from zarr.storage import LocalStore, MemoryStore, StorePath, ZipStore
@@ -1112,6 +1113,14 @@ async def test_asyncgroup_open_wrong_format(
         await AsyncGroup.open(store=store, zarr_format=zarr_format_wrong)
 
 
+def test_group_metadata_from_dict_wrong_node_type_raises() -> None:
+    """
+    A metadata document whose node_type is not 'group' cannot become GroupMetadata.
+    """
+    with pytest.raises(NodeTypeValidationError, match="node_type"):
+        GroupMetadata.from_dict({"zarr_format": 3, "node_type": "array"})
+
+
 # todo: replace the dict[str, Any] type with something a bit more specific
 # should this be async?
 @pytest.mark.parametrize(
diff --git a/tests/test_registry.py b/tests/test_registry.py
index cae7a89d98..4344f5d72d 100644
--- a/tests/test_registry.py
+++ b/tests/test_registry.py
@@ -51,7 +51,7 @@ def unregistered_v2_codec(monkeypatch: pytest.MonkeyPatch) -> str:
     [
         ("n5_default", ("zarr-n5",)),
         ("gribberish", ("gribberish",)),
-        ("imagecodecs_jpeg2k", ("virtual-tiff",)),
+        ("imagecodecs_jpeg2k", ("imagecodecs-zarr", "virtual-tiff")),
         ("omfiles.pfor", ("omfiles",)),
         ("any-numcodecs.array-array", ("zarr-any-numcodecs",)),
         ("totally-made-up", ()),
@@ -81,7 +81,10 @@ def test_packages_for_numcodec_v2(name: str, expected: tuple[str, ...]) -> None:
 
 def test_packages_for_codec_is_format_specific() -> None:
     """The same name can mean different packages in each format's registry."""
-    assert _packages_for_codec("imagecodecs_jpeg2k", zarr_format=3) == ("virtual-tiff",)
+    assert _packages_for_codec("imagecodecs_jpeg2k", zarr_format=3) == (
+        "imagecodecs-zarr",
+        "virtual-tiff",
+    )
     assert _packages_for_codec("imagecodecs_jpeg2k", zarr_format=2) == ("imagecodecs-numcodecs",)
     # `crc32c` is a codec zarr implements in format 3, so only format 2 gets a hint for it.
     assert _packages_for_codec("crc32c", zarr_format=3) == ()
@@ -270,15 +273,36 @@ def test_get_numcodec_non_mapping_input_still_raises_value_error(data: object) -
         get_numcodec(data)  # type: ignore[arg-type]
 
 
-def test_imagecodecs_prefix_does_not_over_match_in_zarr_format_3() -> None:
-    """virtual-tiff provides 15 of the 81 `imagecodecs_*` names; the rest must get no hint.
-
-    Recommending virtual-tiff for a name it does not provide is worse than saying nothing.
-    """
-    assert _packages_for_codec("imagecodecs_jpeg2k", zarr_format=3) == ("virtual-tiff",)
-    for name in ("imagecodecs_jpegls", "imagecodecs_avif", "imagecodecs_blosc"):
-        assert _packages_for_codec(name, zarr_format=3) == ()
-        assert _packages_for_codec(name, zarr_format=2) == ("imagecodecs-numcodecs",)
+@pytest.mark.parametrize(
+    ("name", "expected"),
+    [
+        ("imagecodecs_jpeg2k", ("imagecodecs-zarr", "virtual-tiff")),
+        ("imagecodecs_jpeg8", ("virtual-tiff",)),
+        ("imagecodecs_jetraw", ("virtual-tiff",)),
+        ("imagecodecs_jpegls", ("imagecodecs-zarr",)),
+        ("imagecodecs_avif", ("imagecodecs-zarr",)),
+        ("imagecodecs_blosc", ("imagecodecs-zarr",)),
+        ("imagecodecs_lzma", ("imagecodecs-zarr",)),
+        ("imagecodecs_wavpack", ("imagecodecs-zarr",)),
+        ("imagecodecs_zstd1", ("imagecodecs-zarr",)),
+        ("imagecodecs_not_a_codec", ()),
+    ],
+)
+def test_missing_imagecodec_reports_packages(
+    name: str, expected: tuple[str, ...], monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Missing imagecodecs name their providers without guessing from the prefix."""
+    monkeypatch.setitem(zarr.registry._codec_registries, name, zarr.registry.Registry())
+    message = (
+        f"An implementation for codec {name!r} is not available. Register one explicitly "
+        f"using the codec registry (see {_ZARR_CODEC_DOCS_URL}), or install a Python package "
+        "that registers a codec implementation with zarr."
+    )
+    if expected:
+        message += f" Known packages supporting this codec: {', '.join(expected)}."
+    with pytest.raises(UnknownCodecError) as excinfo:
+        get_codec_class(name)
+    assert str(excinfo.value) == message
 
 
 def test_resolve_codec_reports_missing_codec() -> None:
diff --git a/tests/test_store/test_core.py b/tests/test_store/test_core.py
index 7ba4344810..f39dd0cfd3 100644
--- a/tests/test_store/test_core.py
+++ b/tests/test_store/test_core.py
@@ -230,6 +230,14 @@ async def test_store_path_invalid_mode_raises(
         await StorePath.open(LocalStore(str(tmp_path), read_only=modes[0]), path="", mode=modes[1])  # type: ignore[arg-type]
 
 
+async def test_make_store_invalid_mode_raises() -> None:
+    """
+    Test that make_store raises ValueError for a mode outside the access-mode literals.
+    """
+    with pytest.raises(ValueError, match="Invalid mode"):
+        await make_store({}, mode="x")  # type: ignore[arg-type]
+
+
 async def test_make_store_path_invalid() -> None:
     """
     Test that invalid types raise TypeError
diff --git a/tests/test_store/test_local.py b/tests/test_store/test_local.py
index 90d214ee2c..829e8b4f3c 100644
--- a/tests/test_store/test_local.py
+++ b/tests/test_store/test_local.py
@@ -2,6 +2,7 @@
 
 import pathlib
 import re
+import time
 
 import numpy as np
 import pytest
@@ -10,7 +11,7 @@
 from zarr import create_array
 from zarr.core.buffer import Buffer, cpu
 from zarr.storage import LocalStore
-from zarr.storage._local import _atomic_write
+from zarr.storage._local import _RETRY_DELAYS, _atomic_write, _move_with_retry
 from zarr.testing.store import StoreTests
 from zarr.testing.utils import assert_bytes_equal
 
@@ -164,3 +165,104 @@ def test_atomic_write_exclusive_preexisting(tmp_path: pathlib.Path) -> None:
             f.write(b"abc")
     assert path.read_bytes() == b"xyz"
     assert list(path.parent.iterdir()) == [path]  # no temp files
+
+
+def _oserror(winerror: int) -> OSError:
+    """An OSError shaped like the one a failed MoveFileEx produces."""
+    error = OSError(13, "Access is denied")
+    error.winerror = winerror  # type: ignore[attr-defined]
+    return error
+
+
+class _FlakyMove:
+    """A move that raises `error` the first `failures` times it is called."""
+
+    def __init__(self, failures: int, error: OSError) -> None:
+        self.failures = failures
+        self.error = error
+        self.attempts = 0
+
+    def __call__(self, src: pathlib.Path, dst: pathlib.Path) -> None:
+        self.attempts += 1
+        if self.attempts <= self.failures:
+            raise self.error
+        src.replace(dst)
+
+
+@pytest.fixture
+def sleeps(monkeypatch: pytest.MonkeyPatch) -> list[float]:
+    """Record the delays `_move_with_retry` would sleep for instead of sleeping."""
+    recorded: list[float] = []
+    monkeypatch.setattr(time, "sleep", recorded.append)
+    return recorded
+
+
+@pytest.mark.parametrize("winerror", [5, 32])
+@pytest.mark.parametrize("failures", [1, 2, 3])
+def test_move_with_retry_recovers(
+    tmp_path: pathlib.Path, sleeps: list[float], winerror: int, failures: int
+) -> None:
+    """A destination that is briefly busy is retried, not reported."""
+    src = tmp_path / "src"
+    dst = tmp_path / "dst"
+    src.write_bytes(b"abc")
+    move = _FlakyMove(failures, _oserror(winerror))
+
+    _move_with_retry(src, dst, move)
+
+    assert dst.read_bytes() == b"abc"
+    assert move.attempts == failures + 1
+    assert sleeps == list(_RETRY_DELAYS[:failures])
+
+
+def test_move_with_retry_gives_up(tmp_path: pathlib.Path, sleeps: list[float]) -> None:
+    """A destination that never frees still raises, after a bounded wait."""
+    src = tmp_path / "src"
+    dst = tmp_path / "dst"
+    src.write_bytes(b"abc")
+    move = _FlakyMove(len(_RETRY_DELAYS) + 1, _oserror(5))
+
+    with pytest.raises(OSError, match="Access is denied"):
+        _move_with_retry(src, dst, move)
+
+    assert move.attempts == len(_RETRY_DELAYS) + 1
+    assert sleeps == list(_RETRY_DELAYS)
+    assert sum(sleeps) < 1.0
+
+
+@pytest.mark.parametrize("winerror", [2, 183, None])
+def test_move_with_retry_does_not_retry_other_errors(
+    tmp_path: pathlib.Path, sleeps: list[float], winerror: int | None
+) -> None:
+    """Only a busy destination is transient; everything else fails at once.
+
+    183 is the case that matters: `ERROR_ALREADY_EXISTS` is how the
+    `exclusive` path reports that a node is already there, and retrying it
+    would overwrite what `_safe_move` refused to touch.
+    """
+    src = tmp_path / "src"
+    dst = tmp_path / "dst"
+    src.write_bytes(b"abc")
+    error = OSError(17, "boom")
+    if winerror is not None:
+        error.winerror = winerror  # type: ignore[attr-defined]
+    move = _FlakyMove(1, error)
+
+    with pytest.raises(OSError, match="boom"):
+        _move_with_retry(src, dst, move)
+
+    assert move.attempts == 1
+    assert sleeps == []
+
+
+@pytest.mark.parametrize("exclusive", [True, False])
+def test_atomic_write_onto_directory(
+    tmp_path: pathlib.Path, sleeps: list[float], exclusive: bool
+) -> None:
+    """Writing a key whose destination is a directory fails and leaves no temp file."""
+    path = tmp_path / "node"
+    path.mkdir()
+    with pytest.raises(OSError), _atomic_write(path, "wb", exclusive=exclusive) as f:
+        f.write(b"abc")
+    assert path.is_dir()
+    assert list(tmp_path.iterdir()) == [path]  # no temp files
diff --git a/uv.lock b/uv.lock
index c5539e88e2..989f842645 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1054,74 +1054,74 @@ wheels = [
 
 [[package]]
 name = "hypothesis"
-version = "6.167.1"
+version = "6.168.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "sortedcontainers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c2/c9/8cee74c1390b2932406faaab76980f18946f258fa5a8afca17189b3bc655/hypothesis-6.167.1.tar.gz", hash = "sha256:62eefcb4d2791423626e9901c3027a6e0c5ffda2ac0b44b3c7e797ab9d2d5a4c", size = 505849, upload-time = "2026-08-30T19:53:09.05Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/53/4d/3592ca336deafbd3e9b0f47dc4c727aa32d30e765ef6370da8ecd590d388/hypothesis-6.167.1-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:d28118fd70e4e15ff9c308a98b312b544b6145ae45aaa3b566328c1fdee8058f", size = 785476, upload-time = "2026-08-30T19:51:02.154Z" },
-    { url = "https://files.pythonhosted.org/packages/18/bf/e33c431148994cbcb3332c6df94b833ecfb4aa6a8e51ea4b83da55ddd581/hypothesis-6.167.1-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:e517be7f82a0a917758cc489a88b826b5371f56381fd94b4a8a09ce82d8de406", size = 781033, upload-time = "2026-08-30T19:51:27.314Z" },
-    { url = "https://files.pythonhosted.org/packages/94/a3/e0de9a82c7e790a1def0801076e0ef43110f98e95ed54a3554877d0cb66d/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26f8cec74c4fad7aeb0852cb34c2134b16db05d878ad3946a53337dace7016f4", size = 1117814, upload-time = "2026-08-30T19:53:04.109Z" },
-    { url = "https://files.pythonhosted.org/packages/71/a4/8dd6bdc909324d1c39da1c86d65f75512ae049c159952af4cfe8feb5f8d4/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fd202d02d129197a5e771f8a11c7d30559927284c23ec3a8bd4f37a7955964d1", size = 1141639, upload-time = "2026-08-30T19:51:50.399Z" },
-    { url = "https://files.pythonhosted.org/packages/fa/bd/c13ed6145c360d0770415efd7d5a7e63c29905aeef52ab88004fe7e7f924/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8b1e393ab01b71f683ba2a783785871cc6b81a6e41017780c64a5bc0b99759ae", size = 1143334, upload-time = "2026-08-30T19:50:38.045Z" },
-    { url = "https://files.pythonhosted.org/packages/c0/a8/060d79ed8504b54ced9ad16f33d674b1b98a9debe9733c02709d7dd5c71c/hypothesis-6.167.1-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c385c7741893404306f9e5559ab3835432e85e7c153e25f854c502c410bbcbb", size = 1163345, upload-time = "2026-08-30T19:53:06.583Z" },
-    { url = "https://files.pythonhosted.org/packages/cb/f7/6e68e2b705f729a6f7b4f41030022b1a5264c5434d3bcd917233d6801c6a/hypothesis-6.167.1-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:94920ca1fae70c26b0bd3fabbeef9437ffc17a39fe85696fb9a86187d92f6dba", size = 1123029, upload-time = "2026-08-30T19:52:03.134Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/c0/d274fe37ed5ecd5ad8ed555edc1f5e2abc8e1c3be3d5404b7edd5cc353a8/hypothesis-6.167.1-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b8d90ded2ffdc7e56b5e571993f384b52fade0a7b424e614f999cc2491789970", size = 1154003, upload-time = "2026-08-30T19:50:55.053Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/2f/2b5bb386f43fc965eb86fd69fcb2bd62c08cb6d7c6708a40dc39b3b97440/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:40cd5de7dd252942a08480639f5850594b1aca4a463e8a7f15e1fb6c2c3760c1", size = 1293729, upload-time = "2026-08-30T19:52:59.481Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/32/22436b072d79011fe81abb933edcd2476057c7b971588c5f3caf07519a88/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:b9c33f921ddc7fea93660eca408b25fe755516e22ec7ab21cb9951031f1cd608", size = 1419248, upload-time = "2026-08-30T19:50:52.903Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/3e/abf39faaff0f78112112a82316a5c9fe472574480c1ecee526734775b812/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:495989cf0a5ee03f7f9598ee9efeaabf15fd861ec52b5a9d6435849453e17e5d", size = 1274903, upload-time = "2026-08-30T19:52:27.25Z" },
-    { url = "https://files.pythonhosted.org/packages/29/83/69b89ed5692ba3aad117facfb9ce099633a22c35acc3d64829b72253ec8c/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:bc73c46ce8ff93b0eb220f2b75adcbd9fcc9112078a74d3522d2532ad8069bad", size = 1294185, upload-time = "2026-08-30T19:50:35.038Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/1e/55dfcbe45c72df0a5c5b86a6b7c9365121acab69c2cc060bd55336a48c8f/hypothesis-6.167.1-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:36e83e1d7e97aaacbf6cd778e14a841344f848a674b20dfe4fe997546a6a2151", size = 1330013, upload-time = "2026-08-30T19:52:54.841Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/a6/0a36cead4ccff58bedb5d1aa2f894f7a580c317424b4fa788c6b22232b2d/hypothesis-6.167.1-cp310-abi3-win32.whl", hash = "sha256:fb4d87454d2459c2ccb541a4c61c92ce13058b91305ed3304695a409a1d886e4", size = 671942, upload-time = "2026-08-30T19:51:32.732Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/5b/360285ed42109f5ef48d98ca9ffcf71d1477130c0ff1f1a8d535c8507259/hypothesis-6.167.1-cp310-abi3-win_amd64.whl", hash = "sha256:5e35f98b427bf438a946203426b485dd5b62485f3d5a69a0e0862870a545e518", size = 678637, upload-time = "2026-08-30T19:50:33.573Z" },
-    { url = "https://files.pythonhosted.org/packages/79/2d/cc084c1a8bfa296048ec0461f0fa11731abe0097f5c2310c8d39d94c8dc4/hypothesis-6.167.1-cp310-abi3-win_arm64.whl", hash = "sha256:dd6a0808a2eb8b5b1ac06bca4244eee18ed2c0e7b105599e1662203d164317b5", size = 676657, upload-time = "2026-08-30T19:51:34.494Z" },
-    { url = "https://files.pythonhosted.org/packages/72/82/07987292cfb59c73ce6574e2912c015f678d5aa4d8c0712b78ae4415a535/hypothesis-6.167.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:1937ae4e23f7dde6d4202d3d08c2633bcd535a091bdf866b8799abaabcb1e6f0", size = 787050, upload-time = "2026-08-30T19:51:10.782Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/e9/0d37051bec44ec433d87da03c9a7fe389b1b58210790c1f166af249bf941/hypothesis-6.167.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:1434bbd25d05aaf75c4e6829b4cad8e9931b690f840d92b747b2e6e5af575922", size = 778617, upload-time = "2026-08-30T19:50:31.939Z" },
-    { url = "https://files.pythonhosted.org/packages/13/2a/60c18a493215c22c9cfcb4574b381497bd1971eed9fb5f9831b26e73cffb/hypothesis-6.167.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:af3c09428e553b1dd2f9abbc4738377c58bf6d74cb0b8b528cc1dde3a9cdfbe8", size = 1116743, upload-time = "2026-08-30T19:50:49.293Z" },
-    { url = "https://files.pythonhosted.org/packages/12/1f/b6796f11d6502e0b1764aec99f2792ca60382b6a45e26bbe163dc5757980/hypothesis-6.167.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:04f807b85d425a7005e8a24498ca832bf5590f0d306737471d94c842569cecef", size = 1162718, upload-time = "2026-08-30T19:52:47.544Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/6c/e3cf35474b799e299fa08980b6756f500d730781686916ab65f87cbc0613/hypothesis-6.167.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:803c6a98ff66cee4caf03245bfd00e442a907264031b994a3a650dc6e4786f51", size = 1292417, upload-time = "2026-08-30T19:50:56.822Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/4c/875803c80c373a1628f8eb62f215ad23ce7b50ed61f884d6be0838ebea4a/hypothesis-6.167.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:21a7122ddf072906083e3704fe3961ecbc49d7d30a9b51bcd525d977b3afe65e", size = 1329035, upload-time = "2026-08-30T19:51:46.659Z" },
-    { url = "https://files.pythonhosted.org/packages/90/a8/a8daed3796623884471dc0ee8ed63917b1e2b979b4074bcea19a964fcd71/hypothesis-6.167.1-cp312-cp312-win_amd64.whl", hash = "sha256:a2837c60d782eb0b8a910c541264675b9d11486e186af8c82a5e2920b5fe4fe8", size = 675966, upload-time = "2026-08-30T19:51:56.58Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/44/dca7b211804f60c789aced2792b1e7803ccd8b70b79041cbb92788df5d19/hypothesis-6.167.1-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:6478d19a7887731cc2afaa1ec15f62811c9ceb6fd18e5b7563e0a18399a9528f", size = 786947, upload-time = "2026-08-30T19:51:29.165Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/6a/3cffa138492c9e3d5f98f4ff8b467273dc87af6ca3c18084272d106bde10/hypothesis-6.167.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8f13167a4b81c93e7e051d1f02790814a6495fb79cacf3fb89560a796a2f7d00", size = 778584, upload-time = "2026-08-30T19:52:25.091Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/7d/e8039791aaca3b21557bc520a71cdb88751892f66fd1a0a459b59872e463/hypothesis-6.167.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ef7dd225f7df7d74d1c5a905592cd8b4cd348e6be639b189a43def8b0b5dd79", size = 1116749, upload-time = "2026-08-30T19:52:38.178Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/b8/f9b8d93bd6178870f0daa868ca99915f6d9df1f99dc7291e9ce2743a6dc5/hypothesis-6.167.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7d7585429f2263d3ceeb3474bae3871024630a7a598e71eeb4b0dcf03e291623", size = 1162599, upload-time = "2026-08-30T19:52:11.72Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/0d/53d419094e6f8a7e7377c09de15ac23f842ab698ff07241f7b73e19bd559/hypothesis-6.167.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fb9194f450417cf35f66b6c72737cc6b8f21f20567ba4d39822c64f0d1075784", size = 1292230, upload-time = "2026-08-30T19:52:49.732Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/df/cf4c482323ae4f06b5326b5bdd89cf17d8232fdb3186c9913e0b19a5fa58/hypothesis-6.167.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:c63a0d292a5dde3c0fe999892e76d8375a003ca40c0c00d763f3360f91be5b96", size = 1328899, upload-time = "2026-08-30T19:51:05.366Z" },
-    { url = "https://files.pythonhosted.org/packages/49/05/780c4b0396491d294fda69a541cb1dedb37fb9eb2e3a696e85fe19064c40/hypothesis-6.167.1-cp313-cp313-win_amd64.whl", hash = "sha256:ff07f98a0b230632bb2836b5dad3e94d85c114ae155a316afd251c58760958ae", size = 675927, upload-time = "2026-08-30T19:50:58.472Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/f1/1e602f090dcb7e38655f1f7909482742891332275fc01f241e255cdfa514/hypothesis-6.167.1-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:fcfc2a78fc1025644f889a74684b3201f4652ce8e6694c2a01af0f100d0348cf", size = 787054, upload-time = "2026-08-30T19:50:40.88Z" },
-    { url = "https://files.pythonhosted.org/packages/52/57/cfa930719c7af5a33627abba826a3fa2efa61a5f23e38d4111eace5dfe53/hypothesis-6.167.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:769bdd9aa0af08c063327730ab6dc18b7a23837a2912f2aeaab3912f11a7e3ad", size = 778721, upload-time = "2026-08-30T19:50:36.503Z" },
-    { url = "https://files.pythonhosted.org/packages/01/37/4c4bc3d319eac85bfe17515c9786bf49e57181ca8757886110d2cfb13d10/hypothesis-6.167.1-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d75d44bdead6679b6ee9a7c90d10207db865ca0c77c5212103b5ff421379f99e", size = 1116972, upload-time = "2026-08-30T19:51:52.472Z" },
-    { url = "https://files.pythonhosted.org/packages/33/45/0d61ceef2739e7b96ea1faa0f3d5aa5917c8156797993bf3acbadfcd7f0a/hypothesis-6.167.1-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:742be00d7bb53d10634e6435e5b98f51fcdbe7ed377d473ab7387d9499c87169", size = 1162776, upload-time = "2026-08-30T19:51:09.084Z" },
-    { url = "https://files.pythonhosted.org/packages/4a/cf/756666ce2262e90fd61fec41a95548cceab94b0669381d8f0387cd89af93/hypothesis-6.167.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:b6fcdc8d03b37a902262be13112d113bb4ac87edf3b08afb47f3d1210deb038a", size = 1292748, upload-time = "2026-08-30T19:51:17.22Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/b4/87eb3c695d6c37fb44f4d49f9faa2033af496e24965658942a1706e22620/hypothesis-6.167.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e56e7841514276c308c2bb4d033cf01860d0fc8c76e2b79ce748a9f123eaf83b", size = 1329101, upload-time = "2026-08-30T19:51:36.313Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/3b/87faa4a86533eaaa19037741fb9cdde8647f7ffdf8fd4279828ac9d81f8b/hypothesis-6.167.1-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:bbf4f0cad201d0b8e821e82ad828b2aec99ce6d9967779eecb2cad4d4a93debd", size = 618079, upload-time = "2026-08-30T19:52:43.226Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/46/96b7ac9605887447d267b4b3a9ecf61c6caaabf39eef667173b0cc9222b3/hypothesis-6.167.1-cp314-cp314-win_amd64.whl", hash = "sha256:3e04f6001299708b6fd4512267b189c0b029ef1e34500deb4e4c9639023598d7", size = 675812, upload-time = "2026-08-30T19:52:52.298Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/f6/0337a91c50ce4be323c3d6aa852fcf08199ffbb1072da09fbe6d602f4dfe/hypothesis-6.167.1-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:47c99256df28555ecc2aed0e22ca17cd61c63c8c44207a07b4e402cc49661fae", size = 785525, upload-time = "2026-08-30T19:51:03.637Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/08/9bb52de855169d31888c7033ee2f94b94138fde021c1af9dbc7ba5e83cd5/hypothesis-6.167.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:5d6614e88fd267bbd870e3ec02f8a5387897d2d573626a02f5ac06d81533afa6", size = 777142, upload-time = "2026-08-30T19:52:18.472Z" },
-    { url = "https://files.pythonhosted.org/packages/85/79/f1a7e088e13a641357abb9b43d75c116c2a0902711b1a25a203864b96c9b/hypothesis-6.167.1-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:27829aa89fe2e47c5c8d13b3ce31e0f53a01a98f76a4f99cfa3369ab35362f33", size = 1115311, upload-time = "2026-08-30T19:52:40.975Z" },
-    { url = "https://files.pythonhosted.org/packages/e0/38/e28b1fc20bd3d67d43cf1aab7a15daa2a24ec01d17a153e82fcf38c882f3/hypothesis-6.167.1-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e936777d92ae27393b4a941839bbb43c1f339b5a0e394c7f3730454cdf091b3a", size = 1161238, upload-time = "2026-08-30T19:52:20.501Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/de/9b4fc7992166299e0fc5c13c8766919ae57d0fb9eed5319b7a3bad4f2f17/hypothesis-6.167.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:971ce0d8a367a37c4690b83a2e7f6ef832fa3543357eb6da0da27ba078e5088a", size = 1290974, upload-time = "2026-08-30T19:51:15.673Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/79/ca086eea02588212ab796ee4bd7fe6ed514e10d1a99967e478691608e8d9/hypothesis-6.167.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:af84ce2416be2a65bc0ea18e64d2dbb9796b7692593b5b2064d60ea1d52ec1e2", size = 1327969, upload-time = "2026-08-30T19:52:35.846Z" },
-    { url = "https://files.pythonhosted.org/packages/26/79/1875380fa30e8411553e76b3e9695aca0845f9f265523f20f879bdea2b82/hypothesis-6.167.1-cp314-cp314t-win_amd64.whl", hash = "sha256:3b596efec5bd714588e3bb269544d993c5258c979f3a26f51fadf62c215d0e68", size = 675735, upload-time = "2026-08-30T19:52:22.821Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/45/59abecd75e52b9dfb5b3eb991276f54954c44917a1c83d148cfb3580bd39/hypothesis-6.167.1-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:c25c556d51d55d94988dc0a2c716d471ff19cf9632cd33f5e6db2914d802428a", size = 785097, upload-time = "2026-08-30T19:51:12.528Z" },
-    { url = "https://files.pythonhosted.org/packages/01/7c/e6d978dc9564ba70352da60c00f55f6ad7d66d99ecbf336a228978206cb4/hypothesis-6.167.1-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:b57e950f9d5c93ca335bc612e8fa8fb49abb187c3fc9d5e7d9966d52eb27d747", size = 776798, upload-time = "2026-08-30T19:50:47.247Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/a4/f8ecedcf96790aab69d750afe3fcbf503229d0bb4e0c32be655385a4fc8c/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0807ae8d399162827fc1c396ab4c697a41921c2a2baacfada439771e9dc2b867", size = 1115116, upload-time = "2026-08-30T19:52:16.029Z" },
-    { url = "https://files.pythonhosted.org/packages/7e/97/8bca7c262ac4fcb1ee684c04e4ba75f26541d3a30417e3743d19912d257e/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:546fef39c7aadba74bf3e592585694a71340d1775e9b3274bb3f94106dbde4b7", size = 1137812, upload-time = "2026-08-30T19:51:25.507Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/07/9cb4a7fc2aa2b2ad063b446c378f0d7acfa5303e84afd1b1374ba23fd6f3/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a17a5618b6a5b84f17c8acb3bce37122647cf7a3e48b660a39d68a773bd627dd", size = 1140384, upload-time = "2026-08-30T19:52:05.264Z" },
-    { url = "https://files.pythonhosted.org/packages/1c/18/813bf7efa18f11ce938a0da22a7518a54db46d4a181ebf4cb0a8061c263f/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ff5ad833480c1e34ae902cb52fc00802b08ac6c87bd22d7e5f04fd925869608", size = 1160569, upload-time = "2026-08-30T19:51:40.099Z" },
-    { url = "https://files.pythonhosted.org/packages/52/1d/6658d9294ed33bb17da4acf06fe63b010b205ea1861f6921c38060793255/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:630eb37df80b5bc4ec6f391b13caaecc06942ff5da3aadebacf85f53bbc55757", size = 1120605, upload-time = "2026-08-30T19:53:01.848Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/81/a75821c0e879223a2635b8eded84ae874cb6c711b23e9930668008d0b13f/hypothesis-6.167.1-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bc4e65f7c43b187f7a40964706b5ded1073e0c1839e9fb5e041d7ed973bb65fe", size = 1149479, upload-time = "2026-08-30T19:51:30.972Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/f2/c8c3faf4ec796d6dbf36b84662806696434aef38616e5a65b46188c04262/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:e849f518cbc4e76ab15f2f1473c60dd3103da8d32399187325ceb84309105976", size = 1290423, upload-time = "2026-08-30T19:50:51.114Z" },
-    { url = "https://files.pythonhosted.org/packages/a4/e3/e0903abe7e8634cedb5414931452e82daacdd3b8b46d6348bbefcaa45f2a/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:5c5a26d4d3dca0c84e01bde41df4cabaa5a373c7393f9eef372d19fe93b07ccd", size = 1415749, upload-time = "2026-08-30T19:51:48.456Z" },
-    { url = "https://files.pythonhosted.org/packages/a6/9b/03f09c1ecac1dfb0f4cd7fcc6dc50d9c6ea8067b295a728e242650bafe32/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:4819adbc5911648f6bfaeb574f276add184b4b49f54731dbde46fd71256bb157", size = 1272086, upload-time = "2026-08-30T19:52:29.368Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/7c/7a63bfc0bfbaf000f71352c4faac72ff611376330a2ce2e9a1bf4668848a/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:3ad7206de9c398c8da5745b69b5ba2ef45100082eeb174656490bc4f262b112c", size = 1291553, upload-time = "2026-08-30T19:52:07.545Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/5c/8065bdab53bc81743ca68fc76ca53fc7531a5b3f01c0de4ba40467955d6a/hypothesis-6.167.1-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:96d5e8017a9508f06c8a61a6130cb0d0b4810847ed5c76923cb5cfb9952b31af", size = 1327734, upload-time = "2026-08-30T19:51:42.306Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/a0/5c15d480aea3a8e6e5c17c7cb1170171707ac643ffd319473bc194743ad8/hypothesis-6.167.1-cp315-abi3.abi3t-win32.whl", hash = "sha256:a4e4de36a397cba49d949d89cbc26135977c15f9d797caa95317962ceb5b5674", size = 669115, upload-time = "2026-08-30T19:51:14.192Z" },
-    { url = "https://files.pythonhosted.org/packages/1b/36/4cf494bc96384189fedb7d3f272580315f2284a9f8a7f6a59796612eb76d/hypothesis-6.167.1-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:f6fe9c40ab14def363d9e7ab22863fa31652bd5e08f8495b34ff7bd0062b3f8d", size = 675438, upload-time = "2026-08-30T19:51:06.881Z" },
-    { url = "https://files.pythonhosted.org/packages/b0/7f/db1a37e5f45be32c0e64f9ed1268eba56aeedcb2ef20d195fa60c6610347/hypothesis-6.167.1-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:627ce3bd166799a6c0ddcf1351049be5b9a772d5bce436216d42b41a935f42c0", size = 673123, upload-time = "2026-08-30T19:52:13.991Z" },
+sdist = { url = "https://files.pythonhosted.org/packages/5a/ce/c0946bebffb99b62426a6a7643d4272cc6c5cf777a488b3b4d0ee724e960/hypothesis-6.168.0.tar.gz", hash = "sha256:72af51087b7b5ab21c49f0d502f803c20897678652835596bd2a8b169a39135e", size = 510805, upload-time = "2026-09-08T18:48:36.072Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/f8/8b2cc9ae7b439538f6f2d32a92892340b6343a6b04d171c516666901dedc/hypothesis-6.168.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:47b89491ff02e3ae9b302c440457938e87b47a45b9a1d98ff5575b6910d779e2", size = 791358, upload-time = "2026-09-08T18:47:37.076Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f4/4d7d897310cde5085779fb96feadb8529d98cb8e51ed7b24f7da9b6c6bdc/hypothesis-6.168.0-cp310-abi3-macosx_11_0_arm64.whl", hash = "sha256:1f4cd0ff11bd470a1a846296ed5fe55e84214194850370994fd1370fe73d3099", size = 787081, upload-time = "2026-09-08T18:47:16.227Z" },
+    { url = "https://files.pythonhosted.org/packages/26/7b/9d52066d363faba7f3ac20ee60a3c696a475feb2c477d235d0d649d41cc1/hypothesis-6.168.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:732ae5d47482f99d8028cca096729625f05690a83f5e7ce31466e266155792f4", size = 1123850, upload-time = "2026-09-08T18:48:11.504Z" },
+    { url = "https://files.pythonhosted.org/packages/50/cf/aa46d76fa7df43caf2c372e394fda84ce1dc08421814f8674a6b9295e2ea/hypothesis-6.168.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2085ee74ac3ab6b70e2f7ffae9b4cb74c246da2f574b2de81a0818a8a30f659f", size = 1147685, upload-time = "2026-09-08T18:46:58.219Z" },
+    { url = "https://files.pythonhosted.org/packages/84/c2/78ed8c8d5aa37e4baae2a4b3e29687ee3d9b7f1a5e56ea5ea5ec7ec71ecb/hypothesis-6.168.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1894782fae5d9a7bb44e6dcf848ccb09ccb5babab48d8b5c31a0a7fc025b82a1", size = 1149294, upload-time = "2026-09-08T18:47:04.757Z" },
+    { url = "https://files.pythonhosted.org/packages/78/7f/d57440f19e9de70e85359cf179ce786f309ee17609bd3c5a0113272875c0/hypothesis-6.168.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecf0ab13cef899efb816ffdd7963e0679f372520884ce06756c7642f3df94213", size = 1169729, upload-time = "2026-09-08T18:47:44.056Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/86/dc74410a186990bb22c2a3eea0e77804f2eb0f300860b46d7d8948073674/hypothesis-6.168.0-cp310-abi3-manylinux_2_31_riscv64.whl", hash = "sha256:3f6dcf66270278d078bed01b401f47db4e26456cd909d8e23c6b9366a6c0b131", size = 1129182, upload-time = "2026-09-08T18:46:33.382Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/5e/be048fc4f6dac831625e155bdf11e4233caf46bb54030391d6fba8e19449/hypothesis-6.168.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bfef4d46dbf1704a7b8fa3a78778651a2cb18870ca0a70da19c381646822b149", size = 1160180, upload-time = "2026-09-08T18:47:26.459Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/4a/15a34498a5f08720fbbdbbe4668a8050fe4e17c16c9eeb6f56a017f2fa6b/hypothesis-6.168.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:1d1aa5b3484e329295d88488a5ba06243909e65c2ab616513c2d36721de4ed1d", size = 1299711, upload-time = "2026-09-08T18:47:28.34Z" },
+    { url = "https://files.pythonhosted.org/packages/77/09/5354e0dae302ab98c4f0046b7e8699c2186ae4349397bda5d5c852bda68b/hypothesis-6.168.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:3bc00fd8cda04b58e37a1163e8a65389b247b4f5ee547ae37d244a4960995517", size = 1425341, upload-time = "2026-09-08T18:46:56.785Z" },
+    { url = "https://files.pythonhosted.org/packages/59/7c/3c0e1f59043ff128c70a51d298d3d6b5973525c357a1e1d0542dbc05ac90/hypothesis-6.168.0-cp310-abi3-musllinux_1_2_ppc64le.whl", hash = "sha256:990026952d5b2eca290c88f639ac639233f47e13dae338c6dfb6e4774bcab349", size = 1281063, upload-time = "2026-09-08T18:46:55.401Z" },
+    { url = "https://files.pythonhosted.org/packages/40/dd/db884db9a7d42ae6b72a00c13c725940b638dfb263e618b22af59d5dfa2f/hypothesis-6.168.0-cp310-abi3-musllinux_1_2_riscv64.whl", hash = "sha256:a74b0945acbbd552c7c2d0a99a3b5232962b8848c8eed1829451800a9bfcf00b", size = 1300247, upload-time = "2026-09-08T18:47:02.949Z" },
+    { url = "https://files.pythonhosted.org/packages/99/8a/4ee9769e1d48676efb6a78a130f82e0d52d3f87b2055294102272a08615c/hypothesis-6.168.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:2a380b521b5a76a9e8917d64adcf7f861a45a4360a34b1579af14c5df8eb0377", size = 1336084, upload-time = "2026-09-08T18:48:05.675Z" },
+    { url = "https://files.pythonhosted.org/packages/61/17/d4ed11bc99d205d6d2651a0f1a4874f377150f836b5a0849bd511d68a2eb/hypothesis-6.168.0-cp310-abi3-win32.whl", hash = "sha256:2264f15a1c80329e3ad48e39c44bd5c9429b7b04c9ee62cdd72f4b10aaac9f29", size = 677989, upload-time = "2026-09-08T18:47:24.722Z" },
+    { url = "https://files.pythonhosted.org/packages/77/51/abf1fde7b8afab87db30afb73b3847e62440551d146472111cabeba2fe00/hypothesis-6.168.0-cp310-abi3-win_amd64.whl", hash = "sha256:5b54769033b84477931d2072e7133a7555e0de5c53fd5ca3bbde960762d7d31b", size = 684692, upload-time = "2026-09-08T18:46:24.449Z" },
+    { url = "https://files.pythonhosted.org/packages/12/e2/64d79aed47a95186ce9edcef60eb4684870c72542da3b7027c2483d8ee8c/hypothesis-6.168.0-cp310-abi3-win_arm64.whl", hash = "sha256:112b0900059bf9d7d6528ed729770629ab146e0d133c4143b9bd4a01dc002bcc", size = 682709, upload-time = "2026-09-08T18:48:03.756Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/5e/0035896c101f0484c364353f8ee30175eef8936b49171618677287fdd85d/hypothesis-6.168.0-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6b750390dac4429da0cb70ab3fe758457f0cea3d9c843d48c59d0690d1189fda", size = 793115, upload-time = "2026-09-08T18:48:21.352Z" },
+    { url = "https://files.pythonhosted.org/packages/11/5c/938173e27df771cc6e92bc47f117a1b1be4a88fc6dc214f7fc65f9c7ad93/hypothesis-6.168.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8e4b2d434e0dd134f3d31ac1efc1825bf99730dfe70fec005ff66d7211836d79", size = 784634, upload-time = "2026-09-08T18:47:21.406Z" },
+    { url = "https://files.pythonhosted.org/packages/88/00/0b2c6ac07d519131f97712f2533750ffe9b2490eec8f518ef3a5ed2dd514/hypothesis-6.168.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d4d36ed2fd62de11382f1d608169c1ffa9a49d3b9351146d8ff87cb81a66f7", size = 1122855, upload-time = "2026-09-08T18:46:21.967Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/21/dde930fe43171cab37572bd993d70c2a271f240f428f8ccd64ec4c2d661b/hypothesis-6.168.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5920d267f7d8cfd376672f2bde5905cdf284d47519582e41ce7c142d48ee46c4", size = 1168932, upload-time = "2026-09-08T18:46:39.856Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/5d/92b83c3d06194ec626e92723d0b0f70221ebf42d7cb355ed36929df6d735/hypothesis-6.168.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:fb8cdf45361e259df86e19f8cd042ce2d6c7e6ad88fa631b78a4e3a83c2e572d", size = 1298566, upload-time = "2026-09-08T18:48:19.485Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/67/52de8bf3446e3d2d555b812d96673b31bb213b5b9d5804a666e5d0bba76e/hypothesis-6.168.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3b3ce1cce70b25a37ed1a38a53ce7204785726c675c0f41a0f83c338a7e47b3d", size = 1335074, upload-time = "2026-09-08T18:48:01.561Z" },
+    { url = "https://files.pythonhosted.org/packages/14/fd/e592773c1c0ce55e35d26ec55f75546bf1fd72ef5a5c520ed685969b40cb/hypothesis-6.168.0-cp312-cp312-win_amd64.whl", hash = "sha256:f62bdabf278db9ff61df5f3203d608949f0d893d0e30cdac3f2330e67e41ae68", size = 682026, upload-time = "2026-09-08T18:47:01.471Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/e9/39bb8fcccfbafd10fcc777d583c6ebad5d2148e7d743cb350562f28e974f/hypothesis-6.168.0-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:7d55562bf8d41cfa18559c33f30cadf44ceac8e517509d7a022a9feace621f28", size = 793050, upload-time = "2026-09-08T18:47:56.045Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/dd/00fd32e8ec470535e0065cb8d6e175f9fc54b4d3a6f1269f6c487f8bd79d/hypothesis-6.168.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92cff497b92e2285ff6a94193fdee04aba483a4115d501c1f9a570bd103fcd20", size = 784558, upload-time = "2026-09-08T18:46:32.054Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/4d/553c47093f68bdbac0438e16c024ce97649b5804dc6972ef86b9bd2db8a1/hypothesis-6.168.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6ff259260015f9be3756dcd4bc11c08e007314dec6b43d9a89084c4f34f94475", size = 1122841, upload-time = "2026-09-08T18:48:09.374Z" },
+    { url = "https://files.pythonhosted.org/packages/43/d6/0b5940aa75e617c8fd12200bae24d1b71347362514e8210735c581d4d3d1/hypothesis-6.168.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:35f1262831b5acc74ded15f629965daffcd657f6016ee04fc9605f6eb2b334c0", size = 1168825, upload-time = "2026-09-08T18:47:33.702Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/c0/800de1231b2869b51409bbf85799d6f1bf49a00e0afff0aabc097aa8f1b7/hypothesis-6.168.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:046fe4bcfce2a2fa186ba9d96bbb62c25c2f6c2e4071f0783ed6b5cc481d0669", size = 1298433, upload-time = "2026-09-08T18:46:38.53Z" },
+    { url = "https://files.pythonhosted.org/packages/be/35/9907667a30c1dbabbc44a09b4c25a0f575570937fcbbada924ae3a1dbf2a/hypothesis-6.168.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:24b52a2b1c8db6e1e516f9295c8e4ef7ef63303ff24fbbc5b35f4ff71dcd732c", size = 1334988, upload-time = "2026-09-08T18:48:29.395Z" },
+    { url = "https://files.pythonhosted.org/packages/98/8a/7bf214e703fff532ed47cb52ab93ce4b7ea41e4e7084593fa02b740828b7/hypothesis-6.168.0-cp313-cp313-win_amd64.whl", hash = "sha256:ec0886fe0be9091669937989f9a662beca42ae14a4a6dab25491c2c63365f88d", size = 681990, upload-time = "2026-09-08T18:47:49.173Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/c1/64b36b250b1f66abb6ce8c81775d3373d149bc89cbea477ed71b57cf7d1b/hypothesis-6.168.0-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:e2df8afacf9261070795db36db4a394e3ccdbb663fd2d38c7a9fba0c836dcecc", size = 793101, upload-time = "2026-09-08T18:46:54.067Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/c4/494e42304b15f4ec649d36bbc3fc01cef1b63405cf30d4087ae07d048172/hypothesis-6.168.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9ba679f183c67adcb6f4ad93694beafb6da99fe691757f4e57b04ae77e581ba8", size = 784632, upload-time = "2026-09-08T18:48:31.551Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/6d/90d874cb1d749f505749c9908f34e803b97b03457797d5893354980558bc/hypothesis-6.168.0-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d9a8574f80fc859313aee56167d202e8625c0eedd200971130f0839f06d1c93", size = 1123101, upload-time = "2026-09-08T18:48:17.362Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/bb/ec893d0e5f4bcdd0121a8a4280f4e8aba3b4cdae01411f3236016ecd1f81/hypothesis-6.168.0-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:deb02de608268928d779aa889b0a9d67794b1cc0c54a322cf19e386be8a46ca7", size = 1168962, upload-time = "2026-09-08T18:46:48.507Z" },
+    { url = "https://files.pythonhosted.org/packages/11/f1/16ec2bddbaed461725d9aa5a80b43f1905ea50a08f689ec46f8966bb4f0f/hypothesis-6.168.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:076a2096c34448931c3cfeb2eb7a6b843a56ffdce5e4e3a025bfdf8f935666d9", size = 1298932, upload-time = "2026-09-08T18:47:40.632Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/12/7c2fe2706d092f12bd7b3e8565e1ca5d0c24b853751f2f970768086dbdeb/hypothesis-6.168.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:5f099b1c8fc49ec2d9d7944e661addb97d7c38e818fb8d1f78073c43895a87f6", size = 1335196, upload-time = "2026-09-08T18:47:57.775Z" },
+    { url = "https://files.pythonhosted.org/packages/20/35/59f7ca2414ca39408d13f66a344affe0ffc64748dc01d8a1ca910009cdcb/hypothesis-6.168.0-cp314-cp314-pyemscripten_2026_0_wasm32.whl", hash = "sha256:93413d1b0af50a7b165d66278c529174bf2fd1773c78027735dc0b50d1d3fd27", size = 624102, upload-time = "2026-09-08T18:47:38.869Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/1e/dcd9335ace916ffea40f2cb04ba4122094c2f7b928f3a73fc7d452ce5b71/hypothesis-6.168.0-cp314-cp314-win_amd64.whl", hash = "sha256:db2751c27bffc8491a96d72969649089d5400115e4b7c49bf7167ebbdcc84193", size = 681871, upload-time = "2026-09-08T18:47:59.697Z" },
+    { url = "https://files.pythonhosted.org/packages/de/d0/bc50b0b91e40744b7caa56b8add85cef432f85b4d00108409e8eb17af830/hypothesis-6.168.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:cd0c1dcf308e919c8ae708054d0ad61921ae87634a9aea574a9851da584cebc1", size = 791695, upload-time = "2026-09-08T18:47:06.306Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/53/fc7537d50ff008dc5ea8598764935f93dd07bcedaf23ee4e635bdf7055f4/hypothesis-6.168.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d0bdb77f976740b8cd5ec697327ea343d02d052b9916d213b5d4c65d823415cd", size = 783239, upload-time = "2026-09-08T18:47:47.43Z" },
+    { url = "https://files.pythonhosted.org/packages/71/2a/c7aac2efc06713f704d7e354755aff4a11608b9fe93d973ead374f3b81a3/hypothesis-6.168.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3f7486bed33225d02f6aa78a4c4ba2b6f84992a82571cdda1bf08dce41d13507", size = 1121412, upload-time = "2026-09-08T18:47:07.927Z" },
+    { url = "https://files.pythonhosted.org/packages/60/e2/668ab29e5096af682b17b8491f5427d7c5f17c1b991daa5577bde80c29ca/hypothesis-6.168.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ba3838c4a92e0b9730d1ed7e67e4950c152ad79d0a0c7594065262db84c55c4", size = 1167570, upload-time = "2026-09-08T18:47:17.94Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/17/c64635e4c988b5fa3d3b8be322e19e2fe4c731fa0ca074ca852aa70debea/hypothesis-6.168.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:891b2d281ede45130e7fa0a22fd65336cc77ef2f780ec3792e8de6fc274a02c8", size = 1297118, upload-time = "2026-09-08T18:48:13.407Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/c5/c7a0d9a06bf5c3279386dd53161081a57b98c6faf60fbbf64d046315e9e6/hypothesis-6.168.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:e86820053afad84677f301c0b892a226be1df49790800a65668ae7cc8a1ac571", size = 1334068, upload-time = "2026-09-08T18:48:15.462Z" },
+    { url = "https://files.pythonhosted.org/packages/32/99/11a393a20a867e9b978308323d45022e96f5cd2edf391e4d9a65fb4e2cf7/hypothesis-6.168.0-cp314-cp314t-win_amd64.whl", hash = "sha256:a4956f41ab1ec6e6ef9262a35970e9f3e2caaaa1cdafe0d413156c6934dd99d8", size = 681795, upload-time = "2026-09-08T18:47:14.415Z" },
+    { url = "https://files.pythonhosted.org/packages/16/f7/5adae1bf1d4877aca2e8c8e007e57077237e9ac3765e430ffda490b17e19/hypothesis-6.168.0-cp315-abi3.abi3t-macosx_10_12_x86_64.whl", hash = "sha256:754016594fe78cef91790e0922f60d183c52f531255fbfa30dac495b813e2128", size = 791056, upload-time = "2026-09-08T18:48:27.398Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/93/b1b2770b87591db5cf564b9aa0265cf21e9207d28645e0abdeb8df63225b/hypothesis-6.168.0-cp315-abi3.abi3t-macosx_11_0_arm64.whl", hash = "sha256:6f0dd437ec01140676192422b61f2f833b3ce6a3213da9b7e196ad6b3777e795", size = 782980, upload-time = "2026-09-08T18:48:34.087Z" },
+    { url = "https://files.pythonhosted.org/packages/de/bd/673171c1d2423379a7d4a0f9f009cca735a422d0c4a4ac6422d1d1736cab/hypothesis-6.168.0-cp315-abi3.abi3t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f77af7721ff35a58fa8797decd14c932c350a2548686c6e9b844db710a3a2441", size = 1120964, upload-time = "2026-09-08T18:46:59.92Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/00/33a9bd941b22a4fd8a8c805b1563e0db17efc020422f5bd15bdd0fdf258f/hypothesis-6.168.0-cp315-abi3.abi3t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a0d28418c104d7268fdebcc09bc49f7b6569b5eb942430c6859f53ec8d4edf63", size = 1143869, upload-time = "2026-09-08T18:46:49.875Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c1/963460976f41721eff8f67f30d31059ea407cc1b41c737c8859aabf37197/hypothesis-6.168.0-cp315-abi3.abi3t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:812a84c4cc7f7ae4fcb39a5647cc2698e6c18254f8423126425578f1dcdac782", size = 1146453, upload-time = "2026-09-08T18:46:25.757Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/53/09db238098ad66f4e6d2fe883f26c270c2595b90e21c8f969d4cb21cad7a/hypothesis-6.168.0-cp315-abi3.abi3t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6de30e559eb151de14a5f74bceb4d97792a9315ada2a1816b5da825cd7d28edc", size = 1166918, upload-time = "2026-09-08T18:48:23.436Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/31/e1b7b452c8a6166e445ba2ad80a864f6a9eee0fe4c8cecdb9af5c1ee0aa5/hypothesis-6.168.0-cp315-abi3.abi3t-manylinux_2_31_riscv64.whl", hash = "sha256:9018b20acdb061b2ef4b2fa7f558ca5db97ffea316e0a528bc003a24b2ac996e", size = 1126637, upload-time = "2026-09-08T18:47:50.878Z" },
+    { url = "https://files.pythonhosted.org/packages/97/2b/4eceed248afb46fb6b2df21cf2239362de5b25d295c2dc67a82ec8657d5e/hypothesis-6.168.0-cp315-abi3.abi3t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:bc935a5d5f86fd8f5af951b8fbe00307f6f7c596f82a9a27c17d974f6ab0a26c", size = 1155682, upload-time = "2026-09-08T18:47:30.234Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/3e/f3414cda4f325004d5774485e8983b7d1b99e4b91013f013dd088fd778cf/hypothesis-6.168.0-cp315-abi3.abi3t-musllinux_1_2_aarch64.whl", hash = "sha256:45fcfa05f746e253350f55f216bcef59754f5f2b85745f1fc2bb8ba81dd517a9", size = 1296464, upload-time = "2026-09-08T18:46:34.833Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/40/ca79cf96545e1f172b36b8df56bfeb02b61f351f283026f9a57c4631e368/hypothesis-6.168.0-cp315-abi3.abi3t-musllinux_1_2_armv7l.whl", hash = "sha256:f89d8e998d3c936ffbbd1c3686c96f0378f6558aecc5967a3035a857f2bab0ad", size = 1421853, upload-time = "2026-09-08T18:47:23.083Z" },
+    { url = "https://files.pythonhosted.org/packages/77/bc/657d5386740c1f4ac518ff05e4c5b132f1e6df2e7c865ba8fda4279adfa5/hypothesis-6.168.0-cp315-abi3.abi3t-musllinux_1_2_ppc64le.whl", hash = "sha256:d0620fa320fa66649e6bfd71e94f3f86115fffebb7e3c6dcece19d1aaff8e07f", size = 1278216, upload-time = "2026-09-08T18:46:30.871Z" },
+    { url = "https://files.pythonhosted.org/packages/51/54/2328cdb70489a36634534478d9b238594a269d8bec4630ea0e6897048347/hypothesis-6.168.0-cp315-abi3.abi3t-musllinux_1_2_riscv64.whl", hash = "sha256:4085b61e25d3dcc6c9151d4115269870aee8cdb921611ee5c989b2786449be09", size = 1297593, upload-time = "2026-09-08T18:46:41.395Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/ca/d803fa57e3ff7f460f6e262d2b74822cf143343d378501fd3da601b12040/hypothesis-6.168.0-cp315-abi3.abi3t-musllinux_1_2_x86_64.whl", hash = "sha256:b5449a64eb37d9a4aa6ac9cd2ab0fd1a24145adf421ef1536884f73f39824887", size = 1333785, upload-time = "2026-09-08T18:48:25.434Z" },
+    { url = "https://files.pythonhosted.org/packages/86/8f/b9799ae6ba6074f151db2c63f9f6f12d844512821ffaba1a3672d7e59f07/hypothesis-6.168.0-cp315-abi3.abi3t-win32.whl", hash = "sha256:91e3de666a6c4f7543000d1710e25055d63ef3032c98bd2ab338b3087bdaa780", size = 675173, upload-time = "2026-09-08T18:47:52.601Z" },
+    { url = "https://files.pythonhosted.org/packages/61/54/14c3e277b451ff24128ecc2673cac59dd7e535bce1a433c466912fd682e1/hypothesis-6.168.0-cp315-abi3.abi3t-win_amd64.whl", hash = "sha256:9a2079cd09919956dd388f1a1f8ea5a79f2b2437650fbeda31d8661217ffefef", size = 681491, upload-time = "2026-09-08T18:46:51.437Z" },
+    { url = "https://files.pythonhosted.org/packages/99/f3/827e4a48ffee7e40244b0bf064ba47c2171e053ab7edf1cf770105e23401/hypothesis-6.168.0-cp315-abi3.abi3t-win_arm64.whl", hash = "sha256:085c9aa246487c56a40ca89003d285cbffdbb5be4097ba6d0139f9c21003c04a", size = 679197, upload-time = "2026-09-08T18:47:32.112Z" },
 ]
 
 [[package]]
@@ -1973,75 +1973,75 @@ msgpack = [
 
 [[package]]
 name = "numpy"
-version = "2.5.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9a/80/db0b4559e57ec36362bedbb05530a87fafbcb6067708c946967a41d449e7/numpy-2.5.2.tar.gz", hash = "sha256:d482d171c406ae88c5b19cad3b6a1c4c5209f886ab74bc44c2c865c23f52d860", size = 20773161, upload-time = "2026-08-09T13:48:27.962Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/69/72/dccb0aaf40972777283303919f613964227266d0c13adebb79ac124f1c3e/numpy-2.5.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:14e373cfc6387177e8409dac3c7159be8eb05cd77096cd7c950268b86f62831c", size = 16891693, upload-time = "2026-08-09T13:44:51.702Z" },
-    { url = "https://files.pythonhosted.org/packages/60/2e/b5aee50a1f74ac815cf8331812cb8251e29024025de462e0c047641c614c/numpy-2.5.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:4bbd96c833ecc8cc069ce518078fc8c60cb9cbfb0fea5b7a803ad65035596d03", size = 11903109, upload-time = "2026-08-09T13:44:55.501Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/f4/29e78102a80601cf034d4e9767022cffeca2c3b4c926e1754572ca95593d/numpy-2.5.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:6e8172ddfcf5cf74b811d372b570b83c60bd2de87a6fbfbebdadb4a9bd9c6cbb", size = 5350202, upload-time = "2026-08-09T13:44:58.401Z" },
-    { url = "https://files.pythonhosted.org/packages/11/4b/dcd3b7eadaf4035d2c7a4289d232523a6964f602598ef7674e4bd7291f93/numpy-2.5.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:65f188481f1669e26f62b701e8205d19e460fa4a9b52a1414ba382330e4a3414", size = 6687736, upload-time = "2026-08-09T13:45:00.813Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/21/4947e0e9d6c9fc2e2ff15b8949049ee44f63adb9cacc729ab8793f97e712/numpy-2.5.2-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8ee9c4eeb8454b3660a8b53493563c3e121c2fc94fbd72b848ef814ed7b676a9", size = 15612696, upload-time = "2026-08-09T13:45:04.151Z" },
-    { url = "https://files.pythonhosted.org/packages/3a/5f/62d28cf019460c7f1394105b4d49d9911a9c444cb77ab0bd95a204c5a6de/numpy-2.5.2-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3cdec01fa790a186d430433fdd4d4ffb70eed6f0eeb4bf05c8dbe2dce0a9bcb8", size = 16722264, upload-time = "2026-08-09T13:45:07.714Z" },
-    { url = "https://files.pythonhosted.org/packages/14/25/3f0be4c1b9fdf5dd5e708a6806978564d7c46a055c000496309ff2a2f8af/numpy-2.5.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7999d4ddb0c4025018373fd787510d46e04c769467af22869707b3c1cfd459ab", size = 16974396, upload-time = "2026-08-09T13:45:11.316Z" },
-    { url = "https://files.pythonhosted.org/packages/22/72/6262cbdeeb45da9d971e40715f579d791603ba8ec0b5e2db1ac55454421d/numpy-2.5.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c1f017dc0875c9209d219f97feceb7d54c2661bb243deb4114478e1295808af7", size = 18476044, upload-time = "2026-08-09T13:45:14.869Z" },
-    { url = "https://files.pythonhosted.org/packages/36/33/29208b8b075bde62d26a81d14b358c42b0f69b6cabd98d4ff97f37f22b05/numpy-2.5.2-cp312-cp312-win32.whl", hash = "sha256:d6a48072864e3324e194a8fbb3c657bcc5b5c869dbc64c9537b1d5c862572c0a", size = 6072817, upload-time = "2026-08-09T13:45:17.867Z" },
-    { url = "https://files.pythonhosted.org/packages/7f/b9/87fea2769fe1c47c1b5b01d8310772c9d1a85d485de7cf386ef7a3332b02/numpy-2.5.2-cp312-cp312-win_amd64.whl", hash = "sha256:28ac63476ec7651484215ee7fa15a1f78b57c14621f01e392afe17b9a1390ce4", size = 12464674, upload-time = "2026-08-09T13:45:20.734Z" },
-    { url = "https://files.pythonhosted.org/packages/14/52/032b97e00461ab0809bbe4c588b035620e5a14b8cdee47ecddefc7b17d33/numpy-2.5.2-cp312-cp312-win_arm64.whl", hash = "sha256:27650bb0e7140fa3d37b9923b4803645e0b125d190f326eecfd3f4dad8e8ade1", size = 10397131, upload-time = "2026-08-09T13:45:23.73Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/d2/6b24738a0ef4557d189b150046cd07823c50e4273e8aebd651222e24306f/numpy-2.5.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8e4cb9a754c8a0c62eaa88273a5fba3391f4a610d1dee893c0755da31c083f15", size = 16886595, upload-time = "2026-08-09T13:45:27.323Z" },
-    { url = "https://files.pythonhosted.org/packages/65/60/f2d208d366f263f39c6e69ed309290717aab41078b6d04c9be2a84fa2a07/numpy-2.5.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:52c808f96484f5571a5cc863775ce50247c17dfb3b0361f8ed6b4b0456f80080", size = 11896845, upload-time = "2026-08-09T13:45:31.638Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/79/81e0bf24f4d020a2b1d5cd297a9f60c3f24eeb116f9bba5870443f7b6a4a/numpy-2.5.2-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:29d81e97f668489cba8ebfd796b9bdd453525d35dd9e162e2daec94bf3fc7740", size = 5343880, upload-time = "2026-08-09T13:45:34.373Z" },
-    { url = "https://files.pythonhosted.org/packages/ba/cc/e3141cf06d1a8a2c7e107543fe1269c1d1af760d4d683c0794a4ee1127c2/numpy-2.5.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:afb3f0632d6b2e3ba04dbce8d1e48d321b369138b73830b5ca371a0e8d479d56", size = 6682264, upload-time = "2026-08-09T13:45:36.7Z" },
-    { url = "https://files.pythonhosted.org/packages/29/f1/2a64a307d92c5d98f5255a4014eb43bb6103ee477087b61ecae44a3aa9b9/numpy-2.5.2-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0aadf13b60048d501e05fa699efaf7734e2494f3498a4c2a5521d822640324f3", size = 15609566, upload-time = "2026-08-09T13:45:39.518Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/44/59a1eb68e773c4098d107ef34a0dbdeca501d72ffcfbff9a7707343921ce/numpy-2.5.2-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:29b86ff8a6cc556b47ec6b64b194815cc80e6bf5eedcc6cddfd65318cb0b4eee", size = 16709995, upload-time = "2026-08-09T13:45:43.661Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/4c/3e54d4ddbc359a1295f8b633e8106bcd4d7d4a206e82df051bdfb3058755/numpy-2.5.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6950c4b7dd562453090548ba7f5da7e59f57f85663f15d5dcc60e249192f7e59", size = 16972511, upload-time = "2026-08-09T13:45:47.094Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/9f/02e371638ebf19b66d46231e4be52999e87f32d1961b113bc45656608b22/numpy-2.5.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9727f472d2f3888053b8a75ab0cb94745a9de224bb5846dbadc0092101bc71d", size = 18465609, upload-time = "2026-08-09T13:45:50.808Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/ae/ad6645abc7a3510fe48e8ea1ab4598166f500057ef4ebf38bfad4f1577de/numpy-2.5.2-cp313-cp313-win32.whl", hash = "sha256:4f9744f9fbdcea0bc552e8f19e1f141f811a3f9bc2be2cc6e86d982cab23e3f4", size = 6070204, upload-time = "2026-08-09T13:45:54.111Z" },
-    { url = "https://files.pythonhosted.org/packages/15/20/f3489f86d81ea460b2bcdceaed094142ca6579f6be0ec527b781d39afe68/numpy-2.5.2-cp313-cp313-win_amd64.whl", hash = "sha256:85aaccb24182c25df891ad0ec333585967e115269d5f1b17f2c9ae005bc96657", size = 12460532, upload-time = "2026-08-09T13:45:57.167Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/21/35b31dde1b283b79de828b80f876afd8c94e28fe1e9c375f89e261cc4c0d/numpy-2.5.2-cp313-cp313-win_arm64.whl", hash = "sha256:bd68ece1553d2023c09a4226d9e41c586ad2d20594d1a456186c33513d2cb3f2", size = 10396725, upload-time = "2026-08-09T13:46:00.478Z" },
-    { url = "https://files.pythonhosted.org/packages/ac/f8/c3b222bf075b50afd8e949a07a15c4b312a4a84bd8102a332bcd953cbbb4/numpy-2.5.2-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:d787cf769c3baeb5f6235e778edb52c08dfa923789b5958f28e6450f96107cb1", size = 16885180, upload-time = "2026-08-09T13:46:03.939Z" },
-    { url = "https://files.pythonhosted.org/packages/17/e1/2c1d4b1987795a92b5bbf7c24fe249ab96aa2573ab0d7604802c189d7b86/numpy-2.5.2-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:24b9dc2e3d84aa58523798805194e23e736f3f6ce2d1a5b92583ae734e6dbda8", size = 11907878, upload-time = "2026-08-09T13:46:07.045Z" },
-    { url = "https://files.pythonhosted.org/packages/b9/ee/d08226fc858044355983a6e5b94f08ff6f3969e0a2b160a4a89f0ddb3445/numpy-2.5.2-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:9e9413326d726c2545bfa65d2c0876871e8d8386e77f992c1d426e180bbd4323", size = 5354922, upload-time = "2026-08-09T13:46:10.04Z" },
-    { url = "https://files.pythonhosted.org/packages/94/f0/6d3d933056440ebbc5e6bad92065fc6c26a48a84a36b1208580e94eea76c/numpy-2.5.2-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:60e902ac295855348a5ca2ea4c89108989a9f5fddfad3dfc0a8f36b10358567e", size = 6679168, upload-time = "2026-08-09T13:46:12.275Z" },
-    { url = "https://files.pythonhosted.org/packages/c4/3b/ecd49dd90033cceb2704d88ca905d4d7d89b0e8c739608754ffd325fa820/numpy-2.5.2-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:50e500dc868e9313530ce12ba470fe50ff3afe3d62993ed6eff652dacd555b65", size = 15624501, upload-time = "2026-08-09T13:46:15.322Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/99/461bd36dbdfac6c1c53efa370bd55a83227542d0d118f1677dbf1a3dacd5/numpy-2.5.2-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:318b9a4c845dbea06708a29c84ee429cc3065048db34cdb799047643492050ee", size = 16713701, upload-time = "2026-08-09T13:46:18.949Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/9c/2b251df9e8a5d647b62b0cbc1b90a91850c1cf4859ecb532fd0b4eacff6c/numpy-2.5.2-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:34c319e2963be042673fb46570501b2f06c41924e17e3563d58646b4380dfb68", size = 16986065, upload-time = "2026-08-09T13:46:23.006Z" },
-    { url = "https://files.pythonhosted.org/packages/8f/25/20de43f53ff1390534a124475055a19f01fe10c920a0fd11b8e18d6d6052/numpy-2.5.2-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:f06571a052127dc1b4e8b83029b4d1b20daa2b64a31cdd181fc6bc774e9000eb", size = 18470031, upload-time = "2026-08-09T13:46:27.102Z" },
-    { url = "https://files.pythonhosted.org/packages/56/5e/0c577ca308d6da5eb79b546ba10bbe5b60148192194e2da060913b1de4f1/numpy-2.5.2-cp314-cp314-win32.whl", hash = "sha256:2cc779226e476d1e1f08c74068c419e60f41a9e0e069c92f6671d31d5c985e98", size = 6121028, upload-time = "2026-08-09T13:46:30.046Z" },
-    { url = "https://files.pythonhosted.org/packages/15/5c/7bcbd5b11f94199073320410cddcbb80cee62415bfeb540874b265c2d922/numpy-2.5.2-cp314-cp314-win_amd64.whl", hash = "sha256:7587f53dfbd5edc0f7b87c6217b4c6d2d1f2ef9c3da70bc1315e7db5f8d7ec9d", size = 12597627, upload-time = "2026-08-09T13:46:32.886Z" },
-    { url = "https://files.pythonhosted.org/packages/87/bc/4d0b06fba0da90ccc75af62823cb9dcedb6c9ea0cffa058cb2c9ee773a77/numpy-2.5.2-cp314-cp314-win_arm64.whl", hash = "sha256:3e4c367352d3747784248a227fbec218e193b56f7e6692e3b64fc805478ecfdf", size = 10680414, upload-time = "2026-08-09T13:46:36.036Z" },
-    { url = "https://files.pythonhosted.org/packages/cd/17/f429aac9dc08833a0d0f188eba38c532a751b1a1f2ca6018a37b455cb321/numpy-2.5.2-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:b879fb674276e331513fb136b78dbc6bd3c848309e0d841cfd63be3896c4cfc1", size = 12026967, upload-time = "2026-08-09T13:46:39.084Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/9f/d0849de96a2a4ceaa16662f18ee13eaa9c0aa418269fdc8c4857c56b11da/numpy-2.5.2-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:fd0d703772bba096843785bd38371e31bb4a0c1151497ad5739d182114a73f7f", size = 5473874, upload-time = "2026-08-09T13:46:42.075Z" },
-    { url = "https://files.pythonhosted.org/packages/89/3c/8df216d4a4a5422a3de045301cf7df8ea47286d76f5cb7160b0128ac26b7/numpy-2.5.2-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:3a2f061cebd9e3d23bdcfaaded5e2293a4c6a5b60fa42df85d410a725ce621bf", size = 6789276, upload-time = "2026-08-09T13:46:44.387Z" },
-    { url = "https://files.pythonhosted.org/packages/e6/3a/20d7e9891c4ddfadd6ff8d95bf4b29f353d8e1770553de2099880551dfb9/numpy-2.5.2-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6df895598c0edcb41030126c89e0f353b07d93238116143b7405e937359736c4", size = 15659154, upload-time = "2026-08-09T13:46:47.538Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/d6/f3aa3d2688bf501b858835c6bd087ae9b51a56ae6fca8e2b0990abd177af/numpy-2.5.2-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1ab3d4a901f844ea836c3e80bf463c6a27d7f3c14e8e292fcf28d348b25b9bce", size = 16748909, upload-time = "2026-08-09T13:46:51.442Z" },
-    { url = "https://files.pythonhosted.org/packages/7d/8f/1c5cae8d2baf86ab802ae97a00be55bc7e21ebc11b12bbc33376c5f05342/numpy-2.5.2-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:cebc2d6dbb605a7703d59751dea4bd6b0ab127a5a4338a6f432df1936fef8b26", size = 17027685, upload-time = "2026-08-09T13:46:55.095Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/27/71d3467404aedc1c24ce79610f91b52b0b0f466c43a701aa56fc75c145ab/numpy-2.5.2-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:eaca7ff36f0f52e2111ec71f169d8fd3e889e7ddc0d2592e0d703fd8d3ce8fac", size = 18501181, upload-time = "2026-08-09T13:46:59.09Z" },
-    { url = "https://files.pythonhosted.org/packages/14/2f/42921d27c40aea7e077f4a423ae509fd9220b028cd787bafefd8ab2b3a5f/numpy-2.5.2-cp314-cp314t-win32.whl", hash = "sha256:ddf47472af2e4280d79bac82304f5e80150211f1b9e614b760061d5fdfbb6eba", size = 6271085, upload-time = "2026-08-09T13:47:01.903Z" },
-    { url = "https://files.pythonhosted.org/packages/75/e6/bad5f5d56de9b1971bac959963dda276d35c40f1854475005434bbe08692/numpy-2.5.2-cp314-cp314t-win_amd64.whl", hash = "sha256:44ef9675d908e65f9953063837c3277730f3f4437615a4cdab67b366cabaf884", size = 12787971, upload-time = "2026-08-09T13:47:04.963Z" },
-    { url = "https://files.pythonhosted.org/packages/df/05/f608795cb34391acd67e38d94a3c36abd8d8576293a3a80727d7595c372c/numpy-2.5.2-cp314-cp314t-win_arm64.whl", hash = "sha256:eaa088384c46f519dacb93b7ec483a6d6b19a4a2085ae4f25ab9b1c43d387d1e", size = 10750306, upload-time = "2026-08-09T13:47:07.976Z" },
-    { url = "https://files.pythonhosted.org/packages/33/c6/28de0191c5f82b7d42a0a51390ba98587048aa93a39fafb05bdbe6e8d00c/numpy-2.5.2-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:078f9b027b478c9379b9677babbf0f8b8f1ecfada27636d7b9a93990c638739f", size = 16885274, upload-time = "2026-08-09T13:47:11.439Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/d1/973ca116000d244897e468ea1aff30b589e5022e3c8744b71706fe33bd57/numpy-2.5.2-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:50a68f4bacd8a2b33d8da3d2269d0d78500f86ea582e4786dc10f5ef2c2c6842", size = 11907846, upload-time = "2026-08-09T13:47:15.128Z" },
-    { url = "https://files.pythonhosted.org/packages/78/d9/8c4b3937ef204cb2fd88d389ccd0f265a2ffb11f35a01d2064cf46714bd6/numpy-2.5.2-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:e79aba74ffaf5f78a050d777c184cddf8fdffabab38acf5f3ef1fecbc17895d6", size = 5354892, upload-time = "2026-08-09T13:47:18.07Z" },
-    { url = "https://files.pythonhosted.org/packages/74/9b/b6ee65ea2999fdb7023935e108e6fb776ee4082aa15f159acfa857e578c8/numpy-2.5.2-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:9a0731745a72a184490a582fb4af2533512bd071ace67785b5fdffc0ae58dce8", size = 6679309, upload-time = "2026-08-09T13:47:20.456Z" },
-    { url = "https://files.pythonhosted.org/packages/43/f3/acb18d8b137a393c8e7803a8c994c9e64bde3930692a69d826993113a159/numpy-2.5.2-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4ec954036759bcee3aa484f8603bd9c14f3e776293b85578b8734c2d72777c69", size = 15625850, upload-time = "2026-08-09T13:47:24.365Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/bf/a8e9bb0db815a0e265b5744ebedd3af0bd5faad8604e5b50a1cd012f3c91/numpy-2.5.2-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dc649493697006bc90614a5f0bbc8cb3cb1866715c474e473694968d7e6b99ab", size = 16713664, upload-time = "2026-08-09T13:47:27.965Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/c3/6e913736b3dd6582344af32418b5fb9dab34282e8a8174ae1d54ceb0fc13/numpy-2.5.2-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:cf7de32f486e4ac9e2d93b810f9e9ac72a728dd46a32a0bb403222f27f653514", size = 16986749, upload-time = "2026-08-09T13:47:31.541Z" },
-    { url = "https://files.pythonhosted.org/packages/80/09/7d3b23eff5c7428ef6c01e6f7052bb60d504c4d33e317b36b8959c24ad97/numpy-2.5.2-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:2ffa7bacab3e2ee1b19ed31766bb60bb380b68c23f051e199c5cc598afd68710", size = 18470495, upload-time = "2026-08-09T13:47:35.364Z" },
-    { url = "https://files.pythonhosted.org/packages/a5/a4/68a321d825374f6eb677ffe8ef8c6b9a328304e6fd2e39d9530822776607/numpy-2.5.2-cp315-cp315-win32.whl", hash = "sha256:6b588cc8f902d6bff201c19fd00c43ab8545671e3554d014e12e14139e5e8617", size = 6120696, upload-time = "2026-08-09T13:47:38.561Z" },
-    { url = "https://files.pythonhosted.org/packages/c8/23/deafbb1700f79fae9cd1e91220f133d124cc267de1b584da3fbf6db2f6cd/numpy-2.5.2-cp315-cp315-win_amd64.whl", hash = "sha256:07d4e89f3a9ab0a9ba24264ccdb642b3dd951b2281e8883a5481a4aa79cc31a7", size = 12597324, upload-time = "2026-08-09T13:47:41.401Z" },
-    { url = "https://files.pythonhosted.org/packages/33/cd/3272ba105e3bbbdaeb11357eda31e7a6825ffe159e8171665660299a948f/numpy-2.5.2-cp315-cp315-win_arm64.whl", hash = "sha256:a610dc7e3c52edd39c2bc2375ff9c3fd59cb3ad00e4472d36f83bc1457145788", size = 10680466, upload-time = "2026-08-09T13:47:44.873Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/0e/58370637b1bb70a5c9ce2b43f4b521ccb224e36ccb76a6596b17ae4b447c/numpy-2.5.2-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:40f4d451aed46a8046a1aae41c4e55fb3612273df9c502480135e1501576a34b", size = 16993947, upload-time = "2026-08-09T13:47:48.97Z" },
-    { url = "https://files.pythonhosted.org/packages/10/93/2abcb807712b289d6d60fe4cf30532f98974a8396d885650f3ba5a13026e/numpy-2.5.2-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c081cbe16ba1ab53078e5ff29013621e33c509eedab055775d956427712c236e", size = 12025331, upload-time = "2026-08-09T13:47:52.646Z" },
-    { url = "https://files.pythonhosted.org/packages/8b/3a/2898e003a5fbaf87e76c039b4ee1f5eb390471b4ffe74887c1f34c4e791e/numpy-2.5.2-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:0090ccdd57ec2703e9b49d0bf554767370581c1dd0a6b2bb2b2d9def317d042a", size = 5472336, upload-time = "2026-08-09T13:47:55.403Z" },
-    { url = "https://files.pythonhosted.org/packages/61/a5/23f69d07c544597b29758b31b55c27dc9d541012a2c1496189fef702aec2/numpy-2.5.2-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:6a9bb119fb8dd21ba30b3f0e555b7e2b081bd9883af21ec9c1c633d161cda3a8", size = 6788387, upload-time = "2026-08-09T13:47:58.192Z" },
-    { url = "https://files.pythonhosted.org/packages/15/ea/c0dbdbcf22f43782510a3e492dd3da73c6112b69cac8929d16d127536fc4/numpy-2.5.2-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a839318485284a6fb31be4f8f2c91c8f2cb22f4543c4a8903f12b0671ffe07cc", size = 15667096, upload-time = "2026-08-09T13:48:01.562Z" },
-    { url = "https://files.pythonhosted.org/packages/fc/5e/29c73c31748cdb0f7566642125ba17fd5b56780cddf891b085dab27e4466/numpy-2.5.2-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ba0a474801b8dc67b66bf465548abc90e82b44d2611b5770f33008dcabffe8ec", size = 16751730, upload-time = "2026-08-09T13:48:05.706Z" },
-    { url = "https://files.pythonhosted.org/packages/47/95/02501e8454796bb58dadf7a99d3181e0b464bf264e1003039572f9779fac/numpy-2.5.2-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:0a4035ae1129ff8777f08bfbd44f1e5d8e9c049ce0c2dd78fc0d92c13e7251c0", size = 17038686, upload-time = "2026-08-09T13:48:09.627Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/b5/53a681d91b5c82687067d8ea5035e02d917b5509d6f334cb06484a954714/numpy-2.5.2-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:77843ca236b777e67f8d6b3660ea116e499612703a0ecd7093f316201eb9d8e2", size = 18507727, upload-time = "2026-08-09T13:48:13.744Z" },
-    { url = "https://files.pythonhosted.org/packages/42/06/6e11443f7b64ee376c860506091103bf68f92d2cab9e8d96d4501babf07c/numpy-2.5.2-cp315-cp315t-win32.whl", hash = "sha256:7354826bc6f8f69402e9b7fe28d15fcd34feebd74f856f111585c5b0c9fb0251", size = 6269775, upload-time = "2026-08-09T13:48:17.543Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/18/195d6b86cd72dbbc501edfa778005fa6b87afd34c153e46028cd3a0938f4/numpy-2.5.2-cp315-cp315t-win_amd64.whl", hash = "sha256:e5651f3f87add730ee6608d915009e19c911fba0cb000c7e3ea994b7d768eb12", size = 12782559, upload-time = "2026-08-09T13:48:21.023Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/07/458c344f0f0c178f4481dad5cca790626ffe4c34eabf9467069d06ee4999/numpy-2.5.2-cp315-cp315t-win_arm64.whl", hash = "sha256:5f8e00be2ec6f45f4e8a41a527f68d44a7d96fee92a650e4d8b1326f77f61e6e", size = 10748103, upload-time = "2026-08-09T13:48:24.21Z" },
+version = "2.5.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/01/11703282db468b85f6f7b8c7f22d058de5970d5c7e60a3a8aaa313c3de36/numpy-2.5.3.tar.gz", hash = "sha256:df2d5874ff183595a4ba404edd04f6bd9b5505c1d7708573f6a6c17489a67563", size = 20791231, upload-time = "2026-09-06T16:27:47.073Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d6/50/8fdbb16af64895706a45f06a4068e29db732ec180f3c1375f14123359138/numpy-2.5.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cb189f09db39283b26bfd061ec16189e14f71c6755207f72a0f7540867afe5b9", size = 16994982, upload-time = "2026-09-06T16:24:29.244Z" },
+    { url = "https://files.pythonhosted.org/packages/60/39/789131c1188c078dcb3a1692e72e1e050c68b88ffe72c9ccaac9bcd7a9cd/numpy-2.5.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f59a878c33d6b88122d80d239bb3b845d58708750b0cb06a09aebb9b18ec696c", size = 12009327, upload-time = "2026-09-06T16:24:32.491Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/59/a312e95696e5f601914dd8b6dd844692ba61670807417e24b68e337b5c70/numpy-2.5.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a72f874bc9e10e4b8f80426fb49716d5141f64442a0c8418065093ec8017fbb0", size = 5445405, upload-time = "2026-09-06T16:24:35.071Z" },
+    { url = "https://files.pythonhosted.org/packages/30/d0/5623a1707ed4fe16e3909fe3cf5ee3da004ae677ad23d83bbf3adf1a6faf/numpy-2.5.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:fc36dc566135b5eceec4cf89758fcb719266a019ef07dae1754ae7c9f617ef3e", size = 6783213, upload-time = "2026-09-06T16:24:37.253Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/32/84146fc020ad3c25f805f70ab60da46fe3c540a21369754a7e4369754b6f/numpy-2.5.3-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:76c2c1e6bfa5c84adc6434dfbf013aa92096a7985221762c8f11fedfd20fff58", size = 15687872, upload-time = "2026-09-06T16:24:39.751Z" },
+    { url = "https://files.pythonhosted.org/packages/65/af/aa78d1a88805456e212b65461354cd943197fb9acecc4c90fd12295123a3/numpy-2.5.3-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b7e18c623bb5c95acb3b3328861272816ba199fb531921c5d6d0b675f1fde9e3", size = 16717410, upload-time = "2026-09-06T16:24:42.745Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/24/faa79d865e69a97ba17473b23a1b74094b2259c03e820c70297293b9ea49/numpy-2.5.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4f8929ee6c96bfbd7b4ed2032e0c03af86fe1826740ab61ddabf9072d06e57ff", size = 17040975, upload-time = "2026-09-06T16:24:45.961Z" },
+    { url = "https://files.pythonhosted.org/packages/62/4a/8877e629445a7176297dffcaf9c485faa96a95d81728a62521ad55bd4c0f/numpy-2.5.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b5d93cf48f687479941d12b69c873ad2cc76bbd487f0091c2200636497f34034", size = 18476479, upload-time = "2026-09-06T16:24:49.35Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/db/35e1c2d38b04cbd5b731f9d71495e055e813197669d22b612f11748d2ff9/numpy-2.5.3-cp312-cp312-win32.whl", hash = "sha256:bf63afbe037eb5d2fe87fbcc7778e61da53ebaf21d938a4515aa73b62532a5d4", size = 6133378, upload-time = "2026-09-06T16:24:51.915Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/a1/accf6d4f0c80c5d9ba9735d6b1550e444180599f34dec69ca01360f717ad/numpy-2.5.3-cp312-cp312-win_amd64.whl", hash = "sha256:0a59a421a32580a009e8a1751345bf829631b990dc1794b80514ab722b435def", size = 12567828, upload-time = "2026-09-06T16:24:54.255Z" },
+    { url = "https://files.pythonhosted.org/packages/22/43/1764aff32e4652526ae2f71fa8b3efd8d25c8a3d6926914454e47138ed1e/numpy-2.5.3-cp312-cp312-win_arm64.whl", hash = "sha256:ccb32e0525d29e8b0572eb84c9a57af0e7a4e615726927506f55063c62414034", size = 10485432, upload-time = "2026-09-06T16:24:57.278Z" },
+    { url = "https://files.pythonhosted.org/packages/79/e5/8fb89cd46d14e35699d13bf943a5f5f441ecee8667120a1f6105ab89e349/numpy-2.5.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:66a78fe4556c60aceda5916f9eacd638b18e9e681016ec302dcb4682d6d4d034", size = 16991061, upload-time = "2026-09-06T16:25:00.411Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/06/9dc9e48b5e5e941c8b10350c5ff2d721da42a20517d911d15544246775ff/numpy-2.5.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:92f30e89b8ee0ecf363033576c422b2f58fed6a80bed0aa48dff6d14c654663e", size = 12003676, upload-time = "2026-09-06T16:25:03.475Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/2a/98282aa5b8f58b1157d440bb6282eed47e3632a5de53a714fbab17e659fe/numpy-2.5.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:f9a2353b37a1a9e78fd82b27ad7e2a32a2d036604d18f02b05e3136c62ca3b09", size = 5439695, upload-time = "2026-09-06T16:25:05.978Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/f9/b6533d777be9d6ffd29dc1be0867e563e6e8cc9a220ff1b716adc317f060/numpy-2.5.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ccbc4665079665c3cf3bab4db9f6b095370cd6437d66be549b6c2a1fd19e1958", size = 6779395, upload-time = "2026-09-06T16:25:08.599Z" },
+    { url = "https://files.pythonhosted.org/packages/73/85/735720d04ec197c5dcfacdfc9922667c7f1f5f496a279b7ba4d7c74c4cc7/numpy-2.5.3-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c76d5dde9f445058f83d0c02af00557a4db91de9a9a57c0df87d1535001d654b", size = 15681750, upload-time = "2026-09-06T16:25:11.173Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/1b/3b16a9bc514a440a7a0883684111dcb1ef1aee960af2ca95da8fc775f124/numpy-2.5.3-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a5fa86b80fd24bcd1aff83ad23be44ea323de3f787be8f8b15d4a65621e25321", size = 16708577, upload-time = "2026-09-06T16:25:14.171Z" },
+    { url = "https://files.pythonhosted.org/packages/69/c4/386f397831b07328b639c96c5b62719346cf4baf07c68d927239752b1534/numpy-2.5.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd4cb9ad3c7889b9b3fe0a9a9fb5d2ed26f9879bff2608d9f01aed147a20d231", size = 17042047, upload-time = "2026-09-06T16:25:17.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/3e/a700ecbf36e85ae8328fd3b0e12eeddc22ed6358a64cb2bd913e0d195d65/numpy-2.5.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1302b90c0e52281681b2975adfe8a860cb7b12216a27b4b0b4207c44bf7bccf0", size = 18465724, upload-time = "2026-09-06T16:25:20.949Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ee/38e785e88a4045f6ad1d1f2808dcdfafdca48c760260c0587bf171e29fc9/numpy-2.5.3-cp313-cp313-win32.whl", hash = "sha256:1c80eabb4035ecf4ca9cd49cde8a9fdd69a729e63e6474887d1523ade7aa277f", size = 6129003, upload-time = "2026-09-06T16:25:23.664Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/ec/100f2b1794ede74a9b3d7ec6b9736927f56713414c1dfe19ab6c383494bf/numpy-2.5.3-cp313-cp313-win_amd64.whl", hash = "sha256:71cad2b2a7451ab79d8f5e71b453485b6775963d5cf794179144a7463fe6e8ec", size = 12560965, upload-time = "2026-09-06T16:25:26.602Z" },
+    { url = "https://files.pythonhosted.org/packages/80/b1/7dc825ca94c12acebbce4c37caa5e198695eb31424bc579679f32b1bb49d/numpy-2.5.3-cp313-cp313-win_arm64.whl", hash = "sha256:8e4dd766076855b5ff7ea52fa5f07ce26286726e0f8bff446b7739d02e6ea204", size = 10482343, upload-time = "2026-09-06T16:25:29.772Z" },
+    { url = "https://files.pythonhosted.org/packages/70/78/cf416f15dc29375a229d9dfebf8db6e313f291580b39fa1a568b6052bb07/numpy-2.5.3-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:350ba9783ce969cf9f7ce6e6a9a58e1a6e2a19ca025b7ee448c4db727706212a", size = 16998686, upload-time = "2026-09-06T16:25:33.171Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/59/abcc2d8def4fd60eec7d87f92d27c13448ffd9ab14339bcc63a0d7a2fdea/numpy-2.5.3-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:012e66aca395d795496446e52aeeb5866312a5d4d3f27da270e5a0b43f70dc5c", size = 12013862, upload-time = "2026-09-06T16:25:36.748Z" },
+    { url = "https://files.pythonhosted.org/packages/94/75/4640d2d6e4b64a049e48425a82728a41ef4adb61332d2cba68055774878b/numpy-2.5.3-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:adc1ada2662f8a5f960b8a10d9986897e7499ef07e06d4cfe7197f8cce923c07", size = 5449793, upload-time = "2026-09-06T16:25:39.476Z" },
+    { url = "https://files.pythonhosted.org/packages/96/cd/625b57ae33d4ca560f32cc0b47b4a5922146d9beb998ddf773900d440a73/numpy-2.5.3-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:54a115e5a73b8fc44f0cebef486365a1894b5c9760685d4558b72b7c3eb846e0", size = 6785176, upload-time = "2026-09-06T16:25:42.069Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/72/12918652e7912ef9751e8694c88820fcd1908e0618cb23f5f3caa6004b7b/numpy-2.5.3-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:be5a8381859b6da607c84f4f7d6847725f1cf1853ef8a2c9e115b7d58bef47dc", size = 15703377, upload-time = "2026-09-06T16:25:45.135Z" },
+    { url = "https://files.pythonhosted.org/packages/45/8f/9beacf79ca7c650688ad0baa80931adb988fe6e6e5d5903c23cc3dbd70eb/numpy-2.5.3-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b0521d0f4aebb6e06189451025fa17a913287b13c03d5fe05c017333b654ea5b", size = 16711928, upload-time = "2026-09-06T16:25:48.461Z" },
+    { url = "https://files.pythonhosted.org/packages/09/8d/41d0a56e1ac4c87495c897a211b1368691b7237aadabec8b3b8f3a74d48f/numpy-2.5.3-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9deb49575e5b0b94ed72c8a64ec4d033381adc27e9060ae842971f697ba96104", size = 17059507, upload-time = "2026-09-06T16:25:51.873Z" },
+    { url = "https://files.pythonhosted.org/packages/08/1e/0dfbc5cc251d54e2af790f254d24ec38637fa97ec7d5d11de7ffed787098/numpy-2.5.3-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b00eefbcf0f292945c4b4dec2ae845389ef5bcdcd596e6e4328051db5b5ba694", size = 18471002, upload-time = "2026-09-06T16:25:55.233Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/2c/dfa40f6991f8185c8c30ffd023dfcbb11888e823cfab9557b920f3bb7bed/numpy-2.5.3-cp314-cp314-win32.whl", hash = "sha256:c2381f82999704f818e2c987a865050e285ec3621262c66d40f5a96c8f899f8e", size = 6180485, upload-time = "2026-09-06T16:25:58.157Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/73/d2c08231e4fde7e415501fd02c715d96e98599b2d8384445933944152984/numpy-2.5.3-cp314-cp314-win_amd64.whl", hash = "sha256:2c25dfa72943e4336ddb6b0ee4277b47a0c85bede0807530ec68103bf58e2c10", size = 12698179, upload-time = "2026-09-06T16:26:00.789Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/e9/dcdcc9b95cf5f49815055573aee1b11cfbf5299f38a180e437ded050810f/numpy-2.5.3-cp314-cp314-win_arm64.whl", hash = "sha256:15aa985ac73a8db02db7663381aa109510449d3819d37206caed27b33a65a8a6", size = 10769383, upload-time = "2026-09-06T16:26:04.011Z" },
+    { url = "https://files.pythonhosted.org/packages/49/c4/af8bc08a7ef4e1529a7c0cf24969accce316b783999802089a581ec99272/numpy-2.5.3-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ac7bb1c52d445bd4f8f7f97fefe6abc3a084dc4d63df50d79b17fa2b78e89297", size = 12132668, upload-time = "2026-09-06T16:26:07.138Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/ae/0f15eb56d4ec5e13c1f7ff04ff407f997d1acbadb45d3e1f2e2645a8f43c/numpy-2.5.3-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:e6ab667ba76450084eb64013762c438ea76d9d29cc676dcd6c2e9892ba37f841", size = 5568580, upload-time = "2026-09-06T16:26:09.828Z" },
+    { url = "https://files.pythonhosted.org/packages/23/fb/c72a8f25d4b6e96c354e7ab45ace3b27dc11e5d6a13b6c7d0cd6b08bf112/numpy-2.5.3-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:f7fabeb6cea87d65f3b926de33d03fb016cfdc29314c90974383b5582ae72891", size = 6882634, upload-time = "2026-09-06T16:26:12.524Z" },
+    { url = "https://files.pythonhosted.org/packages/07/a9/968c90ed2ab15060c338e8137f1215b5a60756ae07328e0a60d1c6734df4/numpy-2.5.3-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1fb6f8fb9ff0b3a69f52c66ce397b0246583e9f28616231b0e32ca49259a5fa6", size = 15748923, upload-time = "2026-09-06T16:26:15.092Z" },
+    { url = "https://files.pythonhosted.org/packages/59/08/9df04103947b95e3b6b1f2ed1a70521f325647a31b82da6a2aae3a485508/numpy-2.5.3-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:93e1f5447e2b1e479d7bd74701e84746b86450cff1fc368b132d195e2b8f8211", size = 16746748, upload-time = "2026-09-06T16:26:18.43Z" },
+    { url = "https://files.pythonhosted.org/packages/41/a0/14c8d5fe5b53a334aabb653deb391c0fef49558f491880ea300ed6785224/numpy-2.5.3-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:c00abe94c1a69d75d827dcf1c025b25c8a45d230b3bcd77a9020883a1b047653", size = 17111561, upload-time = "2026-09-06T16:26:22.113Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a6/d7e96e42f01522e154c32489640f16dfc4f6181d165d05fc3bec8c2c4999/numpy-2.5.3-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:536f963710a4e63934d80ac0dc4f478804a83e9a84b6828018f25d09953ada33", size = 18513945, upload-time = "2026-09-06T16:26:25.401Z" },
+    { url = "https://files.pythonhosted.org/packages/25/39/3453afb7119d0449ef11c886874120ff180e2c337760e0e2d88f70f1a945/numpy-2.5.3-cp314-cp314t-win32.whl", hash = "sha256:4c8a6d2ebce6305fd82fbefca827775437147052a976ee7c94b36a0c1b52ac6c", size = 6335421, upload-time = "2026-09-06T16:26:28.175Z" },
+    { url = "https://files.pythonhosted.org/packages/99/01/22815d2b19a1a746b1d45205cffebb3fe511a18acb75fba6c88491fc9894/numpy-2.5.3-cp314-cp314t-win_amd64.whl", hash = "sha256:9a37475425b431b4d060f23b4f52cd2f3aef6bc7c654bd760adf0040eec9d435", size = 12896420, upload-time = "2026-09-06T16:26:31.265Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ee/a7cbba67eeaff038dc29ca8b98a88396c8b0cc9c89d4924f4a27a5c9150b/numpy-2.5.3-cp314-cp314t-win_arm64.whl", hash = "sha256:2d8240cb4c16fd831074aa2b2cf9fc54664d826341d61c372245b96a74a49a9a", size = 10857177, upload-time = "2026-09-06T16:26:34.167Z" },
+    { url = "https://files.pythonhosted.org/packages/45/56/78194492883ff5eec90423fe56a3a44b154da047d88a6307f629713c584f/numpy-2.5.3-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:a6391fafaba97500887132cd582abc6e19452b1ac775a47caa7b24490e152058", size = 16996531, upload-time = "2026-09-06T16:26:37.287Z" },
+    { url = "https://files.pythonhosted.org/packages/11/39/dd55c0af90bbab564b09ae3b0aa60ec5c02b900fa4f1ba23440525c8b32d/numpy-2.5.3-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:09d5a423c71ad5feb5625844ad58050e35df43871004b52ac9c0ad44a56775be", size = 12012569, upload-time = "2026-09-06T16:26:40.707Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/51/04f67d32e4862b281b1cb84ceeaed3421189a84fb6fb51a391cd6d5009f7/numpy-2.5.3-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:f9579f383d1bf9df80081e72760e84960a7fd4f88cf0c9e535a8597c9bb646f5", size = 5448498, upload-time = "2026-09-06T16:26:43.435Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/c9/25b4dc0dd1344ec26c7319e84fd4e9809d2b5628f4e12decd618036e5178/numpy-2.5.3-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:86bff898a431c0fb71f7610b75726e75a54d47b37edc9d537f48de63bb3c0b90", size = 6783026, upload-time = "2026-09-06T16:26:46.374Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/c7/29285be1e5232a6e7ee3268a33c85843f5a8ee93350c6465cddd66ebbf76/numpy-2.5.3-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1f3ed25271581281f2fccb1adcedfcde4c07362eec69189b50baf6f90e3ae159", size = 15697322, upload-time = "2026-09-06T16:26:49.415Z" },
+    { url = "https://files.pythonhosted.org/packages/55/49/bbad5335fb4996a16881f853ff3e0ba582f01720e55c89b1c06b8fc42a90/numpy-2.5.3-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ffdc76bfcae6b255dff75202c5e7feaf95b40246bc0a17944facc1fecf9f79ab", size = 16708995, upload-time = "2026-09-06T16:26:53.127Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/e9/1df35483760b04a65ea44669f89dc64f30e5aca098b48ceb8b1310b0e0fe/numpy-2.5.3-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:116f96cadd935c6122e9228d676fe7ede19e741f5c8bb1c3cddbe0c51ccebea2", size = 17052508, upload-time = "2026-09-06T16:26:56.464Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/99/66e54da8265cc8be8a7382bf96edce17aaa2837d6f484432025932a3caa5/numpy-2.5.3-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:09ffa5d903faeaa5c4dd05009cf81c8bab9f2cb37c548b8d39b65b4cfa7c97f7", size = 18468224, upload-time = "2026-09-06T16:26:59.966Z" },
+    { url = "https://files.pythonhosted.org/packages/01/bc/b5e90a91c115168d793dfd2ad9c69c438c2fe7a13a437e770bc5b078e732/numpy-2.5.3-cp315-cp315-win32.whl", hash = "sha256:e01c918ac3d48e18a927cf7b14a26a3e29ff2bdf2eacb976da0aecd6a43ed034", size = 6179919, upload-time = "2026-09-06T16:27:03.166Z" },
+    { url = "https://files.pythonhosted.org/packages/37/ea/780748fd3985109075514ef8fc64cd25f943e40dde13a6d59141eb268fc8/numpy-2.5.3-cp315-cp315-win_amd64.whl", hash = "sha256:e931e4f499e0dc7ef29d269a8e5b35dd722e5d14be07df6240166ea7c6532fae", size = 12697656, upload-time = "2026-09-06T16:27:06.153Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/16/407be69a2a87c8cab64d95975a8977a426a29e138f07e276ec258f0fe4e5/numpy-2.5.3-cp315-cp315-win_arm64.whl", hash = "sha256:26e15e4aecd8617dfbaecb37d223e365d7b39411fba20454be2670a96aa74cb5", size = 10767601, upload-time = "2026-09-06T16:27:09.297Z" },
+    { url = "https://files.pythonhosted.org/packages/44/bf/a97ffb01e41d50a32a9177aef942a4d0e389a3daf451d04e5f38ef6afb87/numpy-2.5.3-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:6cef4bb1706dfec49243c05d921eefb4e190d41e2528b30d8035ea1f36b4c24a", size = 17090092, upload-time = "2026-09-06T16:27:12.907Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/24/136c02f2c2af9a067a84d0c3aa10c99012c0476fa5066732fa4a4202557d/numpy-2.5.3-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:d1c89973648c85069c5046ad460f7b8a00218b29a2e42359ac8cc63e9ab94832", size = 12129429, upload-time = "2026-09-06T16:27:16.089Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/6c/b47582d6597789bf946d5efbeb6b9e56fd8bcbd5efc6fbf51dbe1ea31eb3/numpy-2.5.3-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:214045a5bf00113a146ab9ee9730c44501af6723cdf1f6830932f7b5ef2e7af0", size = 5565452, upload-time = "2026-09-06T16:27:19.868Z" },
+    { url = "https://files.pythonhosted.org/packages/be/b4/ef3cc6da73774202d4deae16bb321fd8298a4e0561e3539f8c4be237d916/numpy-2.5.3-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:8617bbfae4486cf99c9f899966699428d19da931d06ca94ad3da986c76e15997", size = 6876736, upload-time = "2026-09-06T16:27:22.232Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/24/e3813329498596cb842703dcacac1741612ed9fb9c4e6a3e0c7e2ebbc597/numpy-2.5.3-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:595d020938c84e320bcf40ad71089e108eac0d377cd018e14a8c094f39e98d85", size = 15745777, upload-time = "2026-09-06T16:27:25.181Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/9e/4e7a07fd0776dc2210cdacf2010be8665194d094defc10c419d7dea794cc/numpy-2.5.3-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6f24021b9f22bc6301c37b196974a92c1c18dccedb6fef3dd252e95f2d6adbe4", size = 16746949, upload-time = "2026-09-06T16:27:28.576Z" },
+    { url = "https://files.pythonhosted.org/packages/91/db/01674c0e20335057813a00c2ebd546ed25bff9ed7914f9bced00f8c55d94/numpy-2.5.3-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:71b39d9f935b6ec0f8753e3e2afb51e3efba6f2e05b68b32a40754d24bcd4a3c", size = 17108994, upload-time = "2026-09-06T16:27:31.946Z" },
+    { url = "https://files.pythonhosted.org/packages/45/7a/584c5e71f8d378e57cac0b033891ed65c683ef90573ba4854e8c28203db0/numpy-2.5.3-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:6b05c171afb3aa07adbd20abc00aea86fe375beb0fdb9ef780ec5b7f63bab1c0", size = 18512266, upload-time = "2026-09-06T16:27:35.196Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/d2/4e1014173aa3c55e6a756e0e567290743a6ab33a288460374d7ef6bcd239/numpy-2.5.3-cp315-cp315t-win32.whl", hash = "sha256:f54660b0eb6b0b9f36e7fe1cdfdff472028dd0d14acd9b9b65098efbad059469", size = 6330292, upload-time = "2026-09-06T16:27:38.149Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/b0/ff5658a58199b7bcaad87bf260eef6713d9d42cca4e028f935b4fc5fbac6/numpy-2.5.3-cp315-cp315t-win_amd64.whl", hash = "sha256:1aad64d99730d013cfc6debafed22783b4fc5a7f4b8bc744d2d8cf7dcc880551", size = 12884918, upload-time = "2026-09-06T16:27:40.965Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/0b/b12a2df5d1b774bd9007a6fdff9381145b6223d37f11afc9c37ab0efd9a1/numpy-2.5.3-cp315-cp315t-win_arm64.whl", hash = "sha256:befa1ae5bd6030b3f512b43ff3fa5290bbed6b84411a44244b14adf835f5b89d", size = 10850807, upload-time = "2026-09-06T16:27:43.868Z" },
 ]
 
 [[package]]
@@ -3016,27 +3016,27 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.16.5"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f3/85/c8e12473c93018f92d19dd988a294202e1c27426c47ec4de53ffb847b8d8/ruff-0.16.5.tar.gz", hash = "sha256:1b88500f9ffbcab3dedb0082c9f9492e91ec3d618aac1236a3e0189938f7040b", size = 4912003, upload-time = "2026-08-27T16:34:18.258Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c6/b6/77c90a970fe2dae17a723acbd011043ea97c98d7deacccefdc4ba74ec512/ruff-0.16.5-py3-none-linux_armv6l.whl", hash = "sha256:12e5f673e774c35fbb62f288809c7653b73445f8ecec6b6063fd6ea3521aa14b", size = 10011941, upload-time = "2026-08-27T16:33:41.287Z" },
-    { url = "https://files.pythonhosted.org/packages/4b/46/6cf67cf6411885a1d6f7f6d801682f155536a85176d10b605e2ceffed8bd/ruff-0.16.5-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:eda58a5802de40e7ed5b32b64e0b32539338cc6fcd2c78f61e3ad6a0d79f51c3", size = 10204049, upload-time = "2026-08-27T16:33:44.056Z" },
-    { url = "https://files.pythonhosted.org/packages/46/fd/c8720ca7a090abf0c2fef4abe8a5ef6e5127ed15196d8886ff75a2b370e2/ruff-0.16.5-py3-none-macosx_11_0_arm64.whl", hash = "sha256:c5ae9a7b9a8875131f40f8fe967cc86abf899779efd663cb7ce3d572d01da7eb", size = 9809037, upload-time = "2026-08-27T16:33:46.257Z" },
-    { url = "https://files.pythonhosted.org/packages/43/45/a684caacdedaca180f52bacccc40bf0789d2c5a7c75f25324853e9eaedb5/ruff-0.16.5-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7b719b0a1f4d59710d283ab2965f621684a108a9e41da622e3b23f0326cd0025", size = 9964129, upload-time = "2026-08-27T16:33:48.352Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/f2/5d2bcdaca6b5b93d1b4dfc166cd2aebf7680143a1b38a28759df13a94d31/ruff-0.16.5-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2298f2780ed1be0c5cb1361e32ab7b1467f3cce7dabe101d2210a314f2fe42e9", size = 9821518, upload-time = "2026-08-27T16:33:50.57Z" },
-    { url = "https://files.pythonhosted.org/packages/aa/ff/011cce29accf9257d5974145b733fc653a37985ed6825413a3987cefbfe0/ruff-0.16.5-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:258f29035a2dd021e7861e631b227a5b3f14e50c1184c9a6a122c5f4576154d7", size = 10534835, upload-time = "2026-08-27T16:33:52.522Z" },
-    { url = "https://files.pythonhosted.org/packages/d7/5a/f0cf109bada9bba0e96c90c21c9f9251803f57225c32d293327a03c710d6/ruff-0.16.5-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9a4f0432966834019c74d1b7e5c51224305d7713f3d7faf3e7451f1a3be3cde", size = 11252550, upload-time = "2026-08-27T16:33:54.521Z" },
-    { url = "https://files.pythonhosted.org/packages/63/4d/1d481aaea2046c6a7ed7c291f9004c669cce3c087b6b376ed5b08271e3fe/ruff-0.16.5-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b5eb3a8c3d0ade9cea42b591fd530368e8798380e30e0a308b85a5cf718f09ea", size = 10777949, upload-time = "2026-08-27T16:33:56.88Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/34/ee245ca55f64443233034b3d02b03236b19242004281247c079390b7facd/ruff-0.16.5-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ef0f69e191a13a3c9816f63163c88790cb12cd157bbbb384e9c44745702ab105", size = 10311656, upload-time = "2026-08-27T16:33:59.12Z" },
-    { url = "https://files.pythonhosted.org/packages/a7/4d/c33a333e341c0a2b96c715b52d89a606f5a34cd4ac493cd9b8d0187186b8/ruff-0.16.5-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:0eeab41fbea2c42f98dfb9822cdccda9d24ba38d49f6dc945b5c236d48f0ef29", size = 10532125, upload-time = "2026-08-27T16:34:01.166Z" },
-    { url = "https://files.pythonhosted.org/packages/30/e1/a64cef78b40192497bb98a27a8aa8f2c98ee9ee15bc97f7712d94ef32937/ruff-0.16.5-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:f0768e9df4300713fff30733c87575f68b6f1d8de41184e505b7fdd9c0c95eaf", size = 10097648, upload-time = "2026-08-27T16:34:03.16Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/4e/4cdc9ed3c3e109d2f71e62572a37457298d7bc7501ec3138babb7ed32bbd/ruff-0.16.5-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:95cc70cdc7aa80c338de356279d2adbeb2de0f520b9ecd8aba75b94e95e02f91", size = 9829344, upload-time = "2026-08-27T16:34:05.134Z" },
-    { url = "https://files.pythonhosted.org/packages/39/4a/31ed35ce31729955fc583ee0d176d6e784c1290cb0b0a75cb2134c1ab72a/ruff-0.16.5-py3-none-musllinux_1_2_i686.whl", hash = "sha256:d185c8398ded1bfd91c0c2cb258346307571eccc473a8490af8c3977399c384a", size = 10277117, upload-time = "2026-08-27T16:34:07.425Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/a0/60356d86687b4b666d593df213f4dc3041750d024cb7bf2cfa81cfd65c2e/ruff-0.16.5-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:fb8e3a3c4c6a784150a7ced53b015f4b253fc2bf97a610886419ead64b4756ef", size = 10711653, upload-time = "2026-08-27T16:34:09.712Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/20/656d67f5b25ca9bda4e02b1de25867b2954e1d19e03648060f167ad0f4cc/ruff-0.16.5-py3-none-win32.whl", hash = "sha256:288b0a5f080492fe5635db849f9e2e84aa3cce7b7f0e955997d416c507c76a26", size = 10034250, upload-time = "2026-08-27T16:34:11.8Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/42/ee8e68a207b9127fcde6c3d7e197def432f346cb1af159e1fa14ca0d1cdc/ruff-0.16.5-py3-none-win_amd64.whl", hash = "sha256:ddc6385fb2137f616357ca03d6c74f4be987f80fed4008566b754f6032b8546f", size = 10516714, upload-time = "2026-08-27T16:34:13.963Z" },
-    { url = "https://files.pythonhosted.org/packages/73/e3/7df5a396e445b9ba49ce9a9437439a4d80042c61c0ade199abf8d16de1ac/ruff-0.16.5-py3-none-win_arm64.whl", hash = "sha256:a64abe90968719b851bb7cedffaa8753fbdbdadab483089682db623f3edc587e", size = 10391564, upload-time = "2026-08-27T16:34:16.064Z" },
+version = "0.16.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a4/7c/6adb35d70e7c027e308274557901c7e00fb3407750faf3620c184ae058cb/ruff-0.16.6.tar.gz", hash = "sha256:dcf8a73d2ff77e99dde91244b4da16feba7f14e6beeb4015dee7c5a909e99050", size = 4921251, upload-time = "2026-09-03T16:57:29.037Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a4/28/9cc1b79639e284ec103f43c88c644db4eb58cbd0ea1ca11f1193435369ac/ruff-0.16.6-py3-none-linux_armv6l.whl", hash = "sha256:61c368c26bf8e973e5ab14a2772de587bc068ea3f9a277f673380749b4898fb8", size = 10015638, upload-time = "2026-09-03T16:56:40.986Z" },
+    { url = "https://files.pythonhosted.org/packages/71/11/627d342ef727ea7794edf74fe23d60a074b02c3acc2e9436684e782286ca/ruff-0.16.6-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:ecf4f068e2e123e43a26e9db4e19524cc56563912404e83bbfca375757e45a32", size = 10220762, upload-time = "2026-09-03T16:56:44.681Z" },
+    { url = "https://files.pythonhosted.org/packages/43/d9/b75668ce41e4c8d073d18d6d08672ba6906ce45d5c06ea4fdb2e84ce3853/ruff-0.16.6-py3-none-macosx_11_0_arm64.whl", hash = "sha256:99b62ea33baf130f50368798d841f0d95527b6d817bf31817b65dd058f1d314c", size = 9835082, upload-time = "2026-09-03T16:56:47.142Z" },
+    { url = "https://files.pythonhosted.org/packages/99/97/123ab10b05cde889c107c20f5a9774955104b5552796a2a8584b089ae8eb/ruff-0.16.6-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7fbf89013f2bb3f6835a6038ff658dc8a1b38c98dc8e724b964168ad4e881876", size = 9949304, upload-time = "2026-09-03T16:56:49.813Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/58/a4a2c59dd2e5b85929c912d9cac3056eb9ee8c7e75e9b9fe3e109174966b/ruff-0.16.6-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:56a67065e22efa6bc4d498299d3bb06c0c90aace8fac2068b5a12f9dc4d8d51d", size = 9840612, upload-time = "2026-09-03T16:56:52.368Z" },
+    { url = "https://files.pythonhosted.org/packages/61/6a/ff8c8626a786c4f49d48ced4a752dadbca65f5263005f9c2416578194694/ruff-0.16.6-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e25cc89174874b176a157e4428d66761c2c0c006654419bf384f967f361ff1b1", size = 10543465, upload-time = "2026-09-03T16:56:55.089Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/bb/c47535923365f337b82e28192e4e9eef2176511007cfd99a62fc22df5dad/ruff-0.16.6-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0700580ed5303723cb3c11c2f1d2a8913ce77b7ea86646dddb887f5417a9ba70", size = 11267576, upload-time = "2026-09-03T16:56:57.791Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/50/e5119a5212b5cd63b51e1f4b25e7bd636a6668fc069a3160b108ad7e3c16/ruff-0.16.6-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15f1d0b6e165a6e56567befb6629f8209271311d990bae0f37e6d065035ef5f3", size = 10781993, upload-time = "2026-09-03T16:57:00.666Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/98/083d8b4ef3c51a0d19db84367791cbe9f44e4b53343d19dfa83556e1cd9a/ruff-0.16.6-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d72c591a96986ee4268860e2b7235082129ca5e4cb9cbba653a4b57c11893757", size = 10317748, upload-time = "2026-09-03T16:57:03.428Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/29/68f7ff2c5ad95f19f00627ac2de95644e25fe47371ea60b2db1fd952315e/ruff-0.16.6-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:65a006baa18f33324325814c864daef03541d51564b98c517610ea756ab7003e", size = 10540096, upload-time = "2026-09-03T16:57:06.182Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/f9/79a8f6de85968641d68a7863aeec577551924ef066a990a48ff93167beab/ruff-0.16.6-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:cd02a7bf1a21a8735228a3e8c95a9dc5cf86bd2a52194f4aaae2a5755b4de0f4", size = 10100494, upload-time = "2026-09-03T16:57:09.194Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/e8/b81a22d9b90c00b892ccf2fa2ac36fa95de4c13ab85aea3e73795cfe4651/ruff-0.16.6-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:31b36f1e5ad85e0737f09d2be4e512e2e283583c14015da3b9dc07359ac0fc88", size = 9843663, upload-time = "2026-09-03T16:57:12.168Z" },
+    { url = "https://files.pythonhosted.org/packages/39/aa/54f516ec5e5a11c4afdceb1c454ebb054ffb96e4f4a1705580b4346abd35/ruff-0.16.6-py3-none-musllinux_1_2_i686.whl", hash = "sha256:61029b4ab4aa723fd3064fab96b1d814492596bf0c792679fffcbde1e1679953", size = 10282461, upload-time = "2026-09-03T16:57:15.077Z" },
+    { url = "https://files.pythonhosted.org/packages/52/0b/38d0aa8aa32372b96dc44f97b22e576c4147808271aab7b2cb1e353d4445/ruff-0.16.6-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:9ac8998457832c2061709d900856b7ad271dace0cb41f346588d540162bfa718", size = 10728808, upload-time = "2026-09-03T16:57:17.797Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/e5/9e274e24eeb027640ffc7442f21239f16d17f47acec15ae34f32e03a5c79/ruff-0.16.6-py3-none-win32.whl", hash = "sha256:0b87d9d16fcb63e8018423ca1d50b7260f15cb2da33e30db4baad4183a948c25", size = 10049212, upload-time = "2026-09-03T16:57:20.55Z" },
+    { url = "https://files.pythonhosted.org/packages/22/31/72472449414223ed1a2da236b992adbb1a2ae59e34794574810f60ce068e/ruff-0.16.6-py3-none-win_amd64.whl", hash = "sha256:10d21c51c3495d8eaea7b703a16592117ea6eb1d649e36335aa965ff1173eb39", size = 10556402, upload-time = "2026-09-03T16:57:23.501Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/07/d781f8f8e1ac24bef9f3269cf62ffb1407ca24c3a8f12e5e22874f90528c/ruff-0.16.6-py3-none-win_arm64.whl", hash = "sha256:7a976c79b958f94e50a022a19f0f8c87387448020935ec14fc74331bd0a7f2c5", size = 10412850, upload-time = "2026-09-03T16:57:26.416Z" },
 ]
 
 [[package]]
@@ -3227,15 +3227,15 @@ wheels = [
 
 [[package]]
 name = "towncrier"
-version = "25.8.0"
+version = "26.9.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
     { name = "jinja2" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c2/eb/5bf25a34123698d3bbab39c5bc5375f8f8bcbcc5a136964ade66935b8b9d/towncrier-25.8.0.tar.gz", hash = "sha256:eef16d29f831ad57abb3ae32a0565739866219f1ebfbdd297d32894eb9940eb1", size = 76322, upload-time = "2025-08-30T11:41:55.393Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/d4/e85ce614bf45b1a7fe13b82cc687819c2eaac5a1dd94b84834322095fd98/towncrier-26.9.0.tar.gz", hash = "sha256:ace9031631c718cc0709107b8755e6e31350eb8acdc877af43df3177addb9a55", size = 79338, upload-time = "2026-09-04T12:57:25.341Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/06/8ba22ec32c74ac1be3baa26116e3c28bc0e76a5387476921d20b6fdade11/towncrier-25.8.0-py3-none-any.whl", hash = "sha256:b953d133d98f9aeae9084b56a3563fd2519dfc6ec33f61c9cd2c61ff243fb513", size = 65101, upload-time = "2025-08-30T11:41:53.644Z" },
+    { url = "https://files.pythonhosted.org/packages/82/88/f9340b545dafa64de053798e760515a2736fbb60092cf9aa6b146ccf3ede/towncrier-26.9.0-py3-none-any.whl", hash = "sha256:ae4d223e6aadaff98d29b7f09e58d9c9ccf4cd3b455a2d2e0486d432cd8bf660", size = 67030, upload-time = "2026-09-04T12:57:23.986Z" },
 ]
 
 [[package]]
@@ -3298,28 +3298,28 @@ wheels = [
 
 [[package]]
 name = "uv"
-version = "0.12.9"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d7/42/6d2be569fd280ebd982a54ee2e3d3754fedde5cf557fd7f858eb40d161cf/uv-0.12.9.tar.gz", hash = "sha256:55b8920edb2a29eeef31e246fb60d2145985e17f51ad14b26643575b82759302", size = 7134801, upload-time = "2026-09-01T21:57:47.305Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/73/4a/208c1ed443a5024bdb83cedf1e09b322e68ccc9f7e11d1f53bb1f0690174/uv-0.12.9-py3-none-linux_armv6l.whl", hash = "sha256:97062b2160a97fcfa45f10bbbe02a9c6ba4f5a50cf4e02c0f2babb80b47c1ea8", size = 22183326, upload-time = "2026-09-01T21:57:01.443Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/4f/7cc3d45951bb01089bf948d91a89c5b433789df8ceeba4f4cbcce0b1ef5c/uv-0.12.9-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:0cb7e8a732d81f25d364de8d6ac69f4d00d56b581918ac242eeaeffb53977588", size = 20481767, upload-time = "2026-09-01T21:57:04.573Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/2b/28f22620d336069038e850ff662be979866c4944126d17a19bed738e3dc1/uv-0.12.9-py3-none-macosx_11_0_arm64.whl", hash = "sha256:0af988f800778913d36f9bf6905eb21c917dccc403bb364ad739bfd383acf491", size = 17338955, upload-time = "2026-09-01T21:57:06.884Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/29/649ff920dcd2373a819a4e0d9c1989ae770698e634c277e5a6fbbe19e9b4/uv-0.12.9-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:cce6e716df290b7f4a31f76ef39866e1dc006e947520a660459dea00b5d55234", size = 21598566, upload-time = "2026-09-01T21:57:09.223Z" },
-    { url = "https://files.pythonhosted.org/packages/35/0d/0db7cfdd5bf11ce91c53558449f0e753d3cc578d9e94bd350c10b43f17ef/uv-0.12.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:00ff9f34c04055ebc3e1599ee459f5ae0d42c17cd6a1d8d029f0389e64a1419c", size = 21690729, upload-time = "2026-09-01T21:57:11.866Z" },
-    { url = "https://files.pythonhosted.org/packages/69/bf/a63391a9d0f930f5ec23ff6a1daa9f7806a430fe41fb1e3bfb6cb10ef737/uv-0.12.9-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:2d4a1d4c067f9e2edf703e181a71db8fc9d7af5fcdbd0053103d0a1260e04ce6", size = 21716103, upload-time = "2026-09-01T21:57:14.407Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/4c/4b1fea7c22abac3297fa7fc222f3703c33ffe45aa7553fa9d8bd2b0b70bb/uv-0.12.9-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cafa85338ce1d27b7caa4aadc83ab21f350e2cd2185462fbb10a232b6e93152e", size = 22340621, upload-time = "2026-09-01T21:57:17.109Z" },
-    { url = "https://files.pythonhosted.org/packages/25/57/7ac6fd2b97ea9f608b65bb9b47d686e5d64f8142b190d3c4590d74cf8524/uv-0.12.9-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bbdcb9db8b44d80e3fcebc4205604d52ea145404efb179958560bb2a0157743a", size = 23586367, upload-time = "2026-09-01T21:57:19.494Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/87/3ef6bf32db7af74e7c230ef6c06c387d9be2363dfa63eb524065031c010a/uv-0.12.9-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cfb512d0e284e9fc42c3bbe9b701f430083fca23dbb67a20daeea897fb793069", size = 23279627, upload-time = "2026-09-01T21:57:22.146Z" },
-    { url = "https://files.pythonhosted.org/packages/37/4b/cd04809c7ad5149faac55160925bd67aab43f803f6c01be1c32aec7d24d9/uv-0.12.9-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5badfd805fd88bf99b4b4f044f6e8f762f1892cab27477f4427bb473e93dd049", size = 20056367, upload-time = "2026-09-01T21:57:24.49Z" },
-    { url = "https://files.pythonhosted.org/packages/29/6b/59cddb48c47124428d329ac3ed4ce91ccd8ab757ebeed3d482115d8b82ef/uv-0.12.9-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:c0f7e2b46e4c503f9497c0f41bba3570aa233685db814cd011225118f2d72b6a", size = 19383069, upload-time = "2026-09-01T21:57:27.019Z" },
-    { url = "https://files.pythonhosted.org/packages/99/a6/22e4650cc9a2d018165fda5a53ca7addedc6d4f083ab7c833acc12fbe1e1/uv-0.12.9-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:445c572202243229043abaeab2fecb1b3691477c71c79feb07f638ce34febd39", size = 22392774, upload-time = "2026-09-01T21:57:29.323Z" },
-    { url = "https://files.pythonhosted.org/packages/d4/37/68166b0acb7f8ff30316bf74c0e9840c7c6cbc86ee3e236382bb107d42db/uv-0.12.9-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:ce4ad780d3cefe5a8f965f3ddf942c01e71aa37e36f4fc431e72e4ee8ce5f378", size = 22517532, upload-time = "2026-09-01T21:57:31.758Z" },
-    { url = "https://files.pythonhosted.org/packages/28/ac/8801d60db574aa15fba53944e0ee2e298605bf9076a5389f5e56ed51206a/uv-0.12.9-py3-none-musllinux_1_1_i686.whl", hash = "sha256:f639f8415f08918fb4ba2022bfd94d039e01c6c1eca28583125d439f7bd635fb", size = 21498480, upload-time = "2026-09-01T21:57:34.402Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/47/663bbc05f26c6c518c086da5df1e38fc5b2650fa6768cb36c6418d3f9559/uv-0.12.9-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:5f9325495fa0bf3e71e6b09f72e68b0d4a000067888b48a659536a8c7191a112", size = 22889848, upload-time = "2026-09-01T21:57:37.284Z" },
-    { url = "https://files.pythonhosted.org/packages/58/ce/a4b1ae2a80264231a4dd0a070ffd0fe7f2bdf1d78e99d3c0c68ce315262b/uv-0.12.9-py3-none-win32.whl", hash = "sha256:f4ab95475562884fc8e72fbbf0c3da0e025d3bb25e7348544cd02b19bf77f3e1", size = 19858143, upload-time = "2026-09-01T21:57:39.571Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/b2/55c7fdbdacb0b110f92804cceea449dfcd5be4354ae1e997aca700145a65/uv-0.12.9-py3-none-win_amd64.whl", hash = "sha256:871e884c3329f69c12bb7426edb9e727745c3bb2db6d9e0538ce0e1bdfb64916", size = 17991226, upload-time = "2026-09-01T21:57:42.282Z" },
-    { url = "https://files.pythonhosted.org/packages/85/67/cac985492192ff4a95a76b3854143062f1b3290aca3a404a812b7aadc9cf/uv-0.12.9-py3-none-win_arm64.whl", hash = "sha256:31fddf25d756a51fe33f7831ff697a122628dd3121c37c435c39c678428f937b", size = 19472343, upload-time = "2026-09-01T21:57:44.877Z" },
+version = "0.12.12"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/77/1e/7827991def6006d84adc5113bc000956e83d190da00f836167775f276af5/uv-0.12.12.tar.gz", hash = "sha256:981a00db03357d9e9eec2b0fd128ac8b6786bf9265a56b77b9d9fc22f30fec3b", size = 7162711, upload-time = "2026-09-09T16:44:12.259Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d3/5e/705f15eaf979e50e1f6ff7238fa491196944a6137f724aaf69ab93f13fd5/uv-0.12.12-py3-none-linux_armv6l.whl", hash = "sha256:93deea45061d858760f8756fcca54a3e694978fe7f96e4987ad95ab47f72d554", size = 22185914, upload-time = "2026-09-09T16:43:29.816Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/49/1e5c867d088fd6641f15db3f50e07770a466f54309b818242bfd21e11469/uv-0.12.12-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:d3fa745404dd52a1763bc159073deacc5c0d501cb5e5c0baeeb53bf26f6d3482", size = 20476071, upload-time = "2026-09-09T16:43:32.473Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/8d/ddec2493ee930ebf32676f7b3715d75915eda45c981f6621ce3e99b69254/uv-0.12.12-py3-none-macosx_11_0_arm64.whl", hash = "sha256:e29bf70f889e801f7dc440b51b859f005311416aa3b5c42ba9dc387c7e877c00", size = 16743115, upload-time = "2026-09-09T16:43:34.574Z" },
+    { url = "https://files.pythonhosted.org/packages/77/27/b7b7486ebc998ab0893169a02d87d540c47bc6dd821de7e11156e343697a/uv-0.12.12-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:bff88c94d0b09149c1017b87b9eeca16764df37e1a6717f2b64a4104e3fb6795", size = 21666817, upload-time = "2026-09-09T16:43:36.699Z" },
+    { url = "https://files.pythonhosted.org/packages/af/c1/131f9de447f8f7299ebe3f5cb5089f7c7f2a62b257d81a5cffee5bacd237/uv-0.12.12-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:75c36925481ab9a3f0f31a737636597653ca228d14152420a6047a85c6a16fb0", size = 21668514, upload-time = "2026-09-09T16:43:38.962Z" },
+    { url = "https://files.pythonhosted.org/packages/12/56/94253e4f0e3806236393415b3b941625f3466c0e4091330827e3f07c27a6/uv-0.12.12-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:0635b6d6601cf93d442353fa54f8dddfc3129f3f74f09721fc402983a57dc172", size = 21708940, upload-time = "2026-09-09T16:43:41.327Z" },
+    { url = "https://files.pythonhosted.org/packages/30/be/cd8d050f00b11f01b59b13b4e89801f8f4bfbda599fad5858703b8b81fd3/uv-0.12.12-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e87f83293e6b3521660aa5c9aa5ab2a34fdc87845c90a466563cfbd53acf07de", size = 22402933, upload-time = "2026-09-09T16:43:43.686Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/84/c131548ba3e7726ad105d2022a9e761e09225736678d771cfac502141674/uv-0.12.12-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6bd1bf48fbc973c0700bf35717204b1e2a659e54fb68a010621b4949128f4a7e", size = 23701106, upload-time = "2026-09-09T16:43:46.16Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/0e/f9b3feda985e48d87a6c8375a1255af04af3e759dc92329387215830cd15/uv-0.12.12-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4a8535ca0ebd23d03a5a19b7c7a1c7567aac2aeaa06ee76716e133339e091c56", size = 23357681, upload-time = "2026-09-09T16:43:48.623Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c2/e8ff20e5f0bf1011995688784bc71ed7edbc7ccd3836e4967895680b2968/uv-0.12.12-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa5df02fc619a3cc7a58810d6ffeb80ca1e01404b8ef7239bd1cf2103c02cacf", size = 20041994, upload-time = "2026-09-09T16:43:50.98Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/b6/3c3e39422e507de31270ea3f82d66c8dcf010ed35cb8559dbdfb65078413/uv-0.12.12-py3-none-manylinux_2_28_aarch64.whl", hash = "sha256:091e942f0677f88389265c9028d64108c0641593dd8993166eae71e33fc5b5aa", size = 19458417, upload-time = "2026-09-09T16:43:53.209Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/3a/f39ffe3cd7f3fbc33b3f62eef26274ed3f42a01ceb18296ec6fd65a36080/uv-0.12.12-py3-none-manylinux_2_31_riscv64.musllinux_1_1_riscv64.whl", hash = "sha256:5b22f74a63fae875baf9af5818b08901f5a7addd5440b121245e8c4c7bb84084", size = 22474163, upload-time = "2026-09-09T16:43:55.363Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/9c/6a0105b5102486da1ad8d0dbfb438adc61a5e5d8397757a24fd5f6d17a43/uv-0.12.12-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:0e27713b2441d9204a35e0799c6e44ffeef9978e72ea5530cafcf91f8b24986c", size = 22599041, upload-time = "2026-09-09T16:43:57.702Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/14/a86c94d61245f88dfd825aef961f680d6dd7ba331b4ac5254a6de44aab36/uv-0.12.12-py3-none-musllinux_1_1_i686.whl", hash = "sha256:206446685f487f21c7eff07f74513693dd53a2374934b4324ebb1a1d665b595d", size = 21570488, upload-time = "2026-09-09T16:44:00.391Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/c2/f81d871bb447fcf28667fda4a15b5ad6c2719ba2cd34e51b674167dfab83/uv-0.12.12-py3-none-musllinux_1_1_x86_64.whl", hash = "sha256:98d9659e080c42c289e4552d4f01b758cea544a96e3d9e5ac8565faacf84f970", size = 22996969, upload-time = "2026-09-09T16:44:02.703Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/5f/e1190ec0810e3d785b14f6d9c43b744a7869d3ecec3f5cda3dd47cdcf0f7/uv-0.12.12-py3-none-win32.whl", hash = "sha256:febbb31b52cd47061e496ca12e34cf083981e167d1d0ebadf4a59a0ce369d86a", size = 19441083, upload-time = "2026-09-09T16:44:04.984Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/b7/aebd3504d559315be6137ebfe1f6d2258e8e2f48e528d7cc799aea3441ef/uv-0.12.12-py3-none-win_amd64.whl", hash = "sha256:4a5acd0c6087970bdf210eeb1203835117f6fb8b84828604205de510f68aa6a7", size = 17654279, upload-time = "2026-09-09T16:44:07.495Z" },
+    { url = "https://files.pythonhosted.org/packages/34/f5/70f1cb8ad7dba238489a86a341000c133db54aa12cdd81e67c98ebe9a59a/uv-0.12.12-py3-none-win_arm64.whl", hash = "sha256:3577343756d8bf686c92eaca89a79fb0c1b6a85c2f0b579d535db22a1b49eb4b", size = 18863039, upload-time = "2026-09-09T16:44:09.961Z" },
 ]
 
 [[package]]
@@ -3701,7 +3701,7 @@ dev = [
     { name = "coverage", specifier = "==7.16.0" },
     { name = "fsspec", specifier = ">=2023.10.0" },
     { name = "griffe-inherited-docstrings", specifier = "==1.1.3" },
-    { name = "hypothesis", specifier = "==6.167.1" },
+    { name = "hypothesis", specifier = "==6.168.0" },
     { name = "markdown-exec", extras = ["ansi"], specifier = "==1.12.3" },
     { name = "mike", specifier = "==2.2.0" },
     { name = "mkdocs", specifier = "==1.6.1" },
@@ -3723,12 +3723,12 @@ dev = [
     { name = "pytest-reportlog", specifier = "==1.0.0" },
     { name = "pytest-xdist", specifier = "==3.8.0" },
     { name = "requests", specifier = "==2.34.2" },
-    { name = "ruff", specifier = "==0.16.5" },
+    { name = "ruff", specifier = "==0.16.6" },
     { name = "s3fs", specifier = ">=2023.10.0" },
     { name = "tomlkit", specifier = "==0.15.1" },
-    { name = "towncrier", specifier = "==25.8.0" },
+    { name = "towncrier", specifier = "==26.9.0" },
     { name = "universal-pathlib" },
-    { name = "uv", specifier = "==0.12.9" },
+    { name = "uv", specifier = "==0.12.12" },
 ]
 docs = [
     { name = "astroid", specifier = "==4.3.1" },
@@ -3742,16 +3742,16 @@ docs = [
     { name = "mkdocstrings-python", specifier = "==2.0.8" },
     { name = "numcodecs", extras = ["msgpack"] },
     { name = "pytest", specifier = "==9.1.1" },
-    { name = "ruff", specifier = "==0.16.5" },
+    { name = "ruff", specifier = "==0.16.6" },
     { name = "s3fs", specifier = ">=2023.10.0" },
-    { name = "towncrier", specifier = "==25.8.0" },
+    { name = "towncrier", specifier = "==26.9.0" },
 ]
-release = [{ name = "towncrier", specifier = "==25.8.0" }]
+release = [{ name = "towncrier", specifier = "==26.9.0" }]
 remote-tests = [
     { name = "botocore" },
     { name = "coverage", specifier = "==7.16.0" },
     { name = "fsspec", specifier = ">=2023.10.0" },
-    { name = "hypothesis", specifier = "==6.167.1" },
+    { name = "hypothesis", specifier = "==6.168.0" },
     { name = "moto", extras = ["s3", "server"], specifier = "==5.2.3" },
     { name = "numpydoc", specifier = "==1.10.0" },
     { name = "obstore", specifier = ">=0.5.1" },
@@ -3766,11 +3766,11 @@ remote-tests = [
     { name = "requests", specifier = "==2.34.2" },
     { name = "s3fs", specifier = ">=2023.10.0" },
     { name = "tomlkit", specifier = "==0.15.1" },
-    { name = "uv", specifier = "==0.12.9" },
+    { name = "uv", specifier = "==0.12.12" },
 ]
 test = [
     { name = "coverage", specifier = "==7.16.0" },
-    { name = "hypothesis", specifier = "==6.167.1" },
+    { name = "hypothesis", specifier = "==6.168.0" },
     { name = "numpydoc", specifier = "==1.10.0" },
     { name = "pytest", specifier = "==9.1.1" },
     { name = "pytest-accept", specifier = "==0.3.0" },
@@ -3781,5 +3781,5 @@ test = [
     { name = "pytest-reportlog", specifier = "==1.0.0" },
     { name = "pytest-xdist", specifier = "==3.8.0" },
     { name = "tomlkit", specifier = "==0.15.1" },
-    { name = "uv", specifier = "==0.12.9" },
+    { name = "uv", specifier = "==0.12.12" },
 ]