diff --git a/.github/workflows/wai-conformance.yml b/.github/workflows/wai-conformance.yml
index 89681b505..46dc4e65e 100644
--- a/.github/workflows/wai-conformance.yml
+++ b/.github/workflows/wai-conformance.yml
@@ -56,6 +56,11 @@ on:
       # A library test (staged::tests::staged_delivery_text_lists_the_codes) checks
       # that this extension's §4.2 and A.6 list the codes the sink reports.
       - 'wai/extensions/staged-delivery.md'
+      # A library test (codecs::registry::tests::wire_identifiers_are_in_their_documents)
+      # checks every wire identifier against the section of these texts it names.
+      - 'wai/extensions/http-delivery.md'
+      - 'wai/extensions/moq-streaming-format.md'
+      - 'wai/extensions/jwp-receipts.md'
       - 'wai/wai-web/**'
       - '.github/workflows/wai-conformance.yml'
   pull_request:
@@ -81,6 +86,11 @@ on:
       # A library test (staged::tests::staged_delivery_text_lists_the_codes) checks
       # that this extension's §4.2 and A.6 list the codes the sink reports.
       - 'wai/extensions/staged-delivery.md'
+      # A library test (codecs::registry::tests::wire_identifiers_are_in_their_documents)
+      # checks every wire identifier against the section of these texts it names.
+      - 'wai/extensions/http-delivery.md'
+      - 'wai/extensions/moq-streaming-format.md'
+      - 'wai/extensions/jwp-receipts.md'
       - 'wai/wai-web/**'
       - '.github/workflows/wai-conformance.yml'
 
@@ -143,12 +153,16 @@ jobs:
         # of this build on every leg of this matrix, without a word. staged and the integer
         # media features build the staged-delivery core, its corpus tool and `wai stage`;
         # stage_measure builds the staged-measurement core and wai_stage_measure; telemetry
-        # the delivery-telemetry mapping and wai_telemetry.
-        run: cargo build --no-default-features --features world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,receipt_claims,staged,video_int,audio_int,splat_int,stage_measure,telemetry
+        # the delivery-telemetry mapping and wai_telemetry; http the HTTP delivery binding,
+        # its corpus tool and `wai http`.
+        run: cargo build --no-default-features --features world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,receipt_claims,staged,video_int,audio_int,splat_int,stage_measure,telemetry,http
       # video_package runs the package receipt's dedup tests, which content_dedup feeds.
+      # The dev profile keeps overflow checks on, so an arithmetic overflow in the HTTP
+      # binding (http_binding::tests, among them a seeded test of every parser of untrusted
+      # input) fails here rather than wrapping.
       - name: Library unit tests (the fixed-point determinism floors)
         working-directory: wai/wai-rs
-        run: cargo test --lib --no-default-features --features world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,oer,receipt_claims,key_discovery,staged,video_int,audio_int,splat_int,stage_measure,telemetry,video_package
+        run: cargo test --lib --no-default-features --features world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,oer,receipt_claims,key_discovery,staged,video_int,audio_int,splat_int,stage_measure,telemetry,video_package,http
       # The JPEG AI exact decoder reproduces across platforms only if no platform math
       # library is on its path. Two guards, each failing the step: clippy's
       # disallowed-methods (wai-rs/clippy.toml), which each module on the decode path
@@ -225,20 +239,21 @@ jobs:
       # The integer decode path builds under each of its features alone, so a sink can take
       # one medium without the others, and for wasm32 (a browser sink); `int_payload` arms a
       # medium only under its feature, and none needs `neural`. So does the staged-measurement
-      # core (`stage_measure`), which pulls no ONNX and reads no file on wasm32.
+      # core (`stage_measure`), which pulls no ONNX and reads no file on wasm32. The HTTP
+      # binding (`http`) performs no I/O, so it builds alone and for wasm32 too.
       - name: Each integer feature alone, and wasm32 (unix)
         if: matrix.os != 'windows'
         shell: bash
         working-directory: wai/wai-rs
         run: |
           set -euo pipefail
-          for f in neural_int video_int audio_int splat_int staged stage_measure telemetry; do
+          for f in neural_int video_int audio_int splat_int staged stage_measure telemetry http; do
             cargo check --lib --no-default-features --features "$f"
           done
           # The decode bench prints its machine line from bench_env; no other step builds it.
           cargo build --no-default-features --features neural_int,video_int,audio_int,world_int,splat_int --bin wai_decode_bench
           rustup target add --toolchain 1.98.0 wasm32-unknown-unknown
-          cargo check --lib --target wasm32-unknown-unknown --no-default-features --features video_int,audio_int,splat_int,staged
+          cargo check --lib --target wasm32-unknown-unknown --no-default-features --features video_int,audio_int,splat_int,staged,http
           # The staged-measurement core is wasm32-clean: a browser computes the same figures.
           # Built, not only checked, so codegen and linking of the library run for wasm32.
           cargo build --lib --target wasm32-unknown-unknown --no-default-features --features stage_measure
@@ -254,6 +269,14 @@ jobs:
       - name: Carriage conformance and the wai CLI (wrap, registry export)
         working-directory: wai/wai-rs
         run: cargo test --no-default-features --test carriage --test manifest_builders --test cli_wrap_intent --test cli_registry
+      # tests/cli_http.rs runs `wai http publish`, `codecs`, `origin` and `bench` as a user
+      # does: objects named by their content hash with their head proofs, a sequence's union
+      # and floor, the origin's headers, ranges and If-Range on loopback, and a fetch by
+      # the byte-range procedure whose record states energy as not measured. Cargo.toml
+      # declares it with required-features = ["http"].
+      - name: The wai http commands
+        working-directory: wai/wai-rs
+        run: cargo test --no-default-features --features http --test cli_http
       # The machine-readable registry (wai/registry/, wai/vocab/v2.*, the table in
       # wai/REGISTRY.md) is generated from wai-rs/src/codecs/registry.rs. Regenerate it in
       # memory and fail on any difference; the message says how to regenerate. One leg: the
@@ -314,7 +337,7 @@ jobs:
         working-directory: wai/wai-rs
         run: |
           set -euo pipefail
-          F=world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,quantum,quantum_ops,oer,receipt_claims,key_discovery,video_int,audio_int,splat_int,staged,stage_measure,telemetry
+          F=world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,quantum,quantum_ops,oer,receipt_claims,key_discovery,video_int,audio_int,splat_int,staged,stage_measure,telemetry,http
           v() { echo "::group::$1"; cargo run -q --no-default-features --features "$F" --bin "$2" -- verify "$3"; echo "::endgroup::"; }
           v worlds        wai_world_vectors      ../world-conformance
           v spatial-audio wai_audio_vectors      ../audio-conformance
@@ -334,6 +357,7 @@ jobs:
           v signers       wai_signer_vectors     ../signer-conformance
           v int-payload   wai_int_payload_vectors ../int-payload-conformance
           v staged        wai_staged_vectors     ../staged-conformance
+          v http          wai_http_vectors       ../http-conformance
           v staged-measure wai_stage_measure     ../staged-measure-conformance
           v telemetry     wai_telemetry          ../telemetry-conformance
       # The pin corpus's second implementation: Python standard library only, sharing no
@@ -364,7 +388,7 @@ jobs:
         shell: pwsh
         working-directory: wai/wai-rs
         run: |
-          $F = "world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,quantum,quantum_ops,oer,receipt_claims,key_discovery,video_int,audio_int,splat_int,staged,stage_measure,telemetry"
+          $F = "world,audio_scene,haptic,splat4d,score,provenance,neural_int,film,quantum,quantum_ops,oer,receipt_claims,key_discovery,video_int,audio_int,splat_int,staged,stage_measure,telemetry,http"
           function v($grp, $bin, $path) {
             Write-Output "::group::$grp"
             cargo run -q --no-default-features --features $F --bin $bin -- verify $path
@@ -389,6 +413,7 @@ jobs:
           v signers       wai_signer_vectors     ../signer-conformance
           v int-payload   wai_int_payload_vectors ../int-payload-conformance
           v staged        wai_staged_vectors     ../staged-conformance
+          v http          wai_http_vectors       ../http-conformance
           v staged-measure wai_stage_measure     ../staged-measure-conformance
           v telemetry     wai_telemetry          ../telemetry-conformance
 
@@ -422,7 +447,8 @@ jobs:
   # signer_verify.py (every key-discovery vector and the canonical fixture, with its
   # verdicts required to equal wai_signer_vectors' line for line), and
   # int_payload_verify.py (the integer payloads and their refusal fixtures), and
-  # staged_verify.py (the staged-delivery corpus).
+  # staged_verify.py (the staged-delivery corpus), and http_verify.py (the HTTP delivery
+  # corpus).
   # Each exits non-zero on any failure or any difference, and the step fails with it.
   # One platform: what they check is the reading of the text, not the architecture.
   independent-verifiers:
@@ -476,6 +502,31 @@ jobs:
         working-directory: wai
         shell: bash
         run: python3 staged-conformance/staged_verify.py staged-conformance
+      # The HTTP delivery corpus's second implementation (http-conformance/README): the head,
+      # the head proof (every committed proof rebuilt from the text), response checks, plans,
+      # selection, the byte-range procedure and its fallback, and the codecs union and floor,
+      # checked first against published BLAKE3 vectors. Standard library only. Its
+      # mutations and the differential against wai-rs run in wai-http.yml's falsify job.
+      - name: http_verify.py
+        working-directory: wai
+        shell: bash
+        run: python3 http-conformance/http_verify.py http-conformance
+      # Outside the corpus: wai_http_vectors fuzz writes seeded cases (Content-Range values,
+      # codecs values, #WAI-LAYER lines, manifests and their member types, encryption,
+      # refines, layers declared against their bases, layers over WAI2 components, objects
+      # past the first request through a tampering origin) with wai-rs's outcomes, and
+      # http_verify.py must give every one, a refusal by the same code. It prints each
+      # family's count of cases and of refusals. Two fixed seeds, so a run is reproducible.
+      - name: The HTTP differential outside the corpus (wai-rs against http_verify.py)
+        working-directory: wai
+        shell: bash
+        run: |
+          set -euo pipefail
+          (cd wai-rs && cargo build --no-default-features --features http --bin wai_http_vectors)
+          for seed in 11 12; do
+            wai-rs/target/debug/wai_http_vectors fuzz http-conformance --seed "$seed" --count 400 --out "$RUNNER_TEMP/http-fuzz-$seed.json"
+            python3 http-conformance/http_verify.py cases "$RUNNER_TEMP/http-fuzz-$seed.json" http-conformance
+          done
       # The staged-measurement corpus's second implementation (staged-measure-conformance/README):
       # it counts every object, applies every layer from its base's stage 0, computes the quality
       # integers, the output tree, the prefixes, the overhead points and the dedup totals itself,
diff --git a/.github/workflows/wai-http.yml b/.github/workflows/wai-http.yml
new file mode 100644
index 000000000..8b815fd61
--- /dev/null
+++ b/.github/workflows/wai-http.yml
@@ -0,0 +1,157 @@
+name: WAI HTTP delivery
+
+# extensions/http-delivery.md: two jobs beside the corpus checks in wai-conformance.yml.
+#
+# falsify — the HTTP corpus tool and its independent verifier must catch defects. Each
+#   patch in wai/http-conformance/falsify/ breaks one function of wai-rs (the content
+#   hash's domain, the root flag, the left-subtree rule, the chunk counter, the component
+#   digest check, the Content-Range and content-coding checks, ASCII-only numbers, the
+#   union, layers' place in it and their dispatch, the wai prefix's case, duplicate
+#   capabilities, a record beside a fallback, the trailing-byte rule, the missing-digest
+#   plan, the class merge, the base-only threshold, refused refinement responses, stale
+#   bytes after a mismatch, an unanswered base, the selection digest test); it
+#   is applied to a fresh worktree, the build must succeed, and `wai_http_vectors verify`
+#   must fail naming the cases on the patch's first line. Then each `http_verify.py
+#   --mutate` must fail, and the differential: wai-rs writes random envelopes' covered
+#   prefixes and head proofs, the Python verifier accepts every one, and refuses exactly
+#   the ten it changes one chaining-value byte in.
+#
+# cache-conformance — the cache rules (§9). wai/cache-conformance/run.sh stages the
+#   corpus's objects behind the reference origin (`wai http origin`) and runs driver.py
+#   against the origin, which must pass every MUST test, and against four negative-control
+#   proxies, which must each fail the tests their defect reaches. Labelled caches run only
+#   where the environment provides them (/opt/wai-cache); this repository holds none, and
+#   the job summary says when none ran. The reports are uploaded as an artifact.
+#
+# No workflow_dispatch: it does not start runs on this forge. A weekly schedule keeps the
+# jobs exercised between changes.
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches: [main]
+    paths:
+      - 'wai/wai-rs/src/http_binding/**'
+      - 'wai/wai-rs/src/container.rs'
+      - 'wai/wai-rs/src/jwp_hash.rs'
+      - 'wai/wai-rs/src/bin/wai.rs'
+      - 'wai/wai-rs/src/bin/wai_http_vectors.rs'
+      - 'wai/wai-rs/src/bin/wai_cli/http.rs'
+      - 'wai/wai-rs/src/bin/wai_cli/http_vectors.rs'
+      - 'wai/wai-rs/Cargo.toml'
+      - 'wai/http-conformance/**'
+      - 'wai/cache-conformance/**'
+      - 'wai/claim-conformance/_blake3.py'
+      # http_verify.py reads staged_verify.py (and through it int_payload_verify.py), and
+      # the corpus carries the staged ladder's base and layers.
+      - 'wai/staged-conformance/staged_verify.py'
+      - 'wai/staged-conformance/cases/audio_flac_rate_ladder/**'
+      - 'wai/int-payload-conformance/int_payload_verify.py'
+      - 'wai/registry/**'
+      - '.github/workflows/wai-http.yml'
+  pull_request:
+    paths:
+      - 'wai/wai-rs/src/http_binding/**'
+      - 'wai/wai-rs/src/container.rs'
+      - 'wai/wai-rs/src/jwp_hash.rs'
+      - 'wai/wai-rs/src/bin/wai.rs'
+      - 'wai/wai-rs/src/bin/wai_http_vectors.rs'
+      - 'wai/wai-rs/src/bin/wai_cli/http.rs'
+      - 'wai/wai-rs/src/bin/wai_cli/http_vectors.rs'
+      - 'wai/wai-rs/Cargo.toml'
+      - 'wai/http-conformance/**'
+      - 'wai/cache-conformance/**'
+      - 'wai/claim-conformance/_blake3.py'
+      # http_verify.py reads staged_verify.py (and through it int_payload_verify.py), and
+      # the corpus carries the staged ladder's base and layers.
+      - 'wai/staged-conformance/staged_verify.py'
+      - 'wai/staged-conformance/cases/audio_flac_rate_ladder/**'
+      - 'wai/int-payload-conformance/int_payload_verify.py'
+      - 'wai/registry/**'
+      - '.github/workflows/wai-http.yml'
+  schedule:
+    - cron: '17 4 * * 1'
+
+jobs:
+  falsify:
+    name: HTTP corpus · falsification and differential
+    runs-on: linux
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install Rust 1.98.0
+        shell: bash
+        run: |
+          export PATH="$HOME/.cargo/bin:$PATH"
+          command -v rustup >/dev/null 2>&1 || \
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain 1.98.0
+          rustup toolchain install 1.98.0 --profile minimal
+          rustup default 1.98.0
+          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      # One target directory for every patched build, so only the wai crate rebuilds.
+      - name: Every patch is caught; every mutation is caught; the differential holds
+        shell: bash
+        env:
+          CARGO_TARGET_DIR: ${{ runner.temp }}/falsify-target
+        run: |
+          git config --global --add safe.directory "$GITHUB_WORKSPACE"
+          bash wai/http-conformance/falsify/run.sh "$RUNNER_TEMP/falsify"
+
+  cache-conformance:
+    name: cache rules · controls and labelled caches
+    runs-on: linux
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install Rust 1.98.0
+        shell: bash
+        run: |
+          export PATH="$HOME/.cargo/bin:$PATH"
+          command -v rustup >/dev/null 2>&1 || \
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain 1.98.0
+          rustup toolchain install 1.98.0 --profile minimal
+          rustup default 1.98.0
+          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Build the reference origin
+        working-directory: wai/wai-rs
+        shell: bash
+        run: cargo build --release --no-default-features --features http --bin wai
+
+      # The verdict: run.sh exits non-zero when the origin fails a MUST test, a control is
+      # not caught, or a labelled cache fails one.
+      - name: The origin passes, the controls are caught, labelled caches report
+        shell: bash
+        run: WAI="$GITHUB_WORKSPACE/wai/wai-rs/target/release/wai" bash wai/cache-conformance/run.sh "$RUNNER_TEMP/cache"
+
+      # The evidence in the log, whatever becomes of the upload: each report's path and
+      # SHA-256, and the summary.
+      - name: The reports, in the log
+        if: always()
+        shell: bash
+        run: |
+          cd "$RUNNER_TEMP/cache/reports" 2>/dev/null || { echo "no reports were written"; exit 0; }
+          for f in *; do printf '%s  %s\n' "$(sha256sum "$f" | cut -d' ' -f1)" "$RUNNER_TEMP/cache/reports/$f"; done
+          cat summary.md 2>/dev/null || true
+
+      # An upload this forge cannot take must not decide the job: the verdict is the step
+      # above it.
+      - name: Upload the reports
+        if: always()
+        continue-on-error: true
+        uses: actions/upload-artifact@v3
+        with:
+          name: cache-conformance-reports
+          path: ${{ runner.temp }}/cache/reports
diff --git a/wai/CHANGELOG.md b/wai/CHANGELOG.md
index 888adadd0..1176f4e33 100644
--- a/wai/CHANGELOG.md
+++ b/wai/CHANGELOG.md
@@ -6,6 +6,106 @@ wire format may change and such changes are recorded here.
 
 ## v0.4.0 — current
 
+### HTTP delivery (Draft)
+
+- **The extension** [http-delivery](extensions/http-delivery.md) binds envelopes to
+  HTTP, with no envelope byte and no manifest member changed:
+  - the proposed media type `application/wai`, not registered;
+  - `codecs` elements `wai1.`/`wai2.` that list the exhaustive union of the
+    capabilities a variant may dispatch to or apply, with the floor every object of it
+    offers carried separately (`X-WAI-FLOOR`, a DASH `SupplementalProperty`);
+  - objects named by their receipt content hash (`<cid>.wai`), immutable, with no
+    content coding and no `Vary`, and exactly one envelope each;
+  - the `WHP1` head proof: the BLAKE3 chaining values that prove an envelope's head
+    against its content hash without the rest of the object;
+  - verified range fetch of one `WAI2` component that picks as whole-envelope
+    selection does, and falls back to the whole object when a pick has no digest, a
+    digest fails, or the plan needs most of the object;
+  - receipt, key, grant, parameter-set and playlist sidecars; cache rules; priorities,
+    deadlines and the carriage of enhancement companions, refinement components and
+    layer objects ([staged-delivery](extensions/staged-delivery.md));
+  - HLS and DASH adjacency for on-demand, live and low-latency live; a capability
+    probe that never asks a user agent about a WAI element.
+- **jwp-receipts**: §3 step 4 accepts the content hash a verified head proof
+  establishes for an object fetched in part, and checks a receipt about a component's
+  exploded envelope over the envelope the verifier builds. New §4.4 (objects not
+  delivered) and §4.5 (an HTTP cache is not a relay). §1 and §7.9 point to the HTTP
+  locations. moq-streaming-format §6 names the HTTP binding.
+- **SPEC**: §2 and §7.1 name the HTTP object and the `WAI2` head; the
+  `wai.video.manifest` row admits `render` and `extras` on a playlist receipt.
+- **The registry's wire identifiers.** `codecs::registry::WIRE_IDENTIFIERS` lists the
+  names the container, the two delivery bindings and key discovery put on the wire
+  outside a manifest, each with its kind, defining section and status; `wai registry
+  export` writes them to `registry/capabilities.json` (`wire_identifiers`) and the table
+  in `REGISTRY.md`, and a library test checks each against the section it names.
+- **The reference binding** (`wai-rs`, feature `http`): `http_binding::{head, head_proof,
+  plan, session, codecs, origin}` — the head and §5.1, the `WHP1` proof built and checked
+  with BLAKE3's tree, the root checked before any covered byte is read as a head; plans by
+  priority class; a sans-IO fetch session with §7.1's response checks, component digests,
+  the whole-object fallback and refinement deadlines; the `codecs` grammar, union, floor
+  and support; an origin's headers and Range answers. `container::select_entries` is SPEC
+  §7.1's walk with the digest test passed in, which `WaiMulti::pick` and a client holding
+  only the head both run, and `companion_indices` / `refinement_indices` bind by entry.
+  The `wai` tool gains `wai http publish|codecs|origin|vectors|bench`.
+- **The corpus** [`http-conformance/`](http-conformance/): objects with their head proofs
+  and ETag sidecars (a pinned learned image beside AVIF, JPEG XL and PNG of the one
+  picture; AV1 at two rates with HDR10+ bound by id; a missing and a wrong digest; an AVC
+  base with an LCEVC enhancement; a segment sequence; Appendix D's envelope; a head of
+  several chunks) and cases for §4–§7. `wai_http_vectors verify` and the independent
+  `http_verify.py` (standard library, written from the text, checked first against
+  published BLAKE3 vectors) agree on every case. Falsification patches and Python
+  mutations each must be caught, and a differential checks wai-rs's proofs of random
+  envelopes in Python (`.github/workflows/wai-http.yml`).
+- **Cache conformance** [`cache-conformance/`](cache-conformance/): a driver for §9's
+  rules, run against the reference origin (which must pass), against four
+  negative-control proxies (which must each be caught) and against labelled caches where
+  an environment provides them; reports name a cache by label, version and configuration
+  digest only, and CI uploads them.
+- **What review found, fixed** (http-delivery §3.1, §4, §7, §7.1, §10, §13, Appendix D):
+  - a layer object (a `WAI1` whose capability is refinement-only) is never dispatched:
+    it is fetched whole at refinement urgency, verified against its cid and handed to
+    staged delivery, and joins a union after `+` through `refines.base`
+    (`not_a_layer`, `codecs_layer_unbound`, `layer_tag_malformed`). A `WAI1` whose
+    capability is a payload is an ordinary object even when it carries `refines`: it is
+    dispatched, described by its capability, and `not_a_layer` when listed as a layer.
+    A layer is declared only in the `alt` of its own base's capability;
+  - a refinement never moves its base: only base-class bytes count toward the 90 %
+    rule, a refinement is always requested on its own, a refinement with no digest or a
+    failed one is dropped alone on the range path and on the whole path alike, and a
+    refused refinement response abandons only it;
+  - a client presents a base as soon as it verifies and applies its refinements as they
+    arrive; a refinement's deadline runs from that moment on the caller's clock
+    (`FetchSession::base_ready`, `tick`), and `wai http bench` reports the time to the
+    verified base apart from the time to the complete fetch;
+  - after a component mismatch every byte past `covered_len` is discarded before the
+    rest is fetched again; a base request never answered is `base_unanswered`;
+  - `Content-Range` numbers are ASCII digits only; an element beginning `wai` in any
+    case must be a well-formed WAI element; an empty element or a capability named
+    twice is malformed; a `WAI1` naming a record beside a payload fallback is described
+    by its fallback; a `codecs` value with non-ASCII text, and a head proof whose lengths
+    reach the end of 64 bits, are refused rather than panicking;
+  - the reference origin caps what it reads of a request head (16 KiB); gives the whole
+    head a deadline from the connection's accept (default 10 s, `--read-timeout-ms`),
+    answered by 408 however slowly its bytes trickle in; bounds each connection's whole
+    life from its accept, writing included (default 60 s, `--max-connection-ms`), so a
+    peer reading a large response slowly is cut off then; serves at most 64 connections
+    at once (`--max-connections`), answering 503 to one more, with a cap per peer
+    address only when `--max-per-peer` is given (it listens on 127.0.0.1, where every
+    client has one address, and a default cap would let a few reconnecting clients shut
+    the rest out); decodes `/__hits` as bytes; and refuses `\`, `:` and NUL in a path.
+    The wire-identifier test reads each name in its section's body.
+  - a verified base is decided: a component that verified is never read again, and of a
+    refinement's response only the range requested is kept, so a refinement answered
+    `200` with the whole object, a byte changed, never reaches the base. Every response
+    carries the caller's clock (`FetchSession::on_response(…, now_ms)`), the base is
+    stamped with the time of the response that verified it, and the deadline's
+    arithmetic saturates. The corpus's `fetch_timed` cases run the session on a clock;
+    `http_verify.py` agrees on them.
+  The corpus gains a case for each, and `http_verify.py` agrees with wai-rs on them and
+  on a seeded differential outside the corpus, in which a refusal must match by its
+  code and each family reports how many cases it generated and how many were refused.
+- No envelope byte or receipt byte changes for existing material.
+
 ### Packaging: a declared policy, its digest, and pieces cut at scene changes
 
 - **The extension** [packaging](extensions/packaging.md), first sections: a package is
diff --git a/wai/REGISTRY.md b/wai/REGISTRY.md
index 5ff7d8222..b6561bcd9 100644
--- a/wai/REGISTRY.md
+++ b/wai/REGISTRY.md
@@ -8,7 +8,7 @@ together with the class functions of [`wai-rs/src/codecs/mod.rs`](wai-rs/src/cod
 
 | file | what |
 |---|---|
-| [`registry/capabilities.json`](registry/capabilities.json) | every registered string with its kind, status, media class, role, fidelity tier, licence class, replicate class, set membership, registering section, edition and registration date; the named identifiers that are not capabilities; the unregistered labels |
+| [`registry/capabilities.json`](registry/capabilities.json) | every registered string with its kind, status, media class, role, fidelity tier, licence class, replicate class, set membership, registering section, edition and registration date; the named identifiers that are not capabilities; the unregistered labels; the wire identifiers |
 | [`registry/capabilities.schema.json`](registry/capabilities.schema.json) | JSON Schema (2020-12) for that file; its enums are the label sets below |
 | [`vocab/v2.ttl`](vocab/v2.ttl), [`vocab/v2.jsonld`](vocab/v2.jsonld), [`vocab/v2.shapes.ttl`](vocab/v2.shapes.ttl) | the same registry as RDF, a JSON-LD context for manifests, and a SHACL shape that checks a manifest's capability and fallback against it, only the form of its media, and its parameter-set pins (`vocab/README.md`); a violation for a string the registry does not hold means the string is not registered in this revision, not that the envelope fails to conform or cannot be dispatched (SPEC §4, §8) |
 | the table at the end of this file | the same registry, for reading |
@@ -54,6 +54,16 @@ Two further tables hold strings that look like capabilities and are not:
 - **unregistered labels** are strings the reference implementation uses as labels
   that no revision registers, each with the reason.
 
+A third holds the **wire identifiers**: the names the container, its delivery
+bindings ([http-delivery](extensions/http-delivery.md),
+[moq-streaming-format](extensions/moq-streaming-format.md)) and the key discovery
+they serve ([jwp-receipts](extensions/jwp-receipts.md) §7) put on the wire outside a
+manifest — magic numbers, a media type, `codecs` prefixes, paths, playlist tags and
+attributes, document kinds and catalog fields — each with its kind, the section that
+defines it, and whether it is defined, provisional (test material only until
+registered) or proposed (not registered). A library test checks that each is written
+in the section it names.
+
 ## Status
 
 - **registered** — the payload format (for a record or derivation, the
@@ -250,4 +260,38 @@ and a role are fixed once registered.
 | `wai.quantum.compile` | a receipt-kind label the wai-quantum crate seals; no revision of SPEC or of an extension registers it, so it is not a registered record |
 | `wai.quantum.rearrange` | a receipt-kind label the wai-quantum crate seals; no revision of SPEC or of an extension registers it, so it is not a registered record |
 | `wai.quantum.qbom` | a receipt-kind label the wai-quantum crate seals; no revision of SPEC or of an extension registers it, so it is not a registered record |
+
+| wire identifier (not a capability) | kind | status | defined in |
+|---|---|---|---|
+| `#WAI-LAYER` | playlist-tag | defined | http-delivery §10.4 |
+| `.wai` | path | defined | http-delivery §5.2 |
+| `.wai.hp` | path | defined | http-delivery §6.2 |
+| `.wai.receipts` | path | defined | http-delivery §8.2 |
+| `/.well-known/wai-grants/` | well-known | defined | http-delivery §8.4 |
+| `/.well-known/wai-key-status` | well-known | defined | http-delivery §8.4 |
+| `/.well-known/wai-keys` | well-known | defined | jwp-receipts §7.1 |
+| `WAI1` | magic | defined | SPEC §2 |
+| `WAI2` | magic | defined | SPEC §7.1 |
+| `WAI_RECEIPT` | catalog | defined | moq-streaming-format §5 |
+| `WHP1` | magic | defined | http-delivery §6.2 |
+| `X-WAI-FLOOR` | playlist-attribute | defined | http-delivery §11.1 |
+| `application/wai` | media-type | proposed | http-delivery §3 |
+| `mr/` | path | defined | http-delivery §8.6 |
+| `rcpt/` | path | defined | http-delivery §8.1 |
+| `science.transaction.wai.multivariant` | data-id | defined | http-delivery §11.1 |
+| `tag:transaction.science,2026:wai/floor` | scheme | defined | http-delivery §11.1 |
+| `tag:transaction.science,2026:wai/http-delivery` | scheme | defined | http-delivery §11.1 |
+| `wai` | catalog | defined | moq-streaming-format §3 |
+| `wai-key-status` | document-kind | defined | jwp-receipts §7.9 |
+| `wai-module-grant` | document-kind | defined | jwp-receipts §7.9 |
+| `wai-module-grants` | document-kind | defined | http-delivery §8.4 |
+| `wai-receipt-index` | document-kind | defined | http-delivery §8.2 |
+| `wai1` | codecs-prefix | defined | http-delivery §4.1 |
+| `wai1` | fourcc | provisional | http-delivery Appendix B |
+| `wai2` | codecs-prefix | defined | http-delivery §4.1 |
+| `wai2` | fourcc | provisional | http-delivery Appendix B |
+| `waiC` | fourcc | provisional | http-delivery Appendix B |
+| `wai_capabilities` | catalog | defined | moq-streaming-format §4 |
+| `wai_determinism` | catalog | defined | moq-streaming-format §4 |
+| `wai_receipts` | catalog | defined | moq-streaming-format §4 |
 <!-- end generated -->
diff --git a/wai/SPEC.md b/wai/SPEC.md
index 7f0831d27..6b6d5d5c2 100644
--- a/wai/SPEC.md
+++ b/wai/SPEC.md
@@ -86,6 +86,11 @@ OPTIONAL; §5 says which are RECOMMENDED.
 
 All WAI multi-byte integers are little-endian unless stated otherwise.
 
+An envelope delivered over HTTP is one object of the proposed media type
+`application/wai`, named by its receipt content hash, and fetched whole or, for a
+`WAI2`, one verified component at a time
+([http-delivery](extensions/http-delivery.md)).
+
 ---
 
 ## 3. Manifest schema
@@ -614,7 +619,7 @@ registration and makes no conforming envelope non-conforming (§8).
 | `wai.neural.dcvc_fm` | DCVC-FM (feature modulation), wide single-model quality range (RGB + YUV) | a wide single-model quality range; shares the inter-frame route | research code, `neural/video_dcvc.rs` |
 | `wai.video.int_motion` | DETERMINISTIC INTEGER inter-frame — I-frame + integer block motion-compensated P-frames + integer-quantized residual over rANS, no float/ONNX; motion is whole-pel or **half-pel** (`mv_precision`), the latter predicting at the half-grid by integer bilinear interpolation (`(a+b+1)>>1`, `(a+b+c+d+2)>>2`) so real footage — which pans a non-integer number of pixels per frame — costs fewer residual bits while staying byte-exact | byte-identical frame-by-frame on every machine (*frame-state-equivalence*, a per-frame portable hash); the temporal extension of the integer contract, where a float inter-frame decode desyncs down the GOP | payload `WIV1`, keyframe 0; `int_video.rs` (the encode tools write a JSON form a converter reads) |
 | `wai.video.int_hyper` | NEURAL-KEYFRAME inter-frame — the I-frame is the LEARNED integer codec `int_hyper` decoded byte-exact, the P-frames are integer block-MC residuals on top | a learned keyframe you can put in a receipt + integer inter-frames; whole decode integer, byte-identical everywhere | payload `WIV1`, keyframe 1 (a nested `WIH1`); `int_video::decode_pframes_typed` ∘ `int_hyper_synth::decode_conditional_checked` |
-| `wai.video.manifest` | ATTESTED PER-SESSION MANIFEST — the OTT delivery layer, not a codec: a personalised HLS manifest (ads stitched at `EXT-X-DISCONTINUITY`, blackouts + geo enforced) rendered as a **pure function of the session *class*** `(content, entitlement, geo, blackout set, ad pod, window)` rather than the viewer, and sealed in an Ed25519 receipt that binds the JCP grant (capability, joule ceiling, `funds_ceiling` = ad budget), the composition, the stitched ads and the policy applied | **manifest-equivalence**: `manifest_hash == hash(render(segments))` and `session_class_hash` are recomputable by anyone holding the bytes, so the ads, blackouts and compose-work stop being dashboard claims; class-determinism means one generation serves every viewer of the class, and `uj_per_viewer` is the amortised energy that a 1:1-unique generator cannot report below its per-viewer cost. Only the measurement — `joules_micro`, its acquisition class and the class's evidence — is measured-attested: signed, and not re-measurable | `wai_video_manifest.rs` |
+| `wai.video.manifest` | ATTESTED PER-SESSION MANIFEST — the OTT delivery layer, not a codec: a personalised HLS manifest (ads stitched at `EXT-X-DISCONTINUITY`, blackouts + geo enforced) rendered as a **pure function of the session *class*** `(content, entitlement, geo, blackout set, ad pod, window)` rather than the viewer, and sealed in an Ed25519 receipt that binds the JCP grant (capability, joule ceiling, `funds_ceiling` = ad budget), the composition, the stitched ads and the policy applied. A receipt over a WAI playlist MAY carry `render` and `extras`, the rendering parameters and per-segment lines that playlist adds, both bound through `manifest_hash` ([http-delivery](extensions/http-delivery.md) §8.6) | **manifest-equivalence**: `manifest_hash == hash(render(segments))` and `session_class_hash` are recomputable by anyone holding the bytes, so the ads, blackouts and compose-work stop being dashboard claims; class-determinism means one generation serves every viewer of the class, and `uj_per_viewer` is the amortised energy that a 1:1-unique generator cannot report below its per-viewer cost. Only the measurement — `joules_micro`, its acquisition class and the class's evidence — is measured-attested: signed, and not re-measurable | `wai_video_manifest.rs` |
 | `wai.video.ssai` | ATTESTED SERVER-SIDE AD INSERTION — a **deterministic** ad decision (greedy by price within the avail duration and the funds remaining) plus a per-impression Ed25519 receipt binding the candidate pod, the manifest it belongs to, the served `creative_hash`es and the VAST quartile each reached | **spend-equivalence**: `budget_spent_micros` is recomputed from the *billable* impressions and rejected if it exceeds the grant's `funds_ceiling` — an overspent receipt fails verification; every creative and quartile is checkable, so a buyer and seller reconcile impressions from the same bytes instead of two logs that only a dashboard joins. Only the measurement — `joules_micro`, its acquisition class and the class's evidence — is measured-attested: signed, and not re-measurable | `wai_video_ssai.rs` |
 | `wai.video.keys` | ATTESTED CONTENT-KEY RELEASE — the DRM licensing decision as a record: every key release, and every refusal, is an Ed25519 receipt binding the KID, the DRM system, the entitlement demanded and the window enforced, with a BLAKE3 `key_commit` proving *which* key was released without carrying it | **decision-equivalence**: `verify()` re-runs the release policy over the receipt's own `(grant capability, entitlement, issued, expiry)` and rejects any misreported outcome, and enforces granted-iff-committed — so "keys went only to entitled, unexpired sessions" is checkable against the signed log, not asserted. Only the measurement — `joules_micro`, its acquisition class and the class's evidence — is measured-attested: signed, and not re-measurable | `wai_video_keys.rs` |
 | `wai.video.package` | DETERMINISTIC PACKAGING + ATTESTED SEGMENTMAP — a source sliced into content-hashed segments on GOP boundaries; the ordered `(index → content_hash)` map is a signed Merkle commitment, and identical content (ads, bumpers, replays, simulcast overlap) dedups to one stored/encoded copy | **map-equivalence + verifiable dedup**: `segment_map_root` lets a `wai.video.manifest` reference be checked against the package that produced it, and `verify()` recomputes `unique_segments`/`stored_bytes` from the segments so the storage/encode saving cannot be overstated; `uj_per_unique_segment` is the encode-once energy. Only the measurement — `joules_micro`, its acquisition class and the class's evidence — is measured-attested: signed, and not re-measurable | `wai_video_package.rs` |
@@ -1727,6 +1732,10 @@ by which capability happens to be installed.
   i-th entry corresponds to `renditions[i]` in the manifest.
 - Payloads block: the rendition byte ranges, packed contiguously.
 - `n_renditions` MUST equal the manifest's `renditions.length`.
+- The bytes from offset 0 to the end of the rendition table are the envelope's
+  **head**. They give every component's byte range and, with each entry's `sha256`,
+  its digest, so a sink can fetch and verify one component without the others
+  ([http-delivery](extensions/http-delivery.md) §7).
 
 ### Selection algorithm
 
diff --git a/wai/cache-conformance/README.md b/wai/cache-conformance/README.md
new file mode 100644
index 000000000..80fcb83d9
--- /dev/null
+++ b/wai/cache-conformance/README.md
@@ -0,0 +1,47 @@
+# cache-conformance — HTTP caches under http-delivery §9
+
+Checks the cache rules of [http-delivery](../extensions/http-delivery.md) §9 against
+an HTTP cache that fronts an origin serving the objects of
+[`http-conformance/`](../http-conformance/), and reports, per cache label and version,
+whether the configuration meets each rule.
+
+| file | what |
+|---|---|
+| `tests.json` | the tests: id, rule, level (MUST or informative) and what each checks |
+| `driver.py` | stages the origin's files and runs the tests against a cache; standard library only, with `../claim-conformance/_blake3.py` to check each object against its content hash |
+| `mutators.py` | four proxies that each break §9 in one way: the negative controls |
+| `run.sh` | stages, starts `wai http origin`, and runs the driver against the origin, each control and each labelled cache |
+
+## What runs
+
+1. **The origin, directly** (`origin-direct`): the reference origin
+   (`wai http origin`) must pass every MUST test. It answers byte ranges and `If-Range`,
+   serves a live-edge alias with a shorter `max-age`, sends §8.4's `Cache-Control` for
+   the key log, and counts the requests it receives (`--count-hits`) so the informative
+   tests can tell whether a cache answered from its store.
+2. **The negative controls** (`control-flip`, `control-gzip`, `control-truncate`,
+   `control-vary`): the driver must fail, and must name the tests each defect reaches —
+   `flip` C1, C3 and C11; `gzip` C7; `truncate` C1 and C2; `vary` C13. A control the
+   driver passes is a defect in the driver.
+3. **Labelled caches.** An environment that provides them lists their labels in
+   `/opt/wai-cache/labels`; each `/opt/wai-cache/<label>/` holds `start.sh <port>
+   <origin URL>`, which starts the cache in front of the origin, a `version` file and the
+   `config` it runs with. This repository holds no cache configuration: the labels are
+   opaque, and a report names a cache only by its label, its package version and the
+   SHA-256 of its configuration. Where the directory is absent, only 1 and 2 run, and the
+   summary says so.
+
+## Reports
+
+`run.sh <out-dir>` writes, under `<out-dir>/reports/`, `report-<label>.json`
+(`{cache_label, package_version, config_sha256, results}`), `requirements-<label>.md`
+(the same as a table, with whether the configuration meets §9), the driver's log per run,
+and `summary.md`, which CI also writes to the job summary. The CI job uploads the
+reports as an artifact.
+
+## Running it
+
+    cd wai/wai-rs && cargo build --release --no-default-features --features http --bin wai
+    cd ../.. && WAI=wai/wai-rs/target/release/wai bash wai/cache-conformance/run.sh /tmp/cache-run
+
+Python 3 with the standard library is all the driver and the controls need.
diff --git a/wai/cache-conformance/driver.py b/wai/cache-conformance/driver.py
new file mode 100755
index 000000000..89995bebd
--- /dev/null
+++ b/wai/cache-conformance/driver.py
@@ -0,0 +1,339 @@
+#!/usr/bin/env python3
+"""Cache conformance for HTTP delivery (extensions/http-delivery.md §9).
+
+Runs tests.json against an HTTP cache that fronts an origin serving the objects of
+wai/http-conformance/, and reports, per test, whether the cache met it. Standard library
+only, and ../claim-conformance/_blake3.py to check each object's bytes against its
+content hash; it shares no code with wai-rs.
+
+    python3 driver.py stage <http-conformance dir> <root>
+        lay out the files an origin serves for the tests under <root>
+    python3 driver.py run --base URL --root <root> [--origin URL] [--label L]
+                          [--version V] [--config FILE] [--report report.json]
+        run the tests against the cache at URL (the origin itself, for a control)
+
+`run` exits 1 when a MUST test fails, and prints `FAIL <id>: <detail>` for each. With
+--origin, the origin's hit counter (`wai http origin --count-hits`) lets the informative
+tests see whether a request reached the origin. A report names the cache by its label
+and version only.
+"""
+import hashlib, http.client, json, os, shutil, sys, time, urllib.parse
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "..", "claim-conformance"))
+from _blake3 import blake3  # noqa: E402
+
+DOMAIN = b"moq-jwp:object\x01"
+
+
+def cid_of(b):
+    return blake3(DOMAIN + b).hex()
+
+
+# ------------------------------------------------------------------- staging
+
+def stage(corpus, root):
+    """The origin's files: the corpus objects and head proofs, an alias, a live-edge
+    part, a receipt index, a receipt file, a playlist receipt, a key log and a
+    parameter set named by its digest."""
+    if os.path.exists(root):
+        shutil.rmtree(root)
+    os.makedirs(os.path.join(root, "objects"))
+    listing = json.load(open(os.path.join(corpus, "objects.json")))
+    for oid, o in listing.items():
+        for suffix in ("", ".hp"):
+            shutil.copyfile(os.path.join(corpus, o["path"] + suffix), os.path.join(root, o["path"] + suffix))
+    def put(rel, data):
+        p = os.path.join(root, rel)
+        os.makedirs(os.path.dirname(p), exist_ok=True)
+        open(p, "wb").write(data)
+    o8 = open(os.path.join(corpus, listing["O8"]["path"]), "rb").read()
+    o9b = open(os.path.join(corpus, listing["O9b"]["path"]), "rb").read()
+    put("alias/segment-8.wai", o8)
+    put("live/part-1.wai", o9b)
+    index = json.dumps({"kind": "wai-receipt-index", "object": listing["O3"]["cid"], "delivery": [], "claims": []}, sort_keys=True).encode()
+    put(listing["O3"]["path"] + ".receipts", index)
+    fixture = json.dumps({"kind": "cache-conformance-fixture", "of": "a receipt file"}, sort_keys=True).encode()
+    put("objects/rcpt/%s.json" % blake3(fixture).hex(), fixture)
+    playlist = json.dumps({"kind": "cache-conformance-fixture", "of": "a playlist receipt"}, sort_keys=True).encode()
+    put("objects/mr/%s.json" % blake3(playlist).hex(), playlist)
+    put(".well-known/wai-keys", json.dumps({"kind": "cache-conformance-fixture", "of": "a key log"}).encode())
+    pset = open(os.path.join(corpus, "..", "wai-rs", "tests", "vectors", "int_mlicpp", "model.wmb"), "rb").read()
+    put("sets/" + hashlib.sha256(pset).hexdigest(), pset)
+    manifest = {
+        "objects": {oid: {"path": o["path"], "cid": o["cid"], "n": o["n"]} for oid, o in listing.items()},
+        "alias": {"path": "alias/segment-8.wai", "of": "O8"},
+        "live": {"path": "live/part-1.wai", "of": "O9b"},
+        "index": listing["O3"]["path"] + ".receipts",
+        "receipt": "objects/rcpt/%s.json" % blake3(fixture).hex(),
+        "playlist_receipt": "objects/mr/%s.json" % blake3(playlist).hex(),
+        "key_log": ".well-known/wai-keys",
+        "set": "sets/" + hashlib.sha256(pset).hexdigest(),
+    }
+    open(os.path.join(root, "stage.json"), "w").write(json.dumps(manifest, indent=1) + "\n")
+    print("staged %d objects and their sidecars under %s" % (len(listing), root))
+
+
+# ------------------------------------------------------------------- requests
+
+class Response:
+    def __init__(self, status, headers, body):
+        self.status, self.body = status, body
+        self.headers = {}
+        for k, v in headers:
+            self.headers.setdefault(k.lower(), []).append(v)
+
+    def h(self, name):
+        v = self.headers.get(name.lower())
+        return None if v is None else ", ".join(v)
+
+
+def request(base, path, headers=None, method="GET"):
+    u = urllib.parse.urlsplit(base)
+    conn = http.client.HTTPConnection(u.hostname, u.port or 80, timeout=30)
+    prefix = u.path.rstrip("/")
+    h = {"Connection": "close"}
+    h.update(headers or {})
+    conn.request(method, prefix + "/" + path.lstrip("/"), headers=h)
+    r = conn.getresponse()
+    body = r.read()
+    out = Response(r.status, r.getheaders(), body)
+    conn.close()
+    return out
+
+
+def hits(origin, path):
+    if origin is None:
+        return None
+    r = request(origin, "/__hits?path=" + urllib.parse.quote("/" + path.lstrip("/")))
+    return int(r.body) if r.status == 200 else None
+
+
+# --------------------------------------------------------------------- tests
+
+class Fail(Exception):
+    pass
+
+
+def need(cond, why):
+    if not cond:
+        raise Fail(why)
+
+
+def run_tests(base, root, origin):
+    st = json.load(open(os.path.join(root, "stage.json")))
+    obj = {k: open(os.path.join(root, v["path"]), "rb").read() for k, v in st["objects"].items()}
+    for k, v in st["objects"].items():
+        if cid_of(obj[k]) != v["cid"]:
+            raise SystemExit("the staged object %s does not hash to its cid" % k)
+    path = lambda k: st["objects"][k]["path"]
+    etag = lambda k: '"%s"' % st["objects"][k]["cid"]
+    results = {}
+
+    def whole_ok(r, k, what):
+        need(r.status == 200, "%s: status %d" % (what, r.status))
+        need(r.h("content-encoding") in (None, "identity"), "%s: Content-Encoding %s" % (what, r.h("content-encoding")))
+        need(r.body == obj[k], "%s: %d bytes that are not the object's %d" % (what, len(r.body), len(obj[k])))
+
+    def range_ok(r, k, a, b, what, allow_200=False):
+        n = len(obj[k])
+        if allow_200 and r.status == 200:
+            whole_ok(r, k, what)
+            return
+        need(r.status == 206, "%s: status %d" % (what, r.status))
+        need(r.h("content-encoding") in (None, "identity"), "%s: Content-Encoding %s" % (what, r.h("content-encoding")))
+        need(r.h("content-range") == "bytes %d-%d/%d" % (a, b, n), "%s: Content-Range %s" % (what, r.h("content-range")))
+        need(r.body == obj[k][a:b + 1], "%s: the bytes are not the object's [%d, %d]" % (what, a, b))
+
+    def c1():
+        whole_ok(request(base, path("O3")), "O3", "cold")
+        whole_ok(request(base, path("O3")), "O3", "again")
+
+    def c2():
+        r = request(base, path("O2"))
+        whole_ok(r, "O2", "GET")
+        need(r.h("etag") == etag("O2"), "ETag %s" % r.h("etag"))
+        need((r.h("content-type") or "").startswith("application/wai"), "Content-Type %s" % r.h("content-type"))
+        need(r.h("cache-control") == "public, max-age=31536000, immutable, no-transform", "Cache-Control %s" % r.h("cache-control"))
+        need(r.h("content-length") == str(len(obj["O2"])), "Content-Length %s" % r.h("content-length"))
+
+    def c3():
+        request(base, path("O4"))
+        range_ok(request(base, path("O4"), {"Range": "bytes=1009-3000"}), "O4", 1009, 3000, "range")
+
+    def c4():
+        n = len(obj["O7"])
+        range_ok(request(base, path("O7"), {"Range": "bytes=1009-2999"}), "O7", 1009, 2999, "cold range", allow_200=True)
+        range_ok(request(base, path("O7"), {"Range": "bytes=0-1008"}), "O7", 0, 1008, "head range", allow_200=True)
+        need(n > 0, "empty")
+
+    def c5():
+        n = len(obj["O9c"])
+        request(base, path("O9c"))
+        range_ok(request(base, path("O9c"), {"Range": "bytes=-100"}), "O9c", n - 100, n - 1, "suffix")
+        range_ok(request(base, path("O9c"), {"Range": "bytes=%d-" % (n - 50)}), "O9c", n - 50, n - 1, "open")
+
+    def c6():
+        n = len(obj["O9c"])
+        r = request(base, path("O9c"), {"Range": "bytes=%d-" % n})
+        need(r.status == 416, "status %d" % r.status)
+        need(r.h("content-range") == "bytes */%d" % n, "Content-Range %s" % r.h("content-range"))
+
+    def c7():
+        for enc in ("gzip, deflate, br", "br", "zstd, gzip"):
+            whole_ok(request(base, path("O9a"), {"Accept-Encoding": enc}), "O9a", "Accept-Encoding %s" % enc)
+
+    def c8():
+        request(base, path("OD"))
+        range_ok(request(base, path("OD"), {"Range": "bytes=1009-3593", "If-Range": etag("OD")}), "OD", 1009, 3593, "matching If-Range")
+        whole_ok(request(base, path("OD"), {"Range": "bytes=1009-3593", "If-Range": "W/" + etag("OD")}), "OD", "weak If-Range")
+        whole_ok(request(base, path("OD"), {"Range": "bytes=1009-3593", "If-Range": '"%s"' % ("0" * 64)}), "OD", "other If-Range")
+
+    def c9():
+        a = request(base, path("O5"), {"User-Agent": "conformance-a", "Accept-Language": "en", "Accept": "*/*"})
+        b = request(base, path("O5"), {"User-Agent": "conformance-b", "Accept-Language": "fr", "Accept": "application/wai"})
+        whole_ok(a, "O5", "first")
+        whole_ok(b, "O5", "second")
+        need(a.h("vary") is None and b.h("vary") is None, "Vary %s / %s" % (a.h("vary"), b.h("vary")))
+
+    def c10():
+        p = path("O3") + ".hp"
+        r = request(base, p)
+        need(r.status == 200 and r.body == open(os.path.join(root, p), "rb").read(), "the head proof differs (status %d)" % r.status)
+        need(r.h("content-encoding") in (None, "identity"), "Content-Encoding %s" % r.h("content-encoding"))
+        need(r.h("cache-control") == "public, max-age=31536000, immutable, no-transform", "Cache-Control %s" % r.h("cache-control"))
+
+    def c11():
+        r = request(base, st["alias"]["path"])
+        whole_ok(r, st["alias"]["of"], "alias")
+        need(r.h("etag") == etag(st["alias"]["of"]), "ETag %s" % r.h("etag"))
+
+    def c12():
+        k, p = st["live"]["of"], st["live"]["path"]
+        r = request(base, p)
+        whole_ok(r, k, "live part")
+        cc = r.h("cache-control") or ""
+        need("max-age=31536000" not in cc and "max-age=" in cc, "Cache-Control %s" % cc)
+        range_ok(request(base, p, {"Range": "bytes=10-99"}), k, 10, 99, "live range", allow_200=True)
+
+    def c13():
+        r = request(base, path("O1"), {"Origin": "https://reader.example"})
+        whole_ok(r, "O1", "with Origin")
+        need(r.h("access-control-allow-origin") == "*", "Access-Control-Allow-Origin %s" % r.h("access-control-allow-origin"))
+        need("origin" not in (r.h("vary") or "").lower(), "Vary %s" % r.h("vary"))
+
+    def r1():
+        p = st["index"]
+        first = request(base, p)
+        need(first.status == 200, "status %d" % first.status)
+        changed = json.dumps({"kind": "wai-receipt-index", "changed_at": time.time()}).encode()
+        full = os.path.join(root, p)
+        old = open(full, "rb").read()
+        open(full, "wb").write(changed)
+        try:
+            second = request(base, p)
+        finally:
+            open(full, "wb").write(old)
+        need(second.status == 200 and second.body == changed, "the index came back unchanged")
+
+    def fetch_kept(p, cc=None):
+        r = request(base, p)
+        need(r.status == 200 and r.body == open(os.path.join(root, p), "rb").read(), "%s differs (status %d)" % (p, r.status))
+        need(r.h("content-encoding") in (None, "identity"), "Content-Encoding %s" % r.h("content-encoding"))
+        if cc is not None:
+            need(r.h("cache-control") == cc, "Cache-Control %s" % r.h("cache-control"))
+        return r
+
+    def kept(p, cc=None):
+        fetch_kept(p, cc)
+
+    imm = "public, max-age=31536000, immutable, no-transform"
+
+    def r5():
+        r = fetch_kept(st["set"], imm)
+        need(hashlib.sha256(r.body).hexdigest() == st["set"].rsplit("/", 1)[1], "the set does not hash to its name")
+
+    def s1():
+        if origin is None:
+            return "not run: no hit counter"
+        p = path("O8")
+        request(base, p)
+        before = hits(origin, p)
+        request(base, p)
+        return "stored" if hits(origin, p) == before else "not stored"
+
+    def s2():
+        if origin is None:
+            return "not run: no hit counter"
+        p = path("O9b")
+        request(base, p)
+        before = hits(origin, p)
+        request(base, p, {"Range": "bytes=100-199"})
+        return "answered from store" if hits(origin, p) == before else "forwarded"
+
+    table = {"C1": c1, "C2": c2, "C3": c3, "C4": c4, "C5": c5, "C6": c6, "C7": c7, "C8": c8, "C9": c9,
+             "C10": c10, "C11": c11, "C12": c12, "C13": c13, "R1": r1,
+             "R2": lambda: kept(st["receipt"], imm), "R3": lambda: kept(st["playlist_receipt"], imm),
+             "R4": lambda: kept(st["key_log"], "max-age=300, no-transform"), "R5": r5, "S1": s1, "S2": s2}
+    tests = json.load(open(os.path.join(HERE, "tests.json")))["tests"]
+    out = []
+    for t in tests:
+        try:
+            detail = table[t["id"]]()
+            out.append({"id": t["id"], "name": t["name"], "level": t["level"], "pass": True, "detail": detail})
+        except Fail as e:
+            out.append({"id": t["id"], "name": t["name"], "level": t["level"], "pass": False, "detail": str(e)})
+        except (OSError, http.client.HTTPException) as e:
+            out.append({"id": t["id"], "name": t["name"], "level": t["level"], "pass": False, "detail": "transport: %s" % e})
+    return out
+
+
+def requirements_md(report):
+    lines = ["# Cache configuration: %s" % report["cache_label"], "",
+             "Package version: %s. Configuration SHA-256: %s." % (report["package_version"], report["config_sha256"] or "none"), "",
+             "| test | level | result | detail |", "|---|---|---|---|"]
+    for r in report["results"]:
+        res = ("pass" if r["pass"] else "FAIL") if r["level"] == "MUST" else (r["detail"] or "")
+        lines.append("| %s %s | %s | %s | %s |" % (r["id"], r["name"], r["level"], res, "" if r["pass"] else r["detail"]))
+    musts = [r for r in report["results"] if r["level"] == "MUST"]
+    ok = all(r["pass"] for r in musts)
+    lines += ["", "This configuration %s http-delivery §9 for every MUST test." % ("meets" if ok else "does not meet")]
+    return "\n".join(lines) + "\n"
+
+
+def main(argv):
+    if len(argv) == 3 and argv[0] == "stage":
+        stage(argv[1], argv[2])
+        return 0
+    if not argv or argv[0] != "run":
+        print(__doc__)
+        return 2
+    opt = lambda f, d=None: argv[argv.index(f) + 1] if f in argv else d
+    base, root = opt("--base"), opt("--root")
+    if base is None or root is None:
+        print(__doc__)
+        return 2
+    results = run_tests(base, root, opt("--origin"))
+    cfg = opt("--config")
+    report = {
+        "cache_label": opt("--label", "unlabelled"),
+        "package_version": opt("--version", "n/a"),
+        "config_sha256": hashlib.sha256(open(cfg, "rb").read()).hexdigest() if cfg else None,
+        "results": results,
+    }
+    if opt("--report"):
+        open(opt("--report"), "w").write(json.dumps(report, indent=1) + "\n")
+        open(os.path.join(os.path.dirname(opt("--report")) or ".", "requirements-%s.md" % report["cache_label"]), "w").write(requirements_md(report))
+    failed = [r for r in results if r["level"] == "MUST" and not r["pass"]]
+    for r in results:
+        if not r["pass"]:
+            print("FAIL %s: %s" % (r["id"], r["detail"]))
+        elif r["level"] != "MUST":
+            print("info %s: %s" % (r["id"], r["detail"]))
+    print("%s: %d/%d MUST tests pass" % (report["cache_label"], sum(1 for r in results if r["level"] == "MUST" and r["pass"]),
+                                         sum(1 for r in results if r["level"] == "MUST")))
+    return 1 if failed else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/wai/cache-conformance/mutators.py b/wai/cache-conformance/mutators.py
new file mode 100755
index 000000000..c6683b847
--- /dev/null
+++ b/wai/cache-conformance/mutators.py
@@ -0,0 +1,82 @@
+#!/usr/bin/env python3
+"""Negative controls for driver.py: proxies that break http-delivery §9 in one way each,
+so a run against them must fail the tests that rule reaches. If the driver passes one of
+them, the driver is what is broken.
+
+    python3 mutators.py --mode flip|gzip|truncate|vary --listen PORT --upstream URL
+
+- flip:     changes one byte in the middle of every object body (§9 rule 1);
+- gzip:     applies a gzip content coding to whole objects when the request offers it
+            (§9 rule 1);
+- truncate: drops the last byte of every whole object, and says so in Content-Length
+            (§9 rules 1 and 3);
+- vary:     adds `Vary: Origin` and drops `Access-Control-Allow-Origin` (§9 rule 4,
+            §5.3).
+
+Standard library only.
+"""
+import gzip as gz, http.client, sys, urllib.parse
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+MODE, UPSTREAM = None, None
+HOP = {"connection", "keep-alive", "proxy-connection", "transfer-encoding", "upgrade", "te", "trailer", "host"}
+
+
+class Proxy(BaseHTTPRequestHandler):
+    protocol_version = "HTTP/1.1"
+
+    def log_message(self, *a):
+        pass
+
+    def forward(self, method):
+        u = urllib.parse.urlsplit(UPSTREAM)
+        conn = http.client.HTTPConnection(u.hostname, u.port or 80, timeout=30)
+        headers = {k: v for k, v in self.headers.items() if k.lower() not in HOP}
+        conn.request(method, self.path, headers=headers)
+        r = conn.getresponse()
+        body = r.read()
+        out = [(k, v) for k, v in r.getheaders() if k.lower() not in HOP and k.lower() != "content-length"]
+        conn.close()
+        is_object = self.path.split("?")[0].endswith(".wai")
+        if MODE == "flip" and is_object and len(body) > 1:
+            body = bytearray(body)
+            body[len(body) // 2] ^= 0x01
+            body = bytes(body)
+        elif MODE == "gzip" and is_object and r.status == 200 and "gzip" in (self.headers.get("Accept-Encoding") or ""):
+            body = gz.compress(body, mtime=0)
+            out = [(k, v) for k, v in out if k.lower() != "content-encoding"] + [("Content-Encoding", "gzip")]
+        elif MODE == "truncate" and is_object and r.status == 200 and body:
+            body = body[:-1]
+        elif MODE == "vary":
+            out = [(k, v) for k, v in out if k.lower() != "access-control-allow-origin"] + [("Vary", "Origin")]
+        self.send_response(r.status)
+        for k, v in out:
+            self.send_header(k, v)
+        self.send_header("Content-Length", str(len(body)))
+        self.send_header("Connection", "close")
+        self.end_headers()
+        if method != "HEAD":
+            self.wfile.write(body)
+
+    def do_GET(self):
+        self.forward("GET")
+
+    def do_HEAD(self):
+        self.forward("HEAD")
+
+    def do_OPTIONS(self):
+        self.forward("OPTIONS")
+
+
+def main(argv):
+    global MODE, UPSTREAM
+    opt = lambda f: argv[argv.index(f) + 1]
+    MODE, UPSTREAM, port = opt("--mode"), opt("--upstream"), int(opt("--listen"))
+    if MODE not in ("flip", "gzip", "truncate", "vary"):
+        print(__doc__)
+        return 2
+    ThreadingHTTPServer(("127.0.0.1", port), Proxy).serve_forever()
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/wai/cache-conformance/run.sh b/wai/cache-conformance/run.sh
new file mode 100755
index 000000000..6e0e87e94
--- /dev/null
+++ b/wai/cache-conformance/run.sh
@@ -0,0 +1,93 @@
+#!/usr/bin/env bash
+# Cache conformance (extensions/http-delivery.md §9): stage the corpus's objects, start
+# the reference origin, and run driver.py
+#
+#   1. against the origin itself, which must pass every MUST test (the positive control);
+#   2. against each negative-control proxy in mutators.py, which must fail the tests its
+#      defect reaches (the driver's own falsification);
+#   3. against each labelled cache an environment provides: /opt/wai-cache/labels lists
+#      the labels, and /opt/wai-cache/<label>/start.sh <port> <origin URL> starts one in
+#      front of the origin (with version and config files beside it). The public
+#      repository holds no cache configuration; without that directory only 1 and 2 run,
+#      and the summary says so.
+#
+#   WAI=<path to a `wai` built with http> bash wai/cache-conformance/run.sh <out-dir>
+#
+# Reports go to <out-dir>/reports: report-<label>.json and requirements-<label>.md.
+# Exit status 1 when a control does not behave as stated or a labelled cache fails a
+# MUST test.
+set -uo pipefail
+HERE="$(cd "$(dirname "$0")" && pwd)"
+OUT="${1:?usage: run.sh <out-dir>}"
+WAI="${WAI:?set WAI to a wai binary built with the http feature}"
+mkdir -p "$OUT/reports"
+ROOT="$OUT/root"
+python3 "$HERE/driver.py" stage "$HERE/../http-conformance" "$ROOT" || exit 1
+
+pids=()
+cleanup() { for p in "${pids[@]}"; do kill "$p" 2>/dev/null; done; }
+trap cleanup EXIT
+
+free_port() { python3 -c 'import socket; s=socket.socket(); s.bind(("127.0.0.1",0)); print(s.getsockname()[1]); s.close()'; }
+wait_port() { for _ in $(seq 1 100); do python3 -c "import socket,sys; socket.create_connection(('127.0.0.1',$1),1)" 2>/dev/null && return 0; sleep 0.1; done; return 1; }
+
+OP="$(free_port)"
+"$WAI" http origin --root "$ROOT" --port "$OP" --count-hits --live-prefix live/ --live-max-age 30 > "$OUT/origin.log" 2>&1 &
+pids+=($!)
+wait_port "$OP" || { echo "::error::the origin did not start"; cat "$OUT/origin.log"; exit 1; }
+ORIGIN="http://127.0.0.1:$OP"
+fail=0
+summary="| run | expectation | MUST passed | result |\n|---|---|---|---|\n"
+
+run_driver() { # label base expect-pass [expected failing ids]
+  local label="$1" base="$2" expect="$3"; shift 3
+  python3 "$HERE/driver.py" run --base "$base" --root "$ROOT" --origin "$ORIGIN" --label "$label" \
+    --report "$OUT/reports/report-$label.json" > "$OUT/reports/$label.log" 2>&1
+  local rc=$?
+  local passed; passed="$(tail -1 "$OUT/reports/$label.log" | sed 's/.*: //')"
+  if [ "$expect" = pass ]; then
+    if [ $rc -eq 0 ]; then summary+="| $label | every MUST passes | $passed | ok |\n"
+    else summary+="| $label | every MUST passes | $passed | **failed** |\n"; echo "::error::$label failed a MUST test"; cat "$OUT/reports/$label.log"; fail=1; fi
+  else
+    local missing=""
+    for id in "$@"; do grep -q "^FAIL $id:" "$OUT/reports/$label.log" || missing="$missing $id"; done
+    if [ $rc -ne 0 ] && [ -z "$missing" ]; then summary+="| $label | fails $* | $passed | caught |\n"
+    else summary+="| $label | fails $* | $passed | **not caught:$missing** |\n"; echo "::error::$label: the driver did not catch$missing (exit $rc)"; cat "$OUT/reports/$label.log"; fail=1; fi
+  fi
+}
+
+# 1. The origin, directly.
+run_driver origin-direct "$ORIGIN" pass
+
+# 2. The negative controls.
+expect_of() { case "$1" in flip) echo "C1 C3 C11" ;; gzip) echo "C7" ;; truncate) echo "C1 C2" ;; vary) echo "C13" ;; esac; }
+for m in flip gzip truncate vary; do
+  MP="$(free_port)"
+  python3 "$HERE/mutators.py" --mode "$m" --listen "$MP" --upstream "$ORIGIN" > "$OUT/mutator-$m.log" 2>&1 &
+  pids+=($!)
+  wait_port "$MP" || { echo "::error::mutator $m did not start"; fail=1; continue; }
+  # shellcheck disable=SC2086
+  run_driver "control-$m" "http://127.0.0.1:$MP" fail $(expect_of "$m")
+done
+
+# 3. Labelled caches, where the environment provides them.
+if [ -f /opt/wai-cache/labels ]; then
+  for label in $(cat /opt/wai-cache/labels); do
+    CP="$(free_port)"
+    /opt/wai-cache/"$label"/start.sh "$CP" "$ORIGIN" > "$OUT/cache-$label.log" 2>&1 &
+    pids+=($!)
+    wait_port "$CP" || { echo "::error::cache $label did not start"; fail=1; continue; }
+    python3 "$HERE/driver.py" run --base "http://127.0.0.1:$CP" --root "$ROOT" --origin "$ORIGIN" --label "$label" \
+      --version "$(cat /opt/wai-cache/"$label"/version 2>/dev/null || echo unknown)" \
+      --config /opt/wai-cache/"$label"/config --report "$OUT/reports/report-$label.json" > "$OUT/reports/$label.log" 2>&1
+    rc=$?
+    summary+="| $label | every MUST passes | $(tail -1 "$OUT/reports/$label.log" | sed 's/.*: //') | $([ $rc -eq 0 ] && echo ok || echo '**failed**') |\n"
+    [ $rc -eq 0 ] || fail=1
+  done
+else
+  summary+="| labelled caches | — | — | none in this environment (/opt/wai-cache/labels absent): controls only |\n"
+fi
+
+printf "%b" "$summary" | tee "$OUT/reports/summary.md"
+[ -n "${GITHUB_STEP_SUMMARY:-}" ] && printf "%b" "$summary" >> "$GITHUB_STEP_SUMMARY"
+exit $fail
diff --git a/wai/cache-conformance/tests.json b/wai/cache-conformance/tests.json
new file mode 100644
index 000000000..6c1c27248
--- /dev/null
+++ b/wai/cache-conformance/tests.json
@@ -0,0 +1,25 @@
+{
+  "note": "The tests driver.py runs against an HTTP cache that fronts an origin serving wai/http-conformance's objects (extensions/http-delivery.md §9). A MUST test failing means the cache, as configured, does not meet §9; an informative test reports what the cache did.",
+  "tests": [
+    { "id": "C1", "name": "whole_identity", "level": "MUST", "rule": "§9 rule 1", "what": "a GET of an object, cold and then again, returns exactly the object's bytes" },
+    { "id": "C2", "name": "headers_kept", "level": "MUST", "rule": "§9 rule 3", "what": "a 200 keeps the origin's ETag, Content-Type and Cache-Control, and a Content-Length of the object's length" },
+    { "id": "C3", "name": "range_from_stored", "level": "MUST", "rule": "§9 rule 2", "what": "after a whole GET, a single range is answered 206 with exactly those bytes and Content-Range bytes a-b/n" },
+    { "id": "C4", "name": "range_cold", "level": "MUST", "rule": "§9 rule 2, §5.3", "what": "a single range on an object not yet fetched is answered 206 with exactly those bytes, or 200 with the whole object" },
+    { "id": "C5", "name": "suffix_and_open_ranges", "level": "MUST", "rule": "§9 rule 2", "what": "bytes=-N and bytes=A- are answered with exactly those bytes" },
+    { "id": "C6", "name": "unsatisfiable", "level": "MUST", "rule": "§9 rule 2", "what": "a range starting at the object's length is answered 416 with Content-Range bytes */n" },
+    { "id": "C7", "name": "no_coding", "level": "MUST", "rule": "§9 rule 1", "what": "with Accept-Encoding offering codings, the object comes back with no Content-Encoding and its exact bytes" },
+    { "id": "C8", "name": "if_range_strong", "level": "MUST", "rule": "§9 rule 5", "what": "If-Range with the object's ETag gets 206; with a weak form of it, or another ETag, the whole object" },
+    { "id": "C9", "name": "no_vary_by_header", "level": "MUST", "rule": "§9 rule 4", "what": "requests that differ in User-Agent, Accept-Language and Accept get the same bytes, with no Vary" },
+    { "id": "C10", "name": "head_proof_kept", "level": "MUST", "rule": "§9 rule 6, §6.2", "what": "a head proof is returned byte for byte with its immutable Cache-Control" },
+    { "id": "C11", "name": "alias", "level": "MUST", "rule": "§5.2, §9 rule 1", "what": "an alias returns the object's exact bytes and its ETag" },
+    { "id": "C12", "name": "live_edge_max_age", "level": "MUST", "rule": "§5.3, §9 rule 3", "what": "an object listed at a live edge keeps its shorter max-age and its bytes, whole and by range" },
+    { "id": "C13", "name": "no_vary_cors", "level": "MUST", "rule": "§5.3, §9 rule 4", "what": "a request with Origin gets Access-Control-Allow-Origin: * and no Vary: Origin" },
+    { "id": "R1", "name": "index_revalidated", "level": "MUST", "rule": "§9 rule 6, §8.2", "what": "a receipt index changed at the origin is returned changed on the next request" },
+    { "id": "R2", "name": "receipt_file_kept", "level": "MUST", "rule": "§9 rule 6, §8.1", "what": "a receipt file is returned byte for byte with its immutable Cache-Control" },
+    { "id": "R3", "name": "playlist_receipt_kept", "level": "MUST", "rule": "§9 rule 6, §8.6", "what": "a playlist receipt is returned byte for byte" },
+    { "id": "R4", "name": "key_log_max_age", "level": "MUST", "rule": "§9 rule 6, §8.4", "what": "the key log is returned byte for byte with its Cache-Control" },
+    { "id": "R5", "name": "parameter_set_kept", "level": "MUST", "rule": "§9 rule 6, §8.5", "what": "a parameter set named by its digest is returned byte for byte and hashes to its name" },
+    { "id": "S1", "name": "stored", "level": "informative", "rule": "§9", "what": "a second GET of an object is answered without reaching the origin" },
+    { "id": "S2", "name": "range_stored", "level": "informative", "rule": "§9 rule 2", "what": "a range after a whole GET is answered without reaching the origin" }
+  ]
+}
diff --git a/wai/claim-conformance/_blake3.py b/wai/claim-conformance/_blake3.py
index 89865deb7..a8de73f0e 100644
--- a/wai/claim-conformance/_blake3.py
+++ b/wai/claim-conformance/_blake3.py
@@ -1,8 +1,14 @@
 """BLAKE3 in hash mode, written from its specification in pure Python.
 
-Shared by the claim-conformance verifier (`claim_verify.py`) and the staged-delivery
-verifier (`../staged-conformance/staged_verify.py`), which import `blake3` from here. It
-shares no code with wai-rs, which computes the same hashes with the `blake3` crate.
+Shared by the claim-conformance verifier (`claim_verify.py`), the staged-delivery
+verifier (`../staged-conformance/staged_verify.py`) and the HTTP delivery verifier
+(`../http-conformance/http_verify.py`), which import from here. It shares no code with
+wai-rs, which computes the same hashes with the `blake3` crate.
+
+`subtree_cv` and `parent_cv` expose the tree (the BLAKE3 specification, §2.1): the
+non-root chaining value of a subtree that starts at a given byte offset of the whole
+input, and a parent node with or without the ROOT flag. The HTTP head proof is built of
+these (http-delivery §6).
 """
 
 _IV = [0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19]
@@ -73,3 +79,35 @@ def blake3(data: bytes) -> bytes:
         out = (_IV, stack.pop() + _cv(out), 0, 64, _PARENT)
     cv, w, _, bl, f = out
     return b"".join(x.to_bytes(4, "little") for x in _compress(cv, w, 0, bl, f | _ROOT)[:8])
+
+
+def _bytes(words):
+    return b"".join(x.to_bytes(4, "little") for x in words)
+
+
+def _left_chunks(n):
+    """The left subtree of `n` chunks (n >= 2): the largest power of two below n."""
+    return 1 << ((n - 1).bit_length() - 1)
+
+
+def subtree_cv(data: bytes, start: int) -> bytes:
+    """The non-root chaining value of `data` as a whole subtree of the input whose first
+    chunk is at byte offset `start` (a multiple of 1024): chunk counters run from
+    start // 1024."""
+    assert start % 1024 == 0
+    chunks = [data[i:i + 1024] for i in range(0, len(data), 1024)] or [b""]
+
+    def node(cs, c0):
+        if len(cs) == 1:
+            return _cv(_chunk_output(cs[0], c0))
+        k = _left_chunks(len(cs))
+        return _cv((_IV, node(cs[:k], c0) + node(cs[k:], c0 + k), 0, 64, _PARENT))
+
+    return _bytes(node(chunks, start // 1024))
+
+
+def parent_cv(left: bytes, right: bytes, root: bool = False) -> bytes:
+    """A parent node over two chaining values: its chaining value, or with `root` the
+    hash it outputs as the root."""
+    m = [int.from_bytes((left + right)[i:i + 4], "little") for i in range(0, 64, 4)]
+    return _bytes(_compress(_IV, m, 0, 64, _PARENT | (_ROOT if root else 0))[:8])
diff --git a/wai/extensions/http-delivery.md b/wai/extensions/http-delivery.md
new file mode 100644
index 000000000..a4f159502
--- /dev/null
+++ b/wai/extensions/http-delivery.md
@@ -0,0 +1,903 @@
+# WAI Extension: HTTP Delivery
+
+> Status: Draft. Binds WAI envelopes to HTTP: a proposed media type, a `codecs`
+> grammar, content-addressed immutable objects, verified byte-range fetch of one
+> component of a `WAI2`, receipt, key and playlist sidecars, cache rules, delivery
+> order and deadlines, and HLS / DASH adjacency for on-demand, live and low-latency
+> live. No envelope byte and no manifest member changes. The reference implementation
+> is in `wai-rs`: `http_binding` (feature `http`) for §3–§7 and the origin side of §5
+> and §9, and the `wai http` commands of the `wai` tool. Keywords **MUST**,
+> **MUST NOT**, **SHOULD**, **MAY** are RFC 2119 / RFC 8174.
+
+## 1. Scope
+
+This extension says how a WAI envelope is named, served, cached and fetched over HTTP
+(RFC 9110, RFC 9111), and how WAI objects sit beside a classical HLS or DASH
+presentation without changing it. It is the HTTP sibling of
+[moq-streaming-format](moq-streaming-format.md); Appendix C maps the two. It defines
+no codec, no player and no re-packing: a node that serves bytes other than those it
+received is a producer under [jwp-receipts](jwp-receipts.md) §2.6 and §3.2, not a
+cache under §9. What a refinement does to its base is
+[staged-delivery](staged-delivery.md)'s and [SPEC](../SPEC.md) §7.1's; §10 defines
+only how one is carried over HTTP and when a client gives up on it.
+
+## 2. Terms
+
+- **Object**: one WAI envelope ([SPEC](../SPEC.md) §2 or §7.1) served as one HTTP
+  representation.
+- **Content hash**, **cid**: the object's [jwp-receipts](jwp-receipts.md) §2.1 content
+  hash, `BLAKE3("moq-jwp:object\x01" ‖ envelope)`, written as 64 lowercase hexadecimal
+  digits. `envelope_len` is the envelope's length in bytes.
+- **Head**: for `WAI1`, the first `12 + man_len` bytes — magic, `man_len`, the manifest
+  and `payload_len`; for `WAI2`, the first `10 + man_len + 8·n` bytes — magic, `man_len`,
+  the manifest, `n_renditions` and the rendition table. Its length is `head_len`.
+- **Component**: one entry of a `WAI2` rendition table and its payload bytes
+  ([SPEC](../SPEC.md) §7.1). Its **range** is the `length` bytes from `head_len + offset`.
+- **Covered length**: `covered_len = min(envelope_len, 1024·⌈(15 + head_len)/1024⌉ − 15)`.
+- **Alias**: any URI other than `<cid>.wai` under which an object is served.
+- **Base**: the object, or the component, a sink presents on its own.
+- **Refinement**: bytes a sink MAY add to a base it can already present. It is one
+  of three things:
+  - a companion whose registered role is `enhancement` ([SPEC](../SPEC.md) §5, §7.1);
+  - a component with `role: "refinement"` (SPEC §7.1, *Refinement components*);
+  - a **layer object**: a `WAI1` envelope whose capability is refinement-only, which
+    carries `refines` ([staged-delivery](staged-delivery.md) §1, §3). A `WAI1` whose
+    capability is not refinement-only is not a layer object, whatever else it carries
+    (§10.4).
+
+## 3. Media type `application/wai` (proposed; not registered)
+
+An object is served with media type `application/wai`. The name is **proposed**:
+RFC 6838 §3.1 admits a standards-tree registration only through an IETF document or a
+recognized standards organization, and none has been made. Until one is, the name
+identifies WAI objects between parties that implement this extension, and an
+implementation MUST NOT present it as registered.
+
+The type's properties, in the fields of RFC 6838 §5.6:
+
+| field | value |
+|---|---|
+| Type name / Subtype name | application / wai |
+| Required parameters | none |
+| Optional parameters | `codecs` (§4) |
+| Encoding considerations | binary |
+| Security considerations | §15 |
+| Interoperability considerations | `WAI1` and `WAI2` containers; a reader refuses an unknown MAJOR ([SPEC](../SPEC.md) §8) |
+| Published specification | WAI SPEC.md; this extension |
+| Fragment identifier considerations | §3.1 |
+| Magic number(s) | `57 41 49 31` ("WAI1") or `57 41 49 32` ("WAI2") at offset 0 |
+| File extension(s) | `.wai` |
+
+### 3.1 Fragment identifiers
+
+A fragment on an object's URI is a `&`-separated list of `key=value` pairs. It is never
+sent to a server and never changes the object. Unknown keys are ignored.
+
+- `cid=<64 hex>`: the object's content hash, on an alias (§5.2).
+- `n=<decimal>`: the object's `envelope_len`.
+- `h=<decimal>`: the object's `covered_len`.
+- `c=<component id>`: a preference for the component whose `id` ([SPEC](../SPEC.md)
+  §7.1) is that value, which a sink MAY honour as deployer policy within §7.
+
+`n` and `h` are hints, never checks: every length that matters is checked against the
+head proof (§6.3) or, for an object fetched whole, the cid. A wrong `h` costs a request.
+A wrong `n` below `1009` costs the whole object: the client fetches it whole (§5.4),
+whatever its real length.
+
+## 4. The `codecs` parameter
+
+### 4.1 Grammar
+
+The `codecs` parameter of `application/wai`, the HLS `CODECS` attribute and the DASH
+`@codecs` attribute carry WAI elements in this grammar (ABNF, RFC 5234):
+
+```
+wai-element = wai-prefix "." alt *( "|" alt )
+wai-prefix  = "wai1" / "wai2"
+alt         = cap *( "+" cap )
+cap         = 1*lcalnum 1*( "." 1*( lcalnum / "_" ) )
+lcalnum     = %x61-7A / %x30-39
+```
+
+- An element is one RFC 6381 `id-simple`; elements are separated by `,` as RFC 6381
+  §3.2 separates codecs, and `.` is its hierarchy delimiter. Spaces and tabs around an
+  element are not part of it, and an empty element is malformed. Classical elements
+  (for example `mp4a.40.2`) MAY appear beside WAI elements. An element that begins with
+  `wai`, in any ASCII case, is a WAI element: it MUST match the grammar, and is never
+  read as classical.
+- `wai1` states that every object the element describes is a `WAI1` envelope; `wai2`
+  states that at least one is a `WAI2` envelope. Both name WAI MAJOR 1.
+- A `cap` is a capability string ([SPEC](../SPEC.md) §5) without its leading `wai.`.
+  Every capability this revision registers begins `wai.` and matches the rule once
+  that is removed, so the mapping is one-to-one.
+- In an `alt`, the first `cap` is a **selectable** capability, and each `+cap` is a
+  capability whose payload is applied with it: a companion ([SPEC](../SPEC.md) §7.1)
+  bound to a rendition of it, or a refinement whose base is a rendition of it
+  (§2).
+- An element MUST NOT name a capability whose registered kind is `derivation` or
+  `record` (`codecs_not_media`), or a candidate (`codecs_candidate`). A first `cap`
+  MUST NOT be companion-only or refinement-only, and a `+cap` MUST NOT be registered as
+  standalone media (`codecs_malformed`); a capability this revision does not register
+  may stand in either place, as SPEC §7.1 lets it be a rendition or a companion. A
+  `cap` MUST NOT appear twice among an element's `alt`s, nor twice in one `alt`. A
+  string that breaks any of these is `codecs_malformed`.
+
+### 4.2 Meaning: the union and the floor
+
+- **Union.** The element describing one object or a sequence of objects (an HLS
+  variant, a DASH Representation, a MoQ track) lists every capability any of them may
+  dispatch to or apply. For a `WAI1`, its `capability` and its `fallback`, each where
+  SPEC §4 dispatches it, as an `alt`: a record, a derivation, a candidate, a
+  companion-only or a refinement-only capability is never listed, so a `WAI1` naming a
+  record beside a payload fallback is described by the fallback. For a `WAI2`, one
+  `alt` per distinct selectable capability ([SPEC](../SPEC.md) §7.1), each with `+` and
+  every companion capability bound to a rendition of it and every refinement capability
+  whose base is a rendition of it. An object that lists no capability is not media
+  (`codecs_not_media`). A `WAI1` whose capability is not refinement-only is described
+  by its capability and fallback as above even when it carries `refines`, which a
+  client does not read for it (§10.4). A layer object (§10.4) has no element of its own: its
+  capability follows `+` in the `alt` of the base its `refines.base` names among the
+  sequence's objects — a `WAI1`, through its `capability` (staged delivery never takes
+  a base through its fallback), or a component of a `WAI2`, by the content hash of the
+  component's exploded envelope ([SPEC](../SPEC.md) §7.1), through the component's
+  capability. A sequence with a layer whose base it does not hold cannot be described
+  (`codecs_layer_unbound`). `alt`s are ordered by first appearance, and the
+  capabilities after `+` by first appearance in table order, then a sequence's layers
+  in order. The union is exhaustive: a sink that finds, in a head it has verified, a
+  selectable, companion or refinement capability the union does not list refuses that
+  object (`codecs_undeclared`). A layer is declared only when its capability follows `+`
+  in the `alt` of its own base's capability — the base its `refines.base` names, as
+  above, which the sink holds — and not by following `+` in any other `alt`; a sink
+  that does not hold that base cannot find the layer declared.
+- **Floor.** The floor of a sequence is the `alt`s whose first `cap` is selectable in
+  **every** object that is not a layer, each with the capabilities after `+` that are
+  bound to it, or joined to it by a layer, in every such object. For one object, the
+  floor is its union. A sequence whose floor is
+  empty MUST NOT be published as one variant (`codecs_no_common_capability`). The
+  floor is written as a `wai-element` with the union's prefix, in HLS in the
+  `X-WAI-FLOOR` attribute (§11.1) and in DASH in a `SupplementalProperty` (§11.1).
+- **Support.** A sink **supports** an element when it reads the element's container
+  (`wai1`: `WAI1`; `wai2`: both) and supports the first `cap` of at least one `alt`
+  of the **floor**. The capabilities after `+` never affect support: a sink that
+  cannot apply one presents the rendition ([SPEC](../SPEC.md) §7.1). A sink supports
+  a `codecs` value when it supports every element.
+- An element states capabilities, never parameter sets: a sink that supports a
+  capability may still refuse an object's pin ([SPEC](../SPEC.md) §3.1) and select
+  another rendition.
+
+### 4.3 Not a question for the browser's decoders
+
+An interface that answers for the user agent's own decoders (Media Capabilities,
+`MediaSource.isTypeSupported`, WebCodecs `isConfigSupported`) cannot answer for a WAI
+element. A sink MUST NOT pass a WAI element to such an interface, and MUST NOT read its
+answer about a classical codec string as support for a WAI capability, except for a
+capability whose payload the sink hands to that user-agent decoder (§12).
+
+## 5. Objects
+
+### 5.1 One envelope, nothing after it
+
+An object MUST be exactly one envelope: for `WAI1`, `envelope_len = 12 + man_len +
+payload_len`; for `WAI2`, `envelope_len = head_len + Σ lengths`. A reader that finds
+another length refuses the object (`object_length_mismatch`). This rule binds HTTP
+objects; it does not change which envelopes conform to [SPEC](../SPEC.md).
+
+### 5.2 Names and aliases
+
+An object SHOULD be published at a URI whose last path segment is `<cid>.wai`. Such a
+URI names those bytes forever: a publisher MUST NOT serve other bytes under it.
+
+An object MAY also be served under an alias. An alias MUST serve exactly the object's
+bytes with its `ETag`, and MUST NOT serve other bytes at any time. A client learns no
+content hash from a response, so before it presents anything fetched by alias it MUST
+verify the bytes against a cid it holds from a listing (a `cid` fragment or a
+`<cid>.wai` URI in a playlist) or from a verified receipt.
+
+### 5.3 Response headers
+
+For a `GET` or `HEAD` of an object an origin MUST send:
+
+```
+Content-Type: application/wai          (MAY carry ; codecs="…" of §4 for that object)
+Cache-Control: public, max-age=31536000, immutable, no-transform
+ETag: "<cid>"
+Accept-Ranges: bytes
+Access-Control-Allow-Origin: *
+Access-Control-Expose-Headers: Content-Range, Content-Length, ETag
+Timing-Allow-Origin: *
+```
+
+It MUST NOT send `Content-Encoding` other than none, MUST NOT send `Vary`, and MUST
+NOT select bytes by any request header. An object listed only at a live edge (§11.4)
+MAY carry a smaller `max-age`, not less than the time it stays listed. An origin MAY
+send `Repr-Digest: sha-256=:<base64>:` (RFC 9530 §3) over the whole envelope.
+
+An origin MUST answer a preflight for an object with
+`Access-Control-Allow-Headers: Range, Priority` and `Access-Control-Max-Age`.
+
+A server MUST answer a single byte-range request on an object with `206` and a
+`Content-Range` whose complete length is `envelope_len` (RFC 9110 §14.4, §15.3.7), or
+with `200` and the whole object. It MAY answer a multi-range request with `200`.
+
+### 5.4 Sizes
+
+A publisher SHOULD give each listed object's `n` and, for a `WAI2`, its `h` (§3.1). A
+client that holds `n` below `1009` fetches the object whole: no head proof can cover
+less than one chunk.
+
+### 5.5 Every media class (informative)
+
+The binding is the same for every capability. What a range fetch saves, and where a
+refinement sits, depend on the media class.
+
+| registry media | typical object | range fetch saves | refinement, carried as |
+|---|---|---|---|
+| image | `WAI2`: a pinned integer learned rendition beside standard image renditions | every rendition but the pick | a refinement component, or layer objects |
+| audio | a `WAI1` per segment; or a `WAI2` with an integer or learned codec beside a standard one | the renditions not picked | a refinement component, or layer objects |
+| video | one object per segment or part, aligned with a classical ladder (§11) | the same, per segment | an enhancement companion such as `wai.video.lcevc` (§10.3), a refinement component, or layer objects |
+| metadata (companions) | bound to a rendition in a `WAI2` | fetched only with its rendition | — |
+| interactive (worlds, feeds, avatars) | snapshot and op-delta objects | head first: decide, then fetch | later op-deltas are separate objects |
+| volumetric | `WAI2`: an integer splat codec beside a standard mesh, splat or point-cloud payload | the rendition not picked | a refinement component, or layer objects |
+| haptic, text | small objects | nothing: below 1009 bytes they are fetched whole (§5.4) | — |
+| binary (parameter sets, circuits, ternary) | a parameter set served as an immutable resource, verified by its pin (§8.5) | — | — |
+| records and derivations | carried as objects, never named in `codecs` (`codecs_not_media`) | — | — |
+
+## 6. The head proof
+
+### 6.1 What it proves
+
+A head proof lets a client verify the first `covered_len` envelope bytes against the cid
+without the rest of the object. The content hash is a BLAKE3 root over 1024-byte chunks
+of `X = "moq-jwp:object\x01" ‖ envelope`; the proof is the chaining values of the
+subtrees of `X` that lie wholly at or after offset `c = 15 + covered_len`. It is a
+pure function of the object: anyone holding the object can produce it, and a wrong one
+fails verification.
+
+### 6.2 Format (`<cid>.wai.hp`)
+
+All integers are little-endian ([SPEC](../SPEC.md) §2).
+
+| offset | size | field |
+|---|---|---|
+| 0 | 4 | magic `57 48 50 31` ("WHP1") |
+| 4 | 32 | cid, raw bytes |
+| 36 | 8 | `envelope_len` (u64) |
+| 44 | 8 | `covered_len` (u64), equal to §2's formula |
+| 52 | 1 | `n_cv` (u8), at most 64 |
+| 53 | 32·n_cv | chaining values, in verification order |
+
+The file is exactly `53 + 32·n_cv` bytes. When `covered_len = envelope_len`, `n_cv` is
+0 and the client verifies the whole object: its content hash is computed over the bytes
+it holds. A head proof is served under §5.3's cache headers with
+`Content-Type: application/octet-stream`.
+
+### 6.3 Verification
+
+With `L = 15 + envelope_len`, `c = 15 + covered_len`, and
+`left(n) = 1024 · 2^⌊log₂((n−1)/1024)⌋`, when `covered_len < envelope_len`:
+
+```
+cv(start, len):
+  if start ≥ c:            take the next chaining value from the proof
+  elif start + len ≤ c:    the non-root chaining value of the len bytes of X at start,
+                           a subtree whose first chunk has counter start/1024
+  else:                    parent_cv(cv(start, left(len)), cv(start+left(len), len−left(len)))
+root = parent_root(cv(0, left(L)), cv(left(L), L − left(L)))
+```
+
+`parent_cv` and `parent_root` are BLAKE3's parent node in hash mode, without and with
+the ROOT flag. `c` is a multiple of 1024 whenever `covered_len < envelope_len`, so
+every subtree the procedure meets lies wholly before `c` or wholly at or after it once
+it is split far enough. A client checks, in order:
+
+1. the file has the format above; its cid is the object's; its `envelope_len` equals
+   the complete length of every `Content-Range` and the length of every `200` body it
+   received; and its `covered_len` is `envelope_len`, with `n_cv` 0, or is less than
+   it with `15 + covered_len` a multiple of 1024 (`head_proof_malformed`);
+2. the chaining values are consumed exactly, and `root` equals the cid
+   (`head_proof_mismatch`);
+3. `envelope_len` is the length the verified head gives (§5.1), and `covered_len` is
+   §2's formula for that head (`head_proof_malformed`). The root does not encode the
+   object's length, so a wrong `envelope_len` that leaves the tree's shape unchanged
+   passes check 2 and is refused here.
+
+No covered byte is read as a head before check 2 passes. A producer writes the
+chaining values in the order the procedure consumes them.
+
+## 7. Byte-range fetch of a `WAI2` component
+
+A client that fetches part of an object MUST verify, before it presents or decodes
+anything, every byte it uses: the head against the cid (§6), and each component it
+uses against the `sha256` of its entry in that verified head ([SPEC](../SPEC.md) §7.1).
+The procedure:
+
+1. In parallel, request `Range: bytes=0-(E−1)`, with `E` the `h` fragment if given and
+   16369 otherwise, and request `<cid>.wai.hp`.
+2. Check each response (§7.1). If `covered_len` exceeds the bytes received, request the
+   rest of the first `covered_len` bytes.
+3. Verify the head (§6.3). Parse it (`head_malformed`); apply §5.1; refuse a
+   capability the variant's union does not list (`codecs_undeclared`).
+4. Select from the head exactly as [SPEC](../SPEC.md) §7.1 selects, deferring only
+   the component-digest test to the bytes. A deployer policy MAY reorder and restrict
+   the entries considered, as SPEC §7.1 allows. The result is the picked entry, the
+   companions SPEC §7.1 binds to it, and the refinement components whose
+   `refines.base` is its `id`.
+5. If the picked entry, or a bound companion the sink will apply that is not a
+   refinement (§2), states no `sha256`, go to step 7 (`component_digest_absent`). A
+   refinement that states none is dropped: the client does not request it, and the
+   base's path does not change.
+6. Request the ranges of the picked component and of the companions and refinements it
+   will apply that the client does not already hold: one request per range, merging
+   ranges that touch only when they are in the same priority class (§10.1), so a
+   refinement is always requested on its own. Verify each against its entry's
+   `sha256`. On a mismatch of the picked component or of a companion that is not a
+   refinement (`component_digest_mismatch`), discard every byte held past
+   `covered_len` and go to step 7. A refinement that mismatches is dropped alone.
+7. Request the rest, `bytes=covered_len-` (or `GET` the whole object), verify the whole
+   envelope against the cid (`object_digest_mismatch`), and select as [SPEC](../SPEC.md)
+   §7.1 selects on the whole envelope.
+
+A client SHOULD also go to step 7 when the base-class bytes step 6 would request — the
+picked component's and those of the companions that are not refinements — are at least
+90 % of the bytes after `covered_len`. A refinement's bytes never count, so a refinement
+never moves its base to step 7; when the base goes there, the rest of the object carries
+the refinement's bytes with it. A client MUST NOT send a multi-range request and rely
+on a multipart answer. A `WAI1` has one component, its payload: a client decides from
+its verified head whether it can dispatch it ([SPEC](../SPEC.md) §4), and only then
+fetches the rest after the head. A layer object (§10.4) is never dispatched: the
+client fetches it whole, at refinement urgency, verifies it against its cid, and hands
+it to [staged-delivery](staged-delivery.md) §4.
+
+### 7.1 Response checks
+
+For each request a client checks, in order:
+
+- the status is `206`, or `200` with a body that is the whole object
+  (`http_status_unexpected`);
+- no `Content-Encoding` other than none is present (`content_coding_present`);
+- on a `206`, `Content-Range` names exactly the requested range, its last position
+  reduced to `envelope_len − 1` where the request reached past the end
+  (`content_range_mismatch`), and its complete length equals the head proof's
+  `envelope_len` (`complete_length_mismatch`). Each of its numbers is one or more ASCII
+  digits, RFC 9110 §14.4's `1*DIGIT`: a sign, a separator, a space inside the field or
+  another script's digit is refused the same way;
+- on a `200`, the body length equals the head proof's `envelope_len`
+  (`complete_length_mismatch`).
+
+A refused response's bytes are discarded and never presented. A refused base-class
+response ends the fetch; a refused refinement-class response abandons that refinement
+(§10.2), and the base goes on. A client MAY retry once with `Cache-Control: no-cache`.
+
+### 7.2 One pick on every path
+
+On bytes that verify, §7 picks the same entry that [SPEC](../SPEC.md) §7.1 picks on
+the whole envelope: the digest test runs on the bytes either way, and every case in
+which a range client cannot run it (no `sha256`, a mismatch) is decided on the whole
+envelope. A range client never picks an entry the whole-envelope selection would skip,
+and never skips one it would pick. When the head alone shows that no entry can be
+picked, the client stops there and reports the reasons the head gives; an entry whose
+pin was refused may also fail its digest, which only its bytes would show.
+
+## 8. Receipts, keys, grants and parameter sets over HTTP
+
+### 8.1 Receipt files
+
+`rcpt/<h>.json`, resolved against the object's URI, holds exactly one receipt: a group
+receipt whose link hash ([jwp-receipts](jwp-receipts.md) §3 step 3) is `h`, in its
+canonical form, or a claim whose `link_hash` (§2.4.3) is `h`, in its JCS form. It is
+immutable and served under §5.3's cache headers with `Content-Type: application/json`.
+A client refuses a receipt file whose computed hash is not its name
+(`receipt_name_mismatch`). A group receipt's `parent_receipt_hash` is the name of its
+parent's file, so a client resolves [jwp-receipts](jwp-receipts.md) §3 step 3 by
+fetching `rcpt/<parent_receipt_hash>.json`, and reports `parent_not_held` when it
+cannot, never skipping the step.
+
+### 8.2 Receipt index
+
+`<cid>.wai.receipts` is the sidecar carriage of the `WAI_RECEIPT` property
+([moq-streaming-format](moq-streaming-format.md) §5):
+
+```json
+{ "kind": "wai-receipt-index", "object": "<cid>",
+  "delivery": [ { "property": { …WAI_RECEIPT… }, "object_receipt": { …jwp-receipts §2.4.2… } } ],
+  "claims":   [ "<link hash>" ] }
+```
+
+It is mutable and is served with `Cache-Control: no-cache, no-transform` and an `ETag`
+of its own. It is a locator, never evidence. A client checks each item on its own and
+ignores, item by item, one that fails:
+
+- a delivery item: the property's `content_hash` and the object receipt's
+  `content_hash` equal the cid (`receipt_not_about_object`); the group receipt is
+  fetched as `rcpt/<property.group_receipt>.json` and verified under
+  [jwp-receipts](jwp-receipts.md) §3 steps 1–5, step 4 as §8.3 states; the property
+  is checked against the object receipt as moq-streaming-format §5 states;
+- a claim: verified under [jwp-receipts](jwp-receipts.md) §3.1; its `subject` is the
+  cid or the link hash of a group listed in the index. A soft-binding claim
+  ([jwp-receipts](jwp-receipts.md) §2.6.2) is reported under the ancestor rule (§3.2):
+  as attesting the ancestor, never the object in hand.
+
+### 8.3 A range-fetched object
+
+A client that holds only the head and some components cannot recompute the content
+hash over the envelope. Under [jwp-receipts](jwp-receipts.md) §3 step 4 it takes the
+cid its head proof verified, and the receipt then attests the object the cid names; the
+components it holds are attested through the verified head's `sha256` values.
+
+A component's exploded envelope ([SPEC](../SPEC.md) §7.1, *Exploding a component*) is
+a function of the verified head and the component's bytes, so a client that holds them
+builds it. A receipt about that exploded envelope is checked under step 4 over the
+envelope the client built, as for any object: this is how a refinement component
+fetched by range meets [staged-delivery](staged-delivery.md) §10, which applies a layer
+only on a receipt checked over its envelope bytes.
+
+### 8.4 Keys, statuses and grants
+
+| resource | location | `Cache-Control` |
+|---|---|---|
+| key log ([jwp-receipts](jwp-receipts.md) §7.2) | `/.well-known/wai-keys` | `max-age=300, no-transform` |
+| key status (§7.9 there) | `/.well-known/wai-key-status` | `max-age` at most a quarter of the head's `status_max_age_s`, `no-transform` |
+| module grants (§7.9 there) | `/.well-known/wai-grants/<module digest>.json`: `{"kind":"wai-module-grants","module":"<digest>","grants":[…]}` | `max-age=300, no-transform` |
+
+All are `application/json`. A verifier that **anchors** an origin fetches its key log
+from the origin over HTTPS without following a redirect, as [jwp-receipts](jwp-receipts.md)
+§7.3 states, and with `Cache-Control: no-cache`. Later revisions MAY come through any
+cache: each is checked against its parent, and a rolled-back copy is reported
+(`key_log_rolled_back`). The grants file is a locator: each grant is checked on its
+own.
+
+### 8.5 Parameter sets
+
+A parameter set MAY be served as an immutable resource named by its pin's digest
+(`<base>/<sha256>`), under §5.3's cache headers with `application/octet-stream`. A
+sink verifies it by its pin ([SPEC](../SPEC.md) §3.1) and decodes against it only if
+the checks of [jwp-receipts](jwp-receipts.md) §7.9 pass. A set they refuse is not
+held, and dispatch continues as [SPEC](../SPEC.md) §4 and §7.1 state.
+
+### 8.6 Playlist receipts
+
+A WAI playlist (§11) is authenticated by a manifest receipt (`wai.video.manifest`,
+[SPEC](../SPEC.md) §5) whose `manifest_hash` is the BLAKE3 of the playlist bytes,
+served immutable at `mr/<manifest_hash>.json` resolved against the playlist URI. Each
+revision of a live playlist has its own receipt, whose `parent_receipt_hash` names the
+previous one. A playlist receipt MAY carry `render`, the rendering parameters of the
+playlist it signs (version, media sequence, discontinuity sequence, part target,
+whether it ends), and `extras`, the per-segment lines that rendering adds
+(discontinuities, program date-time, parts, layer lines). When both are absent, the
+playlist is rendered as before. `manifest_hash` covers the rendered bytes, so both are
+bound by the signature through it.
+
+## 9. Cache rules
+
+An HTTP cache that stores and serves objects under this extension is a transparent
+byte store, not a relay under [jwp-receipts](jwp-receipts.md) §4.1 (see §4.5 there).
+It is bound by §4.3 there, and it MUST:
+
+1. store and serve an object byte for byte, and not transform it (RFC 9111 §5.2.2.6)
+   or apply a content coding to it;
+2. answer a single byte-range request from a stored complete object with `206` and the
+   exact bytes (RFC 9110 §14), and with `416` and `Content-Range: bytes */<len>` for
+   an unsatisfiable range. On a miss it MAY forward the range, or fetch the whole object
+   and answer from it;
+3. keep `ETag`, `Content-Type`, `Cache-Control` and, on a `200`, `Content-Length` as the
+   origin sent them;
+4. not vary a stored object by any request header;
+5. evaluate `If-Range` with a strong comparison (RFC 9110 §13.1.5, §8.8.3.2);
+6. store head proofs, receipt files, playlist receipts and parameter sets under the same
+   rules, and revalidate receipt indexes on every use and the other §8.4 resources per
+   their `Cache-Control`;
+7. where a configuration cannot meet 1–6 for a request, pass the request through
+   uncached and relay the origin's bytes unchanged.
+
+A cache SHOULD NOT revalidate an object while it is fresh (RFC 8246 §2). A node that
+serves other bytes than an object's — recompressed, re-packed or split — derives a new
+object: it publishes the new bytes under their own cid, with its own receipts and a
+soft-binding claim to the ancestor ([jwp-receipts](jwp-receipts.md) §2.6.2), listed in
+the new object's index, and MUST NOT serve them under the original name or an alias of
+it. Over HTTP an edge selects only by serving such derived objects; a client selects by
+range.
+
+## 10. Delivery order, deadlines and refinements
+
+### 10.1 Priority
+
+A base and each refinement are separate requests. A client MUST NOT let a request whose
+bytes it needs for a base wait on a refinement's bytes, and a cache MUST NOT hold a
+base response for a refinement request. A client presents a base as soon as it has
+verified it (§7), and applies each refinement when that refinement arrives and
+verifies; it never holds a verified base back for its refinements. A base, once
+verified, is decided: no later response changes its bytes or its outcome. Of a
+response to a refinement request, a client keeps only the bytes of the range it
+requested, even from a `200` that carries the whole object (§7.1), so a refinement's
+response never reaches its base's bytes, before or after the base verified. A client SHOULD signal urgency 2 for a base
+and urgency 5 with incremental for a refinement (RFC 9218 §4.1, §4.2): by the
+`Priority` header (§5 there), or in a browser by the fetch `priority` option. A
+deadline never applies to a base: a base request that is never answered ends the fetch
+(`base_unanswered`).
+
+### 10.2 Deadlines
+
+A client presenting live sets a deadline on every refinement request: the latest time
+at which the refinement, once received and verified, can still be applied, which for a
+layer is its `lead_ms` before the presentation time of the first unit it covers
+([staged-delivery](staged-delivery.md) §8). When the deadline passes, the client
+abandons the request and presents what it has. This is the HTTP counterpart of the
+delivery timeout after which a MoQ relay drops an object; on either binding a
+refinement never stalls its base, and a layer that arrives late is not applied to the
+units that are already due (`deadline-missed`, staged-delivery §8).
+
+A deadline runs on the client's clock from the moment the base verified, the moment
+§10.1 presents it: the time the response that completed the base was received. A
+refinement that has not arrived and verified within it is abandoned, and the base,
+already presented, is unaffected. What the clock read before the base verified never
+moves that start. A clock that steps back has not passed a deadline until it again
+reaches it, and a deadline past the clock's range is at its end. The reference
+client's session reads no clock of its own: every response it is given carries the
+caller's time, and the caller tells it the time between responses.
+
+### 10.3 Enhancement companions and refinement components
+
+A companion whose registered role is `enhancement` (for example `wai.video.lcevc`,
+[SPEC](../SPEC.md) §5) and a component with `role: "refinement"` are refinements inside
+the object: each range is requested in its own request, at refinement priority, after
+or beside the base component's. A client that abandons an enhancement companion
+presents the base, as [SPEC](../SPEC.md) §7.1 lets a sink that does not apply a
+companion present the rendition; one that abandons a refinement component presents the
+stage it has ([staged-delivery](staged-delivery.md) §7). A refinement that states no
+`sha256`, or does not match it, is dropped (§7 steps 5 and 6), and its base is
+unaffected.
+
+### 10.4 Layer objects
+
+A layer object is a `WAI1` whose capability is refinement-only ([SPEC](../SPEC.md) §5,
+[staged-delivery](staged-delivery.md) §3). Whether an object is one is decided by its
+capability alone: a `WAI1` whose capability is a payload is an ordinary object even
+when it carries `refines` (which staged delivery §3 forbids its producer to write), so
+a client dispatches it under SPEC §4 and does not read `refines`. A client never
+dispatches a layer object under SPEC §4: it
+fetches it whole, at refinement urgency (§10.1) and under a deadline (§10.2), verifies
+it against its cid, and hands it to [staged-delivery](staged-delivery.md) §4, which
+decides what it does to its base. A client that finds one by its head (§7) does the
+same with the rest of it. Against a declared union (§4.2), a layer is declared only in
+the `alt` of its own base's capability. An object a playlist lists as a layer that is
+not one, a payload carrying `refines` among them, is refused (`not_a_layer`); a layer's
+request abandoned at its deadline, or whose response
+§7.1 refuses, leaves the layer not delivered (§10.5).
+
+A WAI media playlist lists the layer objects of a segment or part after its `EXTINF`
+or `EXT-X-PART` line, in the order a sink applies them:
+
+```
+#WAI-LAYER:N=<1..255>,URI="<cid>.wai#n=…"
+```
+
+Its attributes are an HLS attribute list (RFC 8216 §4.2): `N` a decimal integer from 1
+to 255, `URI` a quoted string, neither named twice; an attribute this revision does not
+define is ignored. A line that breaks these is `layer_tag_malformed`.
+
+`N` is a locator: it lets a client choose the depth it fetches before it fetches any
+layer. The layer an envelope brings its units to is its `refines.layer`, inside the
+envelope and so inside its content hash; a sink reads it from there and ignores `N`, as
+[staged-delivery](staged-delivery.md) §13 reads a MoQ layer header. The base is layer
+0, the segment or part URI. A client fetches to the depth its policy chooses, each
+layer under §10.1 and §10.2.
+
+### 10.5 Objects not delivered
+
+A refinement a client abandoned is not delivered to it. Its receipts stay listed in
+the index; the client neither presents it nor reports its delivery, and the group
+receipt stays valid for the objects it did receive ([jwp-receipts](jwp-receipts.md)
+§4.4).
+
+## 11. HLS and DASH adjacency
+
+### 11.1 Mode N (native objects) — the default
+
+- The classical multivariant playlist and MPD are unchanged. A publisher MAY add one
+  line to the multivariant playlist:
+  `#EXT-X-SESSION-DATA:DATA-ID="science.transaction.wai.multivariant",VALUE="<URI of wai.m3u8>"`,
+  resolved against the playlist's URI. No other line changes.
+- `wai.m3u8` uses HLS playlist syntax. Its media segments are WAI objects, which are
+  not a format of RFC 8216 §3.1, so it is not an HLS presentation and MUST NOT be
+  offered to a client that does not implement this extension. Each `EXT-X-STREAM-INF`
+  carries `CODECS` (the union, §4.2), `X-WAI-FLOOR` (the floor), and `BANDWIDTH` and
+  `AVERAGE-BANDWIDTH` computed from the objects' `envelope_len` over their durations
+  (peak and mean of `8·envelope_len/duration`), never stated by hand.
+- `wai.mpd` is a separate MPD with one `AdaptationSet` per WAI stream,
+  `mimeType="application/wai"`, `@codecs` (the union), an
+  `EssentialProperty schemeIdUri="tag:transaction.science,2026:wai/http-delivery"`
+  so a client that does not know it ignores the set, and a
+  `SupplementalProperty schemeIdUri="tag:transaction.science,2026:wai/floor"` whose
+  `value` is the floor.
+
+### 11.2 Alignment
+
+A WAI media playlist is **adjacent** to a classical media playlist when, segment for
+segment, they have the same `EXT-X-MEDIA-SEQUENCE`, `EXT-X-DISCONTINUITY-SEQUENCE`,
+`EXTINF` durations to the millisecond, discontinuities and `EXT-X-PROGRAM-DATE-TIME`
+values, and, where both carry parts, the same `EXT-X-PART-INF:PART-TARGET` and the same
+part durations to the millisecond in each segment. In DASH: the same `Period@id`s and
+`@start`s, and a `SegmentTimeline` with the same timescale, `t` and `d`. The WAI
+segment (or part) with a sequence number covers exactly the presentation interval of the
+classical one, so a sink can move between them at any boundary. A packager MUST NOT
+publish a WAI playlist that breaks this (`adjacency_misaligned`). `#WAI-LAYER` lines
+do not affect alignment.
+
+### 11.3 Live at segment granularity (Live-S)
+
+Each segment is one object, listed as `<cid>.wai#n=…&h=…` once it is complete. A client
+presents an object only after its bytes verify against the listed cid. The latency
+from the end of a segment's media interval to presentation is at least
+
+  `S_floor = e + p + r_pl + r_obj + v`
+
+where `e` is encode and packaging time, `p` the time to publish and list, `r_pl` the
+wait for a playlist that lists the object (with blocking reload, one request time),
+`r_obj` the object request time (one round trip and transfer), and `v` the verification
+time.
+
+### 11.4 Low-latency live (Live-P)
+
+Each part is its own object, served under an alias, and listed with its cid:
+
+```
+#EXT-X-PART-INF:PART-TARGET=0.333
+#EXT-X-PART:DURATION=0.333,INDEPENDENT=YES,URI="live/720/1200.3.wai#cid=<hex>&n=…"
+#EXT-X-PRELOAD-HINT:TYPE=PART,URI="live/720/1200.4.wai"
+```
+
+- The alias of a part names those bytes for its lifetime (§5.2). A preload hint names
+  the alias before the part exists; the origin holds the request until it does.
+- A client presents a part only after its bytes hash to the cid that a later playlist
+  revision lists for that alias. Issued together, the hint request and a blocking
+  reload (`_HLS_msn`, `_HLS_part`) complete when the part is complete, so the floor is
+
+  `P_floor = e + max(r_obj, r_pl) + v`
+
+  against `e + r_obj` for a part presented without verification: the added latency is
+  `max(0, r_pl − r_obj) + v`, with `v` the BLAKE3 time of one part.
+- The segment line names a separate segment object, published when the segment closes;
+  it serves every client behind the live edge. Parts stop being listed as the HLS
+  specification permits, and an origin MAY then delete them.
+- An `INDEPENDENT=YES` part is one whose envelope decodes without another object.
+
+### 11.5 Live to on demand
+
+Every object is immutable from the moment it is listed, so a live playlist becomes
+on-demand by appending `EXT-X-ENDLIST`; no object is rewritten.
+
+### 11.6 Playlist authentication
+
+A WAI playlist SHOULD be authenticated by its receipt (§8.6). A client that verifies it
+holds the cids, durations and order its signer published. Without it, which objects a
+playlist names is only as trustworthy as the connection to the origin that served it;
+each object is still bound to the cid the playlist names. A client reports which held:
+**listed** (bytes match a cid in a playlist fetched over HTTPS from the origin the
+multivariant playlist names), **signed** (that playlist's receipt, or the object's
+receipt, verified), and the confirmation level of [jwp-receipts](jwp-receipts.md) §7.4.
+In Live-P a client MAY present at **listed** and verify the playlist receipt after
+presenting; it MUST NOT report the part as signed until it has.
+
+A WAI segment whose payload is a classical segment's media relates to the classical
+package's segment map (`wai.video.package`) by sequence number: the package's
+`content_hash` identifies the media and the cid identifies the envelope that carries it.
+They are hashes of different bytes, and neither replaces the other.
+
+### 11.7 Mode F (fragmented MP4) — provisional
+
+Appendix B defines ISOBMFF sample entries that carry one WAI envelope per sample. Such
+segments are fragmented MP4 (RFC 8216 §3.3), so a WAI track could be a variant of the
+classical multivariant playlist. The 4CCs are not registered: until they are, Mode F
+MUST NOT be published outside test material.
+
+### 11.8 CTA-5005-B
+
+In Mode N the classical presentation's conformance to CTA-5005-B is preserved by byte
+equality of its manifests. The `EXT-X-SESSION-DATA` option and Mode F are to be checked
+against CTA-5005-B's clauses before use.
+
+## 12. Capability probe
+
+### 12.1 The Sink Capability Descriptor
+
+```json
+{ "wai_sink": 1,
+  "containers": ["WAI1", "WAI2"],
+  "caps": { "<capability>": { "via": "wasm" | "ua" | "host",
+                              "asked": { "<ua codec string>": true | false },
+                              "provisional": true | false } },
+  "held_sets": { "<capability>": [ "<pin sha256>" ] } }
+```
+
+- `wasm`: decoded by the sink's own compiled decoder. `ua`: by a user-agent decoder,
+  under the codec strings in `asked`. `host`: by a native host. A capability the sink
+  cannot decode is absent.
+- `provisional` is true for a `ua` capability: the decoder answered for the profiles
+  asked, not for a given payload.
+- `held_sets` lists, per capability, the digests of the parameter sets that passed
+  [jwp-receipts](jwp-receipts.md) §7.9 when the descriptor was built. A revoked set is
+  never listed.
+
+### 12.2 Asking the user agent
+
+A capability is `ua` only if the sink asked the user-agent decoder it will hand the
+payload to, under that decoder's own name, and the answer was supported: WebCodecs
+`isConfigSupported` for a video or audio elementary stream, or an image decode of a
+known sample. Media Capabilities is asked only as a further question about a decoder
+already found. Before decoding a payload through a `ua` capability, a sink MUST ask
+again with the configuration that payload's own header gives; a refusal makes the
+capability unsupported for that object, and selection continues.
+
+### 12.3 Support
+
+`supports(codecs, descriptor)` is §4.2's rule with "reads the container" read as "is in
+`containers`" and "supports `cap`" read as "`wai.<cap>` is in `caps`".
+
+### 12.4 Capable share (informative)
+
+For a WAI variant V and a set C of sessions observed in a stated window:
+
+  capable_share(V, C) = |{ s ∈ C : supports(codecs(V), descriptor(s)) ∧ probe_ok(V, s) }| / |C|
+
+`probe_ok(V, s)` holds when the session decoded V's published probe object and its
+output had the published digest (an exact tier), or decoded without error (any other
+tier). A report states |C|, the window, how C was sampled and the descriptor version. It
+is a share of sessions, not of devices or people.
+
+## 13. Reasons
+
+| reason | raised at |
+|---|---|
+| `object_length_mismatch` | §5.1 |
+| `head_malformed` | §7 step 3 |
+| `head_proof_malformed`, `head_proof_mismatch` | §6.3 |
+| `http_status_unexpected`, `content_coding_present`, `content_range_mismatch`, `complete_length_mismatch` | §7.1 |
+| `component_digest_absent` | §7 step 5 (a reason to fetch whole, never a skip) |
+| `component_digest_mismatch` | §7 step 6 ([SPEC](../SPEC.md) §7.1's reason) |
+| `object_digest_mismatch` | §7 step 7, or any whole fetch |
+| `receipt_name_mismatch`, `receipt_not_about_object` | §8.1, §8.2 |
+| `codecs_malformed`, `codecs_not_media`, `codecs_candidate`, `codecs_no_common_capability`, `codecs_undeclared`, `codecs_layer_unbound` | §4 |
+| `base_unanswered` | §10.1 |
+| `not_a_layer`, `layer_tag_malformed` | §10.4 |
+| `adjacency_misaligned` | §11.2 |
+
+Selection, pin, receipt, key and module reasons are those of [SPEC](../SPEC.md) §3.1
+and §7.1 and [jwp-receipts](jwp-receipts.md) §3, §7.7 and §7.9, and the layer reasons
+those of [staged-delivery](staged-delivery.md) §4.2, unchanged. An object at which
+selection picks nothing is inert at the sink, with each entry's reason, as SPEC §7.1
+step 5 states.
+
+## 14. Conformance
+
+- [`http-conformance/`](../http-conformance/) holds objects, head proofs and cases for
+  §4–§7 and §10 and their reasons, with positive cases. `wai_http_vectors verify`
+  (also `wai http vectors verify`) and the independent `http_verify.py`, which shares no
+  code with `wai-rs`, report the same outcome for every case, and for every case of a
+  seeded differential over inputs outside the corpus (`wai_http_vectors fuzz`): every
+  `Content-Range`, `codecs` value, `#WAI-LAYER` line, manifest, member type, encryption,
+  `refines` and layer sequence it generates.
+- [`cache-conformance/`](../cache-conformance/) checks §9 against HTTP caches and
+  reports, per cache label and version, the configuration that meets it. Products are
+  not named in published reports.
+
+## 15. Security and privacy considerations
+
+- **What a range fetch establishes.** A head proof binds the head to the cid; the head's
+  `sha256` values bind each component to the head; a receipt binds the cid to a signer;
+  a playlist receipt binds the list of cids to a signer. Each link is a hash or a
+  signature.
+- **Changed bytes.** A cache that changes bytes changes a hash and is refused. A content
+  coding is refused before any byte is used (§7.1), so no decompression runs on the
+  range path.
+- **Lengths.** `Content-Range`, `Content-Length`, `n` and `h` are untrusted; every
+  length that matters is checked against the head proof.
+- **Playlists.** An unsigned playlist can name other objects; §11.6 says what a client
+  then holds.
+- **Privacy.** The ranges a sink fetches reveal which rendition it picked, and so part
+  of its capabilities, to every cache and the origin. A sink that does not want this
+  fetches whole objects.
+- **Unsigned files.** Receipt indexes, grants files and aliases are locators, never
+  evidence.
+
+## Appendix A — CDNI configuration
+
+Path patterns `/objects/*.wai`, `*.wai.hp`, `rcpt/*` and `mr/*` take the RFC 8006
+metadata `MI.Cache` with `include-query-strings: []`, and `MI.SourceMetadata`; a
+receipt index (`*.wai.receipts`) takes the cache rule with no storage beyond
+revalidation. RFC 8006 has no metadata for range handling, transformation or a time-to-
+live override: a configuration interface that has them states, for these paths, the
+behaviour §9 requires.
+
+## Appendix B — ISOBMFF sample entries (provisional; 4CCs not registered)
+
+```
+aligned(8) class WAIConfigurationBox extends FullBox('waiC', 0, 0) {
+    unsigned int(8)  wai_major;                 // 1
+    unsigned int(8)  max_minor;                 // highest manifest MINOR in the track
+    unsigned int(16) element_len;
+    unsigned int(8)  element[element_len];      // the track's union element, UTF-8
+    unsigned int(16) floor_len;
+    unsigned int(8)  floor[floor_len];          // the track's floor element, UTF-8
+}
+class WAIVisualSampleEntry(type) extends VisualSampleEntry(type)    { WAIConfigurationBox config; } // 'vide'
+class WAIAudioSampleEntry(type)  extends AudioSampleEntry(type)     { WAIConfigurationBox config; } // 'soun'
+class WAIMetaSampleEntry(type)   extends MetaDataSampleEntry(type)  { WAIConfigurationBox config; } // 'meta'
+// type = 'wai1' when every sample is a WAI1 envelope, else 'wai2'
+```
+
+- Each sample is one envelope, byte-identical, so its cid is unchanged.
+- A sample is a sync sample when it decodes alone.
+- Composition time equals decode time.
+- There is no `encv`/`enca` wrapping; confidentiality is [SPEC](../SPEC.md) §6.
+
+## Appendix C — Mapping to moq-streaming-format
+
+| MoQ ([moq-streaming-format](moq-streaming-format.md)) | HTTP (this extension) |
+|---|---|
+| object = one envelope (§3 there) | object `<cid>.wai` (§5.1) |
+| `packaging: "wai"` | media type `application/wai` |
+| catalog `wai_capabilities`, exhaustive (§4 there) | `codecs` union (§4.2); `codecs_undeclared` is the same protocol error |
+| (no floor) | `X-WAI-FLOOR` / DASH `SupplementalProperty` |
+| `WAI_RECEIPT` property (§5 there) | index item `property` (§8.2) |
+| group receipt per group | `rcpt/<link hash>.json`; a group per segment (on demand) or per segment with its parts (Live-P) |
+| a layer object on its own track | a layer object listed by `#WAI-LAYER` (§10.4); its layer is its `refines.layer` either way |
+| a subscriber's layer cap | the client's depth policy; nothing is sent to the edge |
+| a relay drops layers above the cap, receipts intact | the client does not request them; caches never drop; receipts stay listed (§10.5) |
+| the delivery timeout after which a relay drops an object | the client's refinement deadline (§10.2) |
+| publisher priority | RFC 9218 urgency (§10.1) |
+
+## Appendix D — Worked example
+
+**The envelope.** A `WAI2` with a 560-byte manifest:
+
+```
+{"wai":"1.1","media":"video","intent":"replicate","renditions":[{"capability":"wai.video.av1","kind":"av1","id":"low","sha256":"f541874101876255b4baf3a739778d04cb9cba25ffa38b30bc1fb8b0701f2a45"},{"capability":"wai.video.av1","kind":"av1","id":"high","sha256":"b76bf31be170d9df8eafbd020941b5fd4b7ab017af6a1e5c1c03e909aa8f9fb7"},{"capability":"wai.meta.hdr10plus","kind":"descriptor","id":"hdr","sha256":"74739b7242c81aa5ec2a1601fd04a5f81bed0302970e6a51f3a7dc9e92ea8520","role":"companion","companion_of":"wai.video.av1","companion_of_id":"high"}],"target":null}
+```
+
+Payloads, synthetic (they show the layout, and decode to nothing):
+- `low`: 3,000 B, byte i = (7i+3) mod 256;
+- `high`: 50,000 B, byte i = (13i+5) mod 256;
+- `hdr`: 200 B, byte i = (31i+1) mod 256.
+
+**Layout.**
+- `head_len` = 594. Table: `0300 00000000 b80b0000 b80b0000 50c30000 08cf0000 c8000000`.
+- `envelope_len` = 53,794.
+- cid = `eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228`.
+- `covered_len` = 1009, `n_cv` = 6, so the proof file is 245 B.
+- Component ranges: `low` [594, 3593], `high` [3594, 53593], `hdr` [53594, 53793].
+- `codecs` = `wai2.video.av1+meta.hdr10plus`, and the floor is the same.
+
+The plans below assume the object is listed with `#h=1009` (and `n`), so the first
+request ends at `covered_len`. Without `h`, the first request is 16,369 bytes.
+
+**Plan 1: the sink picks `low`** (the table's order, or a policy under low throughput).
+- Requests: `bytes=0-1008` (1,009 B) and the proof (245 B), then `bytes=1009-3593`
+  (2,585 B).
+- Body bytes: 3,839, with `envelope_len` 53,794.
+- Without `h`: the first request, `bytes=0-16368`, holds `low` whole; 2 requests and
+  16,614 body bytes.
+
+**Plan 2: a policy reorders to `high`, which binds `hdr`.**
+- [3594, 53793] is 50,200 B of base-class bytes: 951 ‰ of the 52,785 B after
+  `covered_len`, which is at least 900 ‰.
+- So the client requests `bytes=1009-53793` and verifies the whole envelope.
+- Body bytes: 53,794 and the proof's 245.
+- Without `h`: the first request holds [0, 16368], and the base-class bytes still
+  needed, [16369, 53793], are 37,425 B, 709 ‰ of the rest; so a range fetch of 3
+  requests and 54,039 body bytes.
+
+## Appendix E — References and their verification status
+
+| reference | status |
+|---|---|
+| RFC 9110 §7.7, §8.4, §8.8.3, §13.1.5, §14.1–§14.6, §15.3.7, §15.5.17 | read |
+| RFC 9111 §5.2.2.6 · RFC 8246 §2 · RFC 6381 §3.2 · RFC 6838 §3.1, §3.2, §5.6 | read |
+| RFC 9530 §2, §3 · RFC 9218 §4.1, §4.2, §5 | read |
+| RFC 8216 §3.1, §3.3, §4.3.4.2, §4.3.4.4 · the HLS second-edition draft (its date only) | read |
+| RFC 8006 `MI.*` objects | read |
+| The HLS second-edition draft's `EXT-X-PART`, `EXT-X-PRELOAD-HINT` and blocking-reload clauses | not re-read here: §11.4 is to be checked against them |
+| CTA-5005-B | title and date only |
+| The BLAKE3 specification | the tree rule is checked by the reference implementation against whole-input hashing |
+| RFC 8615, RFC 8785, RFC 4151, RFC 5234, ISO/IEC 14496-12 and -15, ISO/IEC 23000-19, ISO/IEC 23009-1, the Fetch Standard (CORS-safelisted `Range`, `priority`), WebCodecs, Media Capabilities | not re-read here |
+
+Every row not read is read before this extension leaves Draft.
diff --git a/wai/extensions/jwp-receipts.md b/wai/extensions/jwp-receipts.md
index 5dd2439e5..a968fae01 100644
--- a/wai/extensions/jwp-receipts.md
+++ b/wai/extensions/jwp-receipts.md
@@ -67,6 +67,10 @@ Out of scope:
   the wire; receipts ride alongside WAI envelopes in the carrier
   protocol (e.g. a MoQT object header field, an HTTP trailer, a
   sidecar file).
+  [http-delivery](http-delivery.md) §8 defines the HTTP carriage:
+  receipt files named by link hash, a per-object index of `WAI_RECEIPT`
+  properties, playlist receipts, and the locations of key logs,
+  statuses and grants.
 - A codec. The receipt chain is opaque to the WAI capability dispatch
   in WAI SPEC.md §4. A receipt attests bytes; it does not interpret
   them.
@@ -1093,6 +1097,15 @@ match the algorithm style of WAI SPEC.md §4 (numbered, terminating).
    (`content_hash_mismatch`: the envelope was mutated in transit). An
    object receipt missing a member of §2.4.2, or carrying one neither
    §2.4.2 nor its label defines, is `malformed`.
+   A verifier that received only part of an object over HTTP takes as
+   the recomputed content hash the cid that a verified head proof
+   establishes ([http-delivery](http-delivery.md) §6), provided every
+   component it uses was checked against its entry's digest
+   (http-delivery §7). The object receipt then attests the object that
+   cid names. A receipt about a component's own object, its exploded
+   envelope ([SPEC](../SPEC.md) §7.1), is checked over that envelope,
+   which the verifier builds from the verified head and the component's
+   bytes (http-delivery §8.3).
 
 5. **Verify the Merkle inclusion proof.** In this order:
    - If the object receipt carries a class label (§2.4.2), check it as
@@ -1489,6 +1502,24 @@ chain across hops, a conforming relay:
 - Truncate the receipt to fewer fields than §2.4 requires, even when
   the carrier framing has size pressure.
 
+### 4.4. Objects not delivered
+
+A relay MAY drop an object whose delivery timeout has passed, and an
+HTTP client MAY abandon one ([http-delivery](http-delivery.md) §10.2).
+An object a subscriber did not receive is not delivered to it: it
+neither presents the object nor reports its delivery, and the group
+receipt stays valid for every object it did receive, each by its own
+inclusion proof (§3 step 5). A relay that drops an object MUST still
+forward the group receipt.
+
+### 4.5. HTTP caches
+
+An HTTP cache that stores and serves objects and receipt files byte for
+byte under [http-delivery](http-delivery.md) §9 is not a relay in the
+sense of §4.1 and §4.2: it fans out nothing, verifies nothing, and
+forwards what was requested. It is bound by §4.3. A node that verifies,
+filters or selects receipts is a relay.
+
 ---
 
 ## 5. Test vectors
@@ -2480,6 +2511,9 @@ revision the sink holds that the head descends from by `prev` — with its
 `seq`, under whose `root` the signature verifies. A status that is not
 held is ignored, as an injected revision is (§7.2).
 
+Over HTTP, a status and an origin's grants are served where
+[http-delivery](http-delivery.md) §8.4 states.
+
 **Module origins.** A sink holds a module only from an origin it accepts
 module grants from for the envelope and capability at hand — its
 **module origins**, each recorded with where it came from:
diff --git a/wai/extensions/moq-streaming-format.md b/wai/extensions/moq-streaming-format.md
index 6a96faf9f..a3629c0bf 100644
--- a/wai/extensions/moq-streaming-format.md
+++ b/wai/extensions/moq-streaming-format.md
@@ -164,6 +164,9 @@ Stated so it is not re-argued:
   should use CMSF; this packaging is for tracks whose objects are WAI envelopes.
 - It does **not** make MoQ WAI's transport. WAI remains carrier-agnostic; this
   is one binding among the several `jwp-receipts` §1 anticipates.
+- It is not the only binding. [http-delivery](http-delivery.md) binds the same
+  objects to HTTP, admits `WAI2` envelopes with verified component ranges, carries
+  `WAI_RECEIPT` in a sidecar index, and maps this extension in its Appendix C.
 - It does **not** pin a MOQT draft revision. MOQT is pre-Last-Call; an extension
   that pinned a moving target would be wrong within a meeting cycle. Where MOQT
   and this text disagree, MOQT wins and this text is the thing that must change.
diff --git a/wai/http-conformance/.gitattributes b/wai/http-conformance/.gitattributes
new file mode 100644
index 000000000..eff1df73a
--- /dev/null
+++ b/wai/http-conformance/.gitattributes
@@ -0,0 +1,2 @@
+# Hashed files: a line-ending conversion on checkout would change every digest.
+* -text
diff --git a/wai/http-conformance/README.md b/wai/http-conformance/README.md
new file mode 100644
index 000000000..1d4630b7d
--- /dev/null
+++ b/wai/http-conformance/README.md
@@ -0,0 +1,157 @@
+# http-conformance — HTTP delivery
+
+The conformance corpus of [http-delivery](../extensions/http-delivery.md) (§14): objects
+served as `<cid>.wai` with their `WHP1` head proofs (§6) and ETag sidecars, and cases
+for §4–§7 — the head, the head proof, the response checks, the plans, selection on the
+head and on the whole envelope, the byte-range procedure with its fallback, the
+`codecs` grammar, union, floor and support. Two implementations check every case and
+must agree:
+
+- `wai_http_vectors verify .` (also `wai http vectors verify .`), in `wai-rs`, built
+  with the feature `http`;
+- `python3 http_verify.py .`, written from the extension text and SPEC §7.1, sharing no
+  code with `wai-rs`. It needs only the Python standard library, and reads
+  `../claim-conformance/_blake3.py` (BLAKE3 from its specification) and
+  `../registry/capabilities.json` (the published registry export).
+
+## Files
+
+| path | what |
+|---|---|
+| `objects/<cid>.wai` | each object, named by its content hash (§5.2) |
+| `objects/<cid>.wai.hp` | its head proof (§6.2) |
+| `objects/<cid>.wai.etag` | its `ETag` value, `"<cid>"` (§5.3) |
+| `objects.json` | each object's id, cid, path, `n`, `h`, `codecs` element and what it covers |
+| `bad/O6.wai` | O5 with one byte after it: not one envelope (§5.1) |
+| `cases/*.hp` | head proofs that are wrong in one way each |
+| `cases.json` | one case per line: `{name, op, input, expect}` |
+| `src/` | the frozen sources, with their SHA-256 in `src/SOURCES.json` |
+| `blake3_vectors.json` | a subset of the published BLAKE3 test vectors (CC0), which `http_verify.py` checks itself against first |
+| `http_verify.py` | the independent verifier |
+| `falsify/*.patch` | defects that `wai_http_vectors verify` must catch (below) |
+
+## Objects
+
+| id | object | covers |
+|---|---|---|
+| O1 | `WAI1`, the pinned `wai.neural.int_mlicpp` vector of `wai-rs/tests/vectors/int_mlicpp/` | a `WAI1` head; a proof that covers the whole object |
+| O2 | `WAI2` image: that pinned rendition, AVIF, JPEG XL and PNG of the one picture it decodes to | pins: held, not held |
+| O3 | `WAI2` video: AV1 at two rates, HDR10+ metadata bound to the higher by `companion_of_id` | range plans; a companion; tampering |
+| O4 | `WAI2` whose first selectable entry states no `sha256` | `component_digest_absent`: the whole object, the same pick |
+| O5 | a small `WAI1` | fetched whole (§5.4) |
+| O6 | O5 with a trailing byte (`bad/`) | `object_length_mismatch` |
+| O7 | `WAI2` whose first entry states a wrong `sha256` | the skip on both paths |
+| O8 | `WAI2`: an AVC base, an LCEVC enhancement bound to it, an AV1 alternative | classes; the refinement deadline (§10) |
+| O9a–O9c | three segments carrying {AV1, integer learned video}, {AV1}, {AV1} | union and floor (§4.2) |
+| OD | Appendix D's envelope | Appendix D's numbers, with `h` and without |
+| OH | a `WAI2` whose head spans several chunks | covered subtrees past the first chunk |
+| O10, O10L1, O10L2 | the staged-delivery FLAC base of `../staged-conformance/cases/audio_flac_rate_ladder/` and its two layers | layer objects (§10.4): never dispatched, fetched whole at refinement class, described after `+` through `refines.base` |
+| OS, ON, OW | an AVC base with an LCEVC enhancement nearly four times its size; the enhancement's digest right, absent, wrong | a refinement never moves its base (§7, §10.3); on a clock (`timed_*`), the base ready before its refinement, the deadline from the response that verified it, and a refinement's whole-object `200` that never reaches the base (§10.1, §10.2) |
+| OT | two renditions the first request holds whole | bytes changed in the first response are not reused |
+| OF | a `WAI1` naming a record beside a payload fallback | the union lists what SPEC §4 dispatches |
+| OE1, OE2s, OE2t | an encrypted `WAI1`; `WAI2`s whose `security` is a string, `true` | SPEC §6.4 on both containers |
+| OR | a refinement component whose `refines` is malformed | it refines nothing |
+| OPf, OPe, OPw | a `WAI1` naming `wai.text.zstd` whose `refines` is `false`, `{}`, and well formed | a payload carrying `refines` is an ordinary object: dispatched, described by its capability, `not_a_layer` when listed as a layer (§10.4) |
+| ORN | an AV1 base most of the object and a refinement component stating no `sha256` | the refinement dropped (`component_digest_absent`) on the whole path and the range path alike |
+| `bad/OK.wai`, `bad/OKN.wai` | a string key id; a numeric `kind` | the manifest's member types |
+
+The HDR10+ block, the AVC bases and the LCEVC enhancements are synthetic: they carry
+the right start codes and decode to nothing, which transport does not need. OD's and
+OT's payloads are byte patterns, as are OE2s', OE2t's, OR's and ORN's. Every other payload is real: the integer renditions are
+the committed vectors; the images and the AV1 streams are in `src/`, encoded once
+outside this repository, and the AV1 streams were checked to decode.
+
+## Operations
+
+| op | input | expect |
+|---|---|---|
+| `parse_head` | an object (or `file`), optionally a `prefix` length, an `envelope_len` and a `patch_object` | `need`, or the head's version, lengths, `covered_len` and component ranges, or `error` |
+| `head_proof` | an object, optionally a `proof` file and a `patch_object` | `covered_len`, `n_cv`, `envelope_len`, or `error` |
+| `plan` | an object, the `wanted` entries with their classes, the `held` ranges, a `threshold_permille` | `requests` with their classes, or `whole_rest` and why |
+| `response` | the request, status, `Content-Range`, `Content-Encoding`, body length and object length | `ok` with the bytes held, or `error` |
+| `select` | an object and a sink: `advertises`, `held` (parameter-set files), `order` | `pick` and `skipped`, or `inert` |
+| `fetch` | an object, a `fragment`, a sink (with `applies`, `declared` and `layer_base`), a `tamper` | the pick, how it was verified, why the whole object if it was, body bytes, requests, companions, refinements, abandoned refinements, skips and the component's SHA-256, or `error` |
+| `fetch_timed` | an object, a sink, a `deadline_ms`, and a `script` of steps each at a time on the caller's clock: `base` (answer every base-class request, and those that follow), `base_once` (those outstanding now), `refinement` (every outstanding refinement request, by its range or by a `200` carrying the whole object with the byte at `flip` changed), `tick` | the step after which the base was first ready and its time, the base then and at the end, what each tick abandoned, and the outcome (null while there is none) |
+| `same_pick` | as `fetch` | the pick (or `inert`), which `select` and `fetch` must both give (§7.2) |
+| `codecs` | a `codecs` value | each element rendered, `null` for a classical one, or `error` |
+| `union_floor` | a sequence of objects | the union and the floor, or `error` |
+| `supports` | a floor, the sink's containers and capabilities | `supports` |
+| `layer_tag` | a `#WAI-LAYER` line | `n` and `uri`, or `error` |
+
+An input names an object by id, a `file`, or an `envelope_hex` written inline;
+`union_floor` also takes `envelopes_hex`. A sink's `declared` is the union it was given
+(§4.2), parsed before anything is fetched; `layer_base` (an object id) or
+`layer_base_hex` is the base it holds, against which a layer is declared only in the
+`alt` of that base's capability. A `declared` that does not parse, or a base that is
+not an object, refuses the case with its code.
+
+`fetch` runs the reference client's policy: a first request of 16369 bytes unless `h`
+is given, never past `n`; the rest of the object when the planned base-class ranges
+reach 900 ‰ of the bytes after `covered_len` (`threshold_permille` changes it); and,
+with `listed_as_layer`, one whole request at refinement class. The origin answers
+single ranges with `206`. A `tamper` changes what it serves: `patch_object` its bytes;
+`kind` `gzip` (every object response labelled gzip), `no_refinement` (no
+refinement-class request answered) or `no_proof` (the head proof's request not
+answered); `first_range_flip` one byte of the first range response only; `refinement`
+every refinement-class range response one way (`gzip`, `bad_range`, `416`,
+`complete_length`, `plus_sign`, `short_200`). Body bytes count the head proof; a
+delivery states its role (`base` or `layer`), the refinements abandoned and those
+dropped with why.
+
+## Regenerating
+
+    cargo run --no-default-features --features http --bin wai_http_vectors -- gen ../http-conformance
+
+from `wai/wai-rs`. Every file is a function of `src/`, the two committed vectors the
+objects carry, and the code, so a second run writes the same bytes; `verify`
+regenerates in memory and requires them. The generator also holds each negative case
+to the reason it exists for, and OD to Appendix D's cid, length and proof size.
+
+## Falsification
+
+Each patch in `falsify/` names the function it breaks and, on its first line, the
+cases that must fail. The `falsify` job of `.github/workflows/wai-http.yml` applies
+each to a fresh worktree, requires the build to succeed, and requires
+`wai_http_vectors verify` to exit non-zero naming those cases. `http_verify.py
+--mutate NAME` does the same on the Python side (`left-half`, `no-root`,
+`counter-zero` fail the proof cases; `floor-as-codecs` fails `union_O9`; `blake3-iv`
+fails the self-test; `base-at-done`, `tick-noop` and `refinement-unclipped` fail the
+`timed_*` cases), and the job checks a differential: `wai_http_vectors diff`
+writes random envelopes' covered prefixes and proofs, `http_verify.py diff` verifies
+every one, and, with one chaining-value byte changed in ten of them, refuses exactly
+those ten.
+
+## Outside the corpus
+
+    wai_http_vectors fuzz . --seed S --count N --out cases.json
+    python3 http_verify.py cases cases.json .
+
+`fuzz` writes seeded cases, in the corpus's format and with wai-rs's outcomes, for the
+inputs where two readers most easily part, in families:
+
+- `fuzz_response`: `Content-Range` values, half of them the request's own range with
+  one number given a sign, a separator, a space or another script's digits;
+- `fuzz_codecs`: `codecs` values (the `wai` prefix in any case, duplicates, empty
+  elements, non-ASCII); `fuzz_layer_tag`: `#WAI-LAYER` lines;
+- `fuzz_wai1_head`, `fuzz_wai1_fetch`, `fuzz_wai2_head`, `fuzz_wai2_select`,
+  `fuzz_wai2_fetch`, `fuzz_union`: `WAI1` and `WAI2` manifests (member types,
+  `security` in every shape, `refines` well and badly formed, members named twice,
+  refinement components with a right, a wrong and no `sha256`);
+- `fuzz_wai1_refines_fetch`, `fuzz_wai1_refines_union`: well-formed `WAI1`s whose
+  `refines` varies over payload and refinement-only capabilities, fetched as objects
+  and as listed layers;
+- `fuzz_layer_union`, `fuzz_layer_declared`: a base with a layer that names it or does
+  not, and the layer against a declared union and a base — its own base's `alt`, that
+  `alt` without it, another `alt` with it, the other container, no base, another base;
+- `fuzz_component_layer_union`, `fuzz_component_layer_declared`: a layer whose base is
+  a `WAI2` component, named by the hash of the component's exploded envelope;
+- `fuzz_large_fetch`: `WAI2` objects past the first request, with a base, a refinement
+  or companion and an alternative each stating a right, a wrong or no digest, fetched
+  through an origin tampered one way, at thresholds either side of the plan;
+  `fuzz_whole_refine`: the whole path, its base's digest absent or the threshold low,
+  with a refinement whose digest is right, wrong or absent.
+
+A refusal is an outcome like any other: `http_verify.py cases` must give the same
+code. A case wai-rs gives no outcome for stops the run, and `fuzz` prints, per family,
+the cases it generated and how many were refused, so a family that only ever refuses
+(or never does) shows. `wai-conformance.yml` runs it at two seeds.
diff --git a/wai/http-conformance/bad/O6.wai b/wai/http-conformance/bad/O6.wai
new file mode 100644
index 000000000..c4ef2dd28
Binary files /dev/null and b/wai/http-conformance/bad/O6.wai differ
diff --git a/wai/http-conformance/bad/OK.wai b/wai/http-conformance/bad/OK.wai
new file mode 100644
index 000000000..8b93e930d
Binary files /dev/null and b/wai/http-conformance/bad/OK.wai differ
diff --git a/wai/http-conformance/bad/OKN.wai b/wai/http-conformance/bad/OKN.wai
new file mode 100644
index 000000000..02915f561
Binary files /dev/null and b/wai/http-conformance/bad/OKN.wai differ
diff --git a/wai/http-conformance/blake3_vectors.json b/wai/http-conformance/blake3_vectors.json
new file mode 100644
index 000000000..529093df2
--- /dev/null
+++ b/wai/http-conformance/blake3_vectors.json
@@ -0,0 +1,73 @@
+{
+ "note": "A subset of the published BLAKE3 test vectors (CC0): hash mode, the first 32 bytes of each output. Each input is input_len bytes, byte i being i mod 251.",
+ "cases": [
+  {
+   "input_len": 0,
+   "hash": "af1349b9f5f9a1a6a0404dea36dcc9499bcb25c9adc112b7cc9a93cae41f3262"
+  },
+  {
+   "input_len": 1,
+   "hash": "2d3adedff11b61f14c886e35afa036736dcd87a74d27b5c1510225d0f592e213"
+  },
+  {
+   "input_len": 63,
+   "hash": "e9bc37a594daad83be9470df7f7b3798297c3d834ce80ba85d6e207627b7db7b"
+  },
+  {
+   "input_len": 64,
+   "hash": "4eed7141ea4a5cd4b788606bd23f46e212af9cacebacdc7d1f4c6dc7f2511b98"
+  },
+  {
+   "input_len": 65,
+   "hash": "de1e5fa0be70df6d2be8fffd0e99ceaa8eb6e8c93a63f2d8d1c30ecb6b263dee"
+  },
+  {
+   "input_len": 1023,
+   "hash": "10108970eeda3eb932baac1428c7a2163b0e924c9a9e25b35bba72b28f70bd11"
+  },
+  {
+   "input_len": 1024,
+   "hash": "42214739f095a406f3fc83deb889744ac00df831c10daa55189b5d121c855af7"
+  },
+  {
+   "input_len": 1025,
+   "hash": "d00278ae47eb27b34faecf67b4fe263f82d5412916c1ffd97c8cb7fb814b8444"
+  },
+  {
+   "input_len": 2048,
+   "hash": "e776b6028c7cd22a4d0ba182a8bf62205d2ef576467e838ed6f2529b85fba24a"
+  },
+  {
+   "input_len": 2049,
+   "hash": "5f4d72f40d7a5f82b15ca2b2e44b1de3c2ef86c426c95c1af0b6879522563030"
+  },
+  {
+   "input_len": 3072,
+   "hash": "b98cb0ff3623be03326b373de6b9095218513e64f1ee2edd2525c7ad1e5cffd2"
+  },
+  {
+   "input_len": 3073,
+   "hash": "7124b49501012f81cc7f11ca069ec9226cecb8a2c850cfe644e327d22d3e1cd3"
+  },
+  {
+   "input_len": 4096,
+   "hash": "015094013f57a5277b59d8475c0501042c0b642e531b0a1c8f58d2163229e969"
+  },
+  {
+   "input_len": 4097,
+   "hash": "9b4052b38f1c5fc8b1f9ff7ac7b27cd242487b3d890d15c96a1c25b8aa0fb995"
+  },
+  {
+   "input_len": 8193,
+   "hash": "bab6c09cb8ce8cf459261398d2e7aef35700bf488116ceb94a36d0f5f1b7bc3b"
+  },
+  {
+   "input_len": 16384,
+   "hash": "f875d6646de28985646f34ee13be9a576fd515f76b5b0a26bb324735041ddde4"
+  },
+  {
+   "input_len": 31744,
+   "hash": "62b6960e1a44bcc1eb1a611a8d6235b6b4b78f32e7abc4fb4c6cdcce94895c47"
+  }
+ ]
+}
diff --git a/wai/http-conformance/cases.json b/wai/http-conformance/cases.json
new file mode 100644
index 000000000..f9b0d6ca5
--- /dev/null
+++ b/wai/http-conformance/cases.json
@@ -0,0 +1,322 @@
+[
+{"name":"parse_head_O1","op":"parse_head","input":{"object":"O1"},"expect":{"version":"WAI1","head_len":351,"envelope_len":859,"covered_len":859,"components":[[351,508]]}},
+{"name":"parse_head_O3","op":"parse_head","input":{"object":"O3"},"expect":{"version":"WAI2","head_len":607,"envelope_len":98613,"covered_len":1009,"components":[[607,20766],[21373,77040],[98413,200]]}},
+{"name":"parse_head_O5","op":"parse_head","input":{"object":"O5"},"expect":{"version":"WAI1","head_len":157,"envelope_len":251,"covered_len":251,"components":[[157,94]]}},
+{"name":"parse_head_O9b","op":"parse_head","input":{"object":"O9b"},"expect":{"version":"WAI1","head_len":170,"envelope_len":18004,"covered_len":1009,"components":[[170,17834]]}},
+{"name":"parse_head_OD","op":"parse_head","input":{"object":"OD"},"expect":{"version":"WAI2","head_len":594,"envelope_len":53794,"covered_len":1009,"components":[[594,3000],[3594,50000],[53594,200]]}},
+{"name":"parse_head_OH","op":"parse_head","input":{"object":"OH"},"expect":{"version":"WAI2","head_len":5308,"envelope_len":23519,"covered_len":6129,"components":[[5308,18211]]}},
+{"name":"parse_head_need_OD_300","op":"parse_head","input":{"object":"OD","prefix":300},"expect":{"need":570}},
+{"name":"parse_head_need_OD_580","op":"parse_head","input":{"object":"OD","prefix":580},"expect":{"need":594}},
+{"name":"parse_head_need_O1_6","op":"parse_head","input":{"object":"O1","prefix":6},"expect":{"need":8}},
+{"name":"object_length_trailing","op":"parse_head","input":{"file":"bad/O6.wai"},"expect":{"error":"object_length_mismatch"}},
+{"name":"object_length_short","op":"parse_head","input":{"object":"O3","envelope_len":98614},"expect":{"error":"object_length_mismatch"}},
+{"name":"head_malformed_magic","op":"parse_head","input":{"object":"O5","patch_object":[[3,"33"]]},"expect":{"error":"head_malformed"}},
+{"name":"head_malformed_offset","op":"parse_head","input":{"object":"OD","patch_object":[[574,"01"]]},"expect":{"error":"head_malformed"}},
+{"name":"head_proof_ok_O1","op":"head_proof","input":{"object":"O1"},"expect":{"covered_len":859,"n_cv":0,"envelope_len":859}},
+{"name":"head_proof_ok_O10","op":"head_proof","input":{"object":"O10"},"expect":{"covered_len":1009,"n_cv":1,"envelope_len":1825}},
+{"name":"head_proof_ok_O10L1","op":"head_proof","input":{"object":"O10L1"},"expect":{"covered_len":1009,"n_cv":4,"envelope_len":12711}},
+{"name":"head_proof_ok_O10L2","op":"head_proof","input":{"object":"O10L2"},"expect":{"covered_len":1009,"n_cv":5,"envelope_len":18367}},
+{"name":"head_proof_ok_O2","op":"head_proof","input":{"object":"O2"},"expect":{"covered_len":1009,"n_cv":5,"envelope_len":20250}},
+{"name":"head_proof_ok_O3","op":"head_proof","input":{"object":"O3"},"expect":{"covered_len":1009,"n_cv":7,"envelope_len":98613}},
+{"name":"head_proof_ok_O4","op":"head_proof","input":{"object":"O4"},"expect":{"covered_len":1009,"n_cv":6,"envelope_len":39361}},
+{"name":"head_proof_ok_O5","op":"head_proof","input":{"object":"O5"},"expect":{"covered_len":251,"n_cv":0,"envelope_len":251}},
+{"name":"head_proof_ok_O7","op":"head_proof","input":{"object":"O7"},"expect":{"covered_len":1009,"n_cv":6,"envelope_len":39437}},
+{"name":"head_proof_ok_O8","op":"head_proof","input":{"object":"O8"},"expect":{"covered_len":1009,"n_cv":6,"envelope_len":46433}},
+{"name":"head_proof_ok_O9a","op":"head_proof","input":{"object":"O9a"},"expect":{"covered_len":1009,"n_cv":5,"envelope_len":21034}},
+{"name":"head_proof_ok_O9b","op":"head_proof","input":{"object":"O9b"},"expect":{"covered_len":1009,"n_cv":5,"envelope_len":18004}},
+{"name":"head_proof_ok_O9c","op":"head_proof","input":{"object":"O9c"},"expect":{"covered_len":1009,"n_cv":5,"envelope_len":18381}},
+{"name":"head_proof_ok_OD","op":"head_proof","input":{"object":"OD"},"expect":{"covered_len":1009,"n_cv":6,"envelope_len":53794}},
+{"name":"head_proof_ok_OE1","op":"head_proof","input":{"object":"OE1"},"expect":{"covered_len":299,"n_cv":0,"envelope_len":299}},
+{"name":"head_proof_ok_OE2s","op":"head_proof","input":{"object":"OE2s"},"expect":{"covered_len":1009,"n_cv":3,"envelope_len":5251}},
+{"name":"head_proof_ok_OE2t","op":"head_proof","input":{"object":"OE2t"},"expect":{"covered_len":1009,"n_cv":3,"envelope_len":5242}},
+{"name":"head_proof_ok_OF","op":"head_proof","input":{"object":"OF"},"expect":{"covered_len":283,"n_cv":0,"envelope_len":283}},
+{"name":"head_proof_ok_OH","op":"head_proof","input":{"object":"OH"},"expect":{"covered_len":6129,"n_cv":3,"envelope_len":23519}},
+{"name":"head_proof_ok_ON","op":"head_proof","input":{"object":"ON"},"expect":{"covered_len":1009,"n_cv":6,"envelope_len":38384}},
+{"name":"head_proof_ok_OPe","op":"head_proof","input":{"object":"OPe"},"expect":{"covered_len":264,"n_cv":0,"envelope_len":264}},
+{"name":"head_proof_ok_OPf","op":"head_proof","input":{"object":"OPf"},"expect":{"covered_len":267,"n_cv":0,"envelope_len":267}},
+{"name":"head_proof_ok_OPw","op":"head_proof","input":{"object":"OPw"},"expect":{"covered_len":421,"n_cv":0,"envelope_len":421}},
+{"name":"head_proof_ok_OR","op":"head_proof","input":{"object":"OR"},"expect":{"covered_len":1009,"n_cv":4,"envelope_len":9434}},
+{"name":"head_proof_ok_ORN","op":"head_proof","input":{"object":"ORN"},"expect":{"covered_len":1009,"n_cv":5,"envelope_len":32659}},
+{"name":"head_proof_ok_OS","op":"head_proof","input":{"object":"OS"},"expect":{"covered_len":1009,"n_cv":6,"envelope_len":38460}},
+{"name":"head_proof_ok_OT","op":"head_proof","input":{"object":"OT"},"expect":{"covered_len":1009,"n_cv":4,"envelope_len":12368}},
+{"name":"head_proof_ok_OW","op":"head_proof","input":{"object":"OW"},"expect":{"covered_len":1009,"n_cv":6,"envelope_len":38460}},
+{"name":"head_proof_flip_prefix_O3","op":"head_proof","input":{"object":"O3","patch_object":[[1008,"d0"]]},"expect":{"error":"head_proof_mismatch"}},
+{"name":"head_proof_flip_cv_O3","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_flip_cv_O3.hp"},"expect":{"error":"head_proof_mismatch"}},
+{"name":"head_proof_drop_cv_O3","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_drop_cv_O3.hp"},"expect":{"error":"head_proof_mismatch"}},
+{"name":"head_proof_extra_cv_O3","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_extra_cv_O3.hp"},"expect":{"error":"head_proof_mismatch"}},
+{"name":"head_proof_unaligned_O3","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_unaligned_O3.hp"},"expect":{"error":"head_proof_malformed"}},
+{"name":"head_proof_envelope_len_O3","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_envelope_len_O3.hp"},"expect":{"error":"head_proof_malformed"}},
+{"name":"head_proof_magic","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_magic.hp"},"expect":{"error":"head_proof_malformed"}},
+{"name":"head_proof_other_object","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_of_O4.hp"},"expect":{"error":"head_proof_malformed"}},
+{"name":"head_proof_not_formula_OH","op":"head_proof","input":{"object":"OH","proof":"cases/head_proof_not_formula_OH.hp"},"expect":{"error":"head_proof_malformed"}},
+{"name":"plan_OD_1","op":"plan","input":{"object":"OD","wanted":[[0,"base"]],"held":[[0,1008]]},"expect":{"requests":[[1009,3593,"base"]],"dropped":[]}},
+{"name":"plan_OD_2","op":"plan","input":{"object":"OD","wanted":[[1,"base"],[2,"base"]],"held":[[0,1008]]},"expect":{"whole_rest":[1009,53793],"why":"range_threshold"}},
+{"name":"plan_classes_O8","op":"plan","input":{"object":"O8","wanted":[[0,"base"],[1,"refinement"]],"held":[[0,1008]]},"expect":{"requests":[[1009,8598,"base"],[8599,28598,"refinement"]],"dropped":[]}},
+{"name":"plan_one_class_O8","op":"plan","input":{"object":"O8","wanted":[[0,"base"],[1,"base"]],"held":[[0,1008]]},"expect":{"requests":[[1009,28598,"base"]],"dropped":[]}},
+{"name":"plan_no_digest_O4","op":"plan","input":{"object":"O4","wanted":[[0,"base"]],"held":[[0,1008]]},"expect":{"whole_rest":[1009,39360],"why":"component_digest_absent"}},
+{"name":"plan_O3_high","op":"plan","input":{"object":"O3","wanted":[[1,"base"],[2,"base"]],"held":[[0,1008]]},"expect":{"requests":[[21373,98612,"base"]],"dropped":[]}},
+{"name":"plan_held_O3","op":"plan","input":{"object":"O3","wanted":[[0,"base"]],"held":[[0,1008],[2000,2999]]},"expect":{"requests":[[1009,1999,"base"],[3000,21372,"base"]],"dropped":[]}},
+{"name":"response_ok","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3593/53794","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"ok":[1009,3593]}},
+{"name":"response_wrong_range","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3592/53794","content_encoding":null,"body_len":2584,"envelope_len":53794},"expect":{"error":"content_range_mismatch"}},
+{"name":"response_short_body","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3593/53794","content_encoding":null,"body_len":2000,"envelope_len":53794},"expect":{"error":"content_range_mismatch"}},
+{"name":"response_gzip","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3593/53794","content_encoding":"gzip","body_len":2585,"envelope_len":53794},"expect":{"error":"content_coding_present"}},
+{"name":"response_complete_length","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3593/53795","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"complete_length_mismatch"}},
+{"name":"response_complete_unknown","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3593/*","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"complete_length_mismatch"}},
+{"name":"response_identity","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3593/53794","content_encoding":"identity","body_len":2585,"envelope_len":53794},"expect":{"ok":[1009,3593]}},
+{"name":"response_304","op":"response","input":{"request":[1009,3593],"status":304,"body_len":0,"envelope_len":53794},"expect":{"error":"http_status_unexpected"}},
+{"name":"response_200_short","op":"response","input":{"request":[1009,3593],"status":200,"body_len":1000,"envelope_len":53794},"expect":{"error":"complete_length_mismatch"}},
+{"name":"response_200_whole","op":"response","input":{"request":[1009,3593],"status":200,"body_len":53794,"envelope_len":53794},"expect":{"ok":[0,53793]}},
+{"name":"response_past_end","op":"response","input":{"request":[0,16368],"status":206,"content_range":"bytes 0-899/900","body_len":900,"envelope_len":900},"expect":{"ok":[0,899]}},
+{"name":"response_206_unasked","op":"response","input":{"request":null,"status":206,"content_range":"bytes 0-9/900","body_len":10,"envelope_len":900},"expect":{"error":"http_status_unexpected"}},
+{"name":"select_O2_held","op":"select","input":{"object":"O2","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"]},"expect":{"pick":0,"skipped":[]}},
+{"name":"select_O2_not_held","op":"select","input":{"object":"O2","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"held":[]},"expect":{"pick":1,"skipped":[[0,"prior_not_held"]]}},
+{"name":"select_O2_png_only","op":"select","input":{"object":"O2","advertises":["wai.image.png"],"held":[]},"expect":{"pick":3,"skipped":[[0,"missing_capability"],[1,"missing_capability"],[2,"missing_capability"]]}},
+{"name":"select_O3","op":"select","input":{"object":"O3","advertises":["wai.video.av1"]},"expect":{"pick":0,"skipped":[]}},
+{"name":"select_O7","op":"select","input":{"object":"O7","advertises":["wai.video.av1"]},"expect":{"pick":1,"skipped":[[0,"component_digest_mismatch"]]}},
+{"name":"select_O3_nothing","op":"select","input":{"object":"O3","advertises":[]},"expect":{"inert":[[0,"missing_capability"],[1,"missing_capability"],[2,"not_selectable"]]}},
+{"name":"select_O9a_int_hyper","op":"select","input":{"object":"O9a","advertises":["wai.video.int_hyper"],"held":[]},"expect":{"inert":[[0,"missing_capability"],[1,"prior_not_held"]]}},
+{"name":"fetch_O3_low","op":"fetch","input":{"object":"O3","fragment":"#n=98613&h=1009","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":21650,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"24003cee2a7bf7fa45caa412ab4ea9f5f08b6bf44842a73d5a11c2bcf36df464"}},
+{"name":"fetch_O3_low_default_head","op":"fetch","input":{"object":"O3","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":21650,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"24003cee2a7bf7fa45caa412ab4ea9f5f08b6bf44842a73d5a11c2bcf36df464"}},
+{"name":"fetch_O3_high","op":"fetch","input":{"object":"O3","fragment":"#n=98613&h=1009","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"],"order":[1,0,2]},"expect":{"role":"base","pick":1,"verified_by":"head-proof","why_whole":null,"body_bytes":78526,"requests":3,"companions":[2],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"68a51be787c439226eb7bb1cf434e913fc1f0e221870da87f70615d667a7ab12"}},
+{"name":"fetch_OD_1","op":"fetch","input":{"object":"OD","fragment":"#n=53794&h=1009","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":3839,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"f541874101876255b4baf3a739778d04cb9cba25ffa38b30bc1fb8b0701f2a45"}},
+{"name":"fetch_OD_2","op":"fetch","input":{"object":"OD","fragment":"#n=53794&h=1009","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"],"order":[1,0,2]},"expect":{"role":"base","pick":1,"verified_by":"whole-object","why_whole":"range_threshold","body_bytes":54039,"requests":3,"companions":[2],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"b76bf31be170d9df8eafbd020941b5fd4b7ab017af6a1e5c1c03e909aa8f9fb7"}},
+{"name":"fetch_OD_1_no_h","op":"fetch","input":{"object":"OD","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":16614,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"f541874101876255b4baf3a739778d04cb9cba25ffa38b30bc1fb8b0701f2a45"}},
+{"name":"fetch_OD_2_no_h","op":"fetch","input":{"object":"OD","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"],"order":[1,0,2]},"expect":{"role":"base","pick":1,"verified_by":"head-proof","why_whole":null,"body_bytes":54039,"requests":3,"companions":[2],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"b76bf31be170d9df8eafbd020941b5fd4b7ab017af6a1e5c1c03e909aa8f9fb7"}},
+{"name":"fetch_OD_2_no_threshold","op":"fetch","input":{"object":"OD","fragment":"#n=53794&h=1009","advertises":["wai.video.av1"],"applies":["wai.meta.hdr10plus"],"order":[1,0,2],"threshold_permille":1001},"expect":{"role":"base","pick":1,"verified_by":"head-proof","why_whole":null,"body_bytes":51454,"requests":3,"companions":[2],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"b76bf31be170d9df8eafbd020941b5fd4b7ab017af6a1e5c1c03e909aa8f9fb7"}},
+{"name":"fetch_O4","op":"fetch","input":{"object":"O4","fragment":"#n=39361&h=1009","advertises":["wai.video.av1"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"component_digest_absent","body_bytes":39606,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"24003cee2a7bf7fa45caa412ab4ea9f5f08b6bf44842a73d5a11c2bcf36df464"}},
+{"name":"fetch_O7","op":"fetch","input":{"object":"O7","fragment":"#n=39437&h=1009","advertises":["wai.video.av1"]},"expect":{"role":"base","pick":1,"verified_by":"whole-object","why_whole":"component_digest_mismatch","body_bytes":59817,"requests":4,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[[0,"component_digest_mismatch"]],"component_sha256":"0c03a22bebcdb29e26fc1e6dbf040bd86751e8e0be66a2b2ba6709f786a260e8"}},
+{"name":"component_tamper_O3","op":"fetch","input":{"object":"O3","fragment":"#n=98613&h=1009","advertises":["wai.video.av1"],"tamper":{"patch_object":[[1509,"32"]]}},"expect":{"error":"object_digest_mismatch"}},
+{"name":"head_tamper_O3","op":"fetch","input":{"object":"O3","advertises":["wai.video.av1"],"tamper":{"patch_object":[[40,"75"]]}},"expect":{"error":"head_proof_mismatch"}},
+{"name":"fetch_gzip_O3","op":"fetch","input":{"object":"O3","advertises":["wai.video.av1"],"tamper":{"kind":"gzip"}},"expect":{"error":"content_coding_present"}},
+{"name":"fetch_O8_deadline","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"tamper":{"kind":"no_refinement"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8844,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O8_full","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":28844,"requests":4,"companions":[1],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O8_no_enhancement","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":[]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8844,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O2_held","op":"fetch","input":{"object":"O2","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":16582,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"5b2bf2dbd36a683d4a62292d1a179e695c511c4971be6859cec41cd980e4f971"}},
+{"name":"fetch_O2_not_held","op":"fetch","input":{"object":"O2","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"held":[]},"expect":{"role":"base","pick":1,"verified_by":"head-proof","why_whole":null,"body_bytes":16582,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[[0,"prior_not_held"]],"component_sha256":"c56f9ab9a3b1df0bd650c3177bd85427f4a4be8fde82547219bcea4ec254162c"}},
+{"name":"fetch_O1","op":"fetch","input":{"object":"O1","advertises":["wai.neural.int_mlicpp"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":912,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"5b2bf2dbd36a683d4a62292d1a179e695c511c4971be6859cec41cd980e4f971"}},
+{"name":"fetch_O1_not_held","op":"fetch","input":{"object":"O1","advertises":["wai.neural.int_mlicpp"],"held":[]},"expect":{"error":"inert","skipped":[[0,"prior_not_held"]]}},
+{"name":"fetch_O5_small","op":"fetch","input":{"object":"O5","fragment":"#n=251","advertises":["wai.text.zstd"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"below_one_chunk","body_bytes":251,"requests":1,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_O9b_wai1","op":"fetch","input":{"object":"O9b","fragment":"#n=18004&h=1009","advertises":["wai.video.av1"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":18217,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"edd595431a8992d78fd6f691c6b066efa102ac8c1ffb822505639e0d640174a4"}},
+{"name":"fetch_OH","op":"fetch","input":{"object":"OH","advertises":["wai.video.av1"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":23668,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"dbf116e87034120670d459dbc4812644799b1dc3ae29cc070659103948ca59bc"}},
+{"name":"fetch_OH_short_head","op":"fetch","input":{"object":"OH","fragment":"#n=23519&h=1009","advertises":["wai.video.av1"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"range_threshold","body_bytes":23668,"requests":4,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"dbf116e87034120670d459dbc4812644799b1dc3ae29cc070659103948ca59bc"}},
+{"name":"fetch_O9a_undeclared","op":"fetch","input":{"object":"O9a","advertises":["wai.video.av1"],"declared":"wai2.video.av1"},"expect":{"error":"codecs_undeclared"}},
+{"name":"fetch_O9a_declared","op":"fetch","input":{"object":"O9a","advertises":["wai.video.av1"],"declared":"wai2.video.av1|video.int_hyper"},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":19099,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"0c03a22bebcdb29e26fc1e6dbf040bd86751e8e0be66a2b2ba6709f786a260e8"}},
+{"name":"same_pick_O2_video_0","op":"same_pick","input":{"object":"O2","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2,3],"fragment":"#n=20250&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O2_video_1","op":"same_pick","input":{"object":"O2","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[3,2,1,0],"fragment":"#n=20250&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O2_video_2","op":"same_pick","input":{"object":"O2","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,3,0],"fragment":"#n=20250&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O2_image_0","op":"same_pick","input":{"object":"O2","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2,3],"fragment":"#n=20250&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_O2_image_1","op":"same_pick","input":{"object":"O2","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[3,2,1,0],"fragment":"#n=20250&h=1009"},"expect":{"pick":3}},
+{"name":"same_pick_O2_image_2","op":"same_pick","input":{"object":"O2","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,3,0],"fragment":"#n=20250&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O2_other_0","op":"same_pick","input":{"object":"O2","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2,3],"fragment":"#n=20250&h=1009"},"expect":{"pick":3}},
+{"name":"same_pick_O2_other_1","op":"same_pick","input":{"object":"O2","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[3,2,1,0],"fragment":"#n=20250&h=1009"},"expect":{"pick":3}},
+{"name":"same_pick_O2_other_2","op":"same_pick","input":{"object":"O2","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,3,0],"fragment":"#n=20250&h=1009"},"expect":{"pick":3}},
+{"name":"same_pick_O2_none_0","op":"same_pick","input":{"object":"O2","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2,3],"fragment":"#n=20250&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O2_none_1","op":"same_pick","input":{"object":"O2","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[3,2,1,0],"fragment":"#n=20250&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O2_none_2","op":"same_pick","input":{"object":"O2","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,3,0],"fragment":"#n=20250&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_video_0","op":"same_pick","input":{"object":"O3","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=98613&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_O3_video_1","op":"same_pick","input":{"object":"O3","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=98613&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O3_video_2","op":"same_pick","input":{"object":"O3","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=98613&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O3_image_0","op":"same_pick","input":{"object":"O3","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_image_1","op":"same_pick","input":{"object":"O3","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_image_2","op":"same_pick","input":{"object":"O3","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_other_0","op":"same_pick","input":{"object":"O3","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_other_1","op":"same_pick","input":{"object":"O3","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_other_2","op":"same_pick","input":{"object":"O3","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_none_0","op":"same_pick","input":{"object":"O3","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_none_1","op":"same_pick","input":{"object":"O3","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O3_none_2","op":"same_pick","input":{"object":"O3","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=98613&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_video_0","op":"same_pick","input":{"object":"O4","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39361&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_O4_video_1","op":"same_pick","input":{"object":"O4","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O4_video_2","op":"same_pick","input":{"object":"O4","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O4_image_0","op":"same_pick","input":{"object":"O4","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_image_1","op":"same_pick","input":{"object":"O4","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_image_2","op":"same_pick","input":{"object":"O4","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_other_0","op":"same_pick","input":{"object":"O4","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_other_1","op":"same_pick","input":{"object":"O4","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_other_2","op":"same_pick","input":{"object":"O4","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_none_0","op":"same_pick","input":{"object":"O4","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_none_1","op":"same_pick","input":{"object":"O4","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O4_none_2","op":"same_pick","input":{"object":"O4","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39361&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_video_0","op":"same_pick","input":{"object":"O7","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39437&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O7_video_1","op":"same_pick","input":{"object":"O7","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O7_video_2","op":"same_pick","input":{"object":"O7","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_O7_image_0","op":"same_pick","input":{"object":"O7","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_image_1","op":"same_pick","input":{"object":"O7","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_image_2","op":"same_pick","input":{"object":"O7","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_other_0","op":"same_pick","input":{"object":"O7","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_other_1","op":"same_pick","input":{"object":"O7","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_other_2","op":"same_pick","input":{"object":"O7","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_none_0","op":"same_pick","input":{"object":"O7","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_none_1","op":"same_pick","input":{"object":"O7","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O7_none_2","op":"same_pick","input":{"object":"O7","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=39437&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_video_0","op":"same_pick","input":{"object":"O8","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=46433&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_O8_video_1","op":"same_pick","input":{"object":"O8","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=46433&h=1009"},"expect":{"pick":2}},
+{"name":"same_pick_O8_video_2","op":"same_pick","input":{"object":"O8","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=46433&h=1009"},"expect":{"pick":2}},
+{"name":"same_pick_O8_image_0","op":"same_pick","input":{"object":"O8","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_image_1","op":"same_pick","input":{"object":"O8","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_image_2","op":"same_pick","input":{"object":"O8","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_other_0","op":"same_pick","input":{"object":"O8","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_other_1","op":"same_pick","input":{"object":"O8","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_other_2","op":"same_pick","input":{"object":"O8","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_none_0","op":"same_pick","input":{"object":"O8","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_none_1","op":"same_pick","input":{"object":"O8","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O8_none_2","op":"same_pick","input":{"object":"O8","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=46433&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_video_0","op":"same_pick","input":{"object":"O9a","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=21034&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_O9a_video_1","op":"same_pick","input":{"object":"O9a","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_O9a_video_2","op":"same_pick","input":{"object":"O9a","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_O9a_image_0","op":"same_pick","input":{"object":"O9a","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_image_1","op":"same_pick","input":{"object":"O9a","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_image_2","op":"same_pick","input":{"object":"O9a","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_other_0","op":"same_pick","input":{"object":"O9a","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_other_1","op":"same_pick","input":{"object":"O9a","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_other_2","op":"same_pick","input":{"object":"O9a","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_none_0","op":"same_pick","input":{"object":"O9a","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_none_1","op":"same_pick","input":{"object":"O9a","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_O9a_none_2","op":"same_pick","input":{"object":"O9a","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,0],"fragment":"#n=21034&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_video_0","op":"same_pick","input":{"object":"OD","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=53794&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_OD_video_1","op":"same_pick","input":{"object":"OD","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=53794&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_OD_video_2","op":"same_pick","input":{"object":"OD","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=53794&h=1009"},"expect":{"pick":1}},
+{"name":"same_pick_OD_image_0","op":"same_pick","input":{"object":"OD","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_image_1","op":"same_pick","input":{"object":"OD","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_image_2","op":"same_pick","input":{"object":"OD","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_other_0","op":"same_pick","input":{"object":"OD","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_other_1","op":"same_pick","input":{"object":"OD","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_other_2","op":"same_pick","input":{"object":"OD","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_none_0","op":"same_pick","input":{"object":"OD","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0,1,2],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_none_1","op":"same_pick","input":{"object":"OD","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[2,1,0],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OD_none_2","op":"same_pick","input":{"object":"OD","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[1,2,0],"fragment":"#n=53794&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_video_0","op":"same_pick","input":{"object":"OH","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_OH_video_1","op":"same_pick","input":{"object":"OH","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_OH_video_2","op":"same_pick","input":{"object":"OH","advertises":["wai.video.av1","wai.video.avc"],"applies":["wai.meta.hdr10plus","wai.video.lcevc"],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"pick":0}},
+{"name":"same_pick_OH_image_0","op":"same_pick","input":{"object":"OH","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_image_1","op":"same_pick","input":{"object":"OH","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_image_2","op":"same_pick","input":{"object":"OH","advertises":["wai.neural.int_mlicpp","wai.image.avif","wai.image.jxl","wai.image.png"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_other_0","op":"same_pick","input":{"object":"OH","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_other_1","op":"same_pick","input":{"object":"OH","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_other_2","op":"same_pick","input":{"object":"OH","advertises":["wai.video.int_hyper","wai.image.png","wai.text.zstd"],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_none_0","op":"same_pick","input":{"object":"OH","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_none_1","op":"same_pick","input":{"object":"OH","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"same_pick_OH_none_2","op":"same_pick","input":{"object":"OH","advertises":[],"applies":[],"held":["../wai-rs/tests/vectors/int_mlicpp/model.wmb"],"order":[0],"fragment":"#n=23519&h=1009"},"expect":{"inert":true}},
+{"name":"codecs_ok_0","op":"codecs","input":{"value":"wai2.video.av1+meta.hdr10plus|video.int_hyper"},"expect":{"elements":["wai2.video.av1+meta.hdr10plus|video.int_hyper"]}},
+{"name":"codecs_ok_1","op":"codecs","input":{"value":"wai1.video.av1"},"expect":{"elements":["wai1.video.av1"]}},
+{"name":"codecs_ok_2","op":"codecs","input":{"value":"mp4a.40.2,wai1.video.av1, avc1.42E01E"},"expect":{"elements":[null,"wai1.video.av1",null]}},
+{"name":"codecs_ok_3","op":"codecs","input":{"value":"wai2.video.avc+video.lcevc"},"expect":{"elements":["wai2.video.avc+video.lcevc"]}},
+{"name":"codecs_ok_4","op":"codecs","input":{"value":"wai2.video.int_motion+video.int_refine"},"expect":{"elements":["wai2.video.int_motion+video.int_refine"]}},
+{"name":"codecs_ok_5","op":"codecs","input":{"value":"wai2.neural.int_mlicpp|image.avif"},"expect":{"elements":["wai2.neural.int_mlicpp|image.avif"]}},
+{"name":"codecs_uppercase","op":"codecs","input":{"value":"wai1.Video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_empty_segment","op":"codecs","input":{"value":"wai1.video..av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_wai3","op":"codecs","input":{"value":"wai3.video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_plus_standalone","op":"codecs","input":{"value":"wai1.video.av1+video.vp9"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_companion_first","op":"codecs","input":{"value":"wai1.meta.hdr10plus"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_refinement_first","op":"codecs","input":{"value":"wai2.video.int_refine"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_derivation","op":"codecs","input":{"value":"wai1.derive.crop"},"expect":{"error":"codecs_not_media"}},
+{"name":"codecs_record","op":"codecs","input":{"value":"wai1.video.manifest"},"expect":{"error":"codecs_not_media"}},
+{"name":"codecs_candidate","op":"codecs","input":{"value":"wai1.splat.sog"},"expect":{"error":"codecs_candidate"}},
+{"name":"codecs_one_segment","op":"codecs","input":{"value":"wai1.video"},"expect":{"error":"codecs_malformed"}},
+{"name":"union_O9","op":"union_floor","input":{"objects":["O9a","O9b","O9c"]},"expect":{"union":"wai2.video.av1|video.int_hyper","floor":"wai2.video.av1"}},
+{"name":"union_O3","op":"union_floor","input":{"objects":["O3"]},"expect":{"union":"wai2.video.av1+meta.hdr10plus","floor":"wai2.video.av1+meta.hdr10plus"}},
+{"name":"union_O8","op":"union_floor","input":{"objects":["O8"]},"expect":{"union":"wai2.video.avc+video.lcevc|video.av1","floor":"wai2.video.avc+video.lcevc|video.av1"}},
+{"name":"union_O2","op":"union_floor","input":{"objects":["O2"]},"expect":{"union":"wai2.neural.int_mlicpp|image.avif|image.jxl|image.png","floor":"wai2.neural.int_mlicpp|image.avif|image.jxl|image.png"}},
+{"name":"union_wai1_only","op":"union_floor","input":{"objects":["O9b","O9c"]},"expect":{"union":"wai1.video.av1","floor":"wai1.video.av1"}},
+{"name":"floor_none","op":"union_floor","input":{"objects":["O9b","O2"]},"expect":{"error":"codecs_no_common_capability"}},
+{"name":"codecs_non_ascii_prefix","op":"codecs","input":{"value":"waié.video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_non_ascii_digit","op":"codecs","input":{"value":"wai١.video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_non_ascii_cap","op":"codecs","input":{"value":"wai2.videó.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_non_ascii_classical","op":"codecs","input":{"value":"vidéo.av1"},"expect":{"elements":[null]}},
+{"name":"codecs_upper_prefix","op":"codecs","input":{"value":"WAI2.video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_mixed_prefix","op":"codecs","input":{"value":"Wai1.video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_wai_word","op":"codecs","input":{"value":"waiting.for.godot"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_dup_alt","op":"codecs","input":{"value":"wai2.video.av1|video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_dup_plus","op":"codecs","input":{"value":"wai2.video.av1+meta.hdr10plus+meta.hdr10plus"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_plus_is_alt","op":"codecs","input":{"value":"wai2.video.av1+video.av1"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_empty_element","op":"codecs","input":{"value":"wai2.video.av1,,mp4a.40.2"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_trailing_comma","op":"codecs","input":{"value":"wai2.video.av1,"},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_empty_value","op":"codecs","input":{"value":""},"expect":{"error":"codecs_malformed"}},
+{"name":"codecs_companion_in_two_alts","op":"codecs","input":{"value":"wai2.video.av1+meta.hdr10plus|video.vp9+meta.hdr10plus"},"expect":{"elements":["wai2.video.av1+meta.hdr10plus|video.vp9+meta.hdr10plus"]}},
+{"name":"response_plus_first","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes +1009-3593/53794","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"content_range_mismatch"}},
+{"name":"response_plus_last","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-+3593/53794","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"content_range_mismatch"}},
+{"name":"response_underscore","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3_593/53794","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"content_range_mismatch"}},
+{"name":"response_inner_space","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009- 3593/53794","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"content_range_mismatch"}},
+{"name":"response_non_ascii_digit","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes ١٠٠٩-3593/53794","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"content_range_mismatch"}},
+{"name":"response_plus_complete","op":"response","input":{"request":[1009,3593],"status":206,"content_range":"bytes 1009-3593/+53794","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"error":"complete_length_mismatch"}},
+{"name":"response_outer_whitespace","op":"response","input":{"request":[1009,3593],"status":206,"content_range":" bytes 1009-3593/53794\t","content_encoding":null,"body_len":2585,"envelope_len":53794},"expect":{"ok":[1009,3593]}},
+{"name":"fetch_OE1_encrypted","op":"fetch","input":{"object":"OE1","fragment":"#n=299","advertises":["wai.text.zstd"]},"expect":{"error":"inert","skipped":[[0,"unsupported_encryption"]]}},
+{"name":"select_OE2s_security_string","op":"select","input":{"object":"OE2s","advertises":["wai.text.zstd"]},"expect":{"inert":[[0,"unsupported_encryption"]]}},
+{"name":"select_OE2t_security_true","op":"select","input":{"object":"OE2t","advertises":["wai.text.zstd"]},"expect":{"inert":[[0,"unsupported_encryption"]]}},
+{"name":"fetch_OE2s_security_string","op":"fetch","input":{"object":"OE2s","advertises":["wai.text.zstd"]},"expect":{"error":"inert","skipped":[[0,"unsupported_encryption"]]}},
+{"name":"fetch_OR_malformed_refines","op":"fetch","input":{"object":"OR","advertises":["wai.video.int_motion"],"applies":["wai.video.int_refine"]},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":9615,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"6b1bcc071f58c5fb62613d029be744e824494acf931a1c46d89641a548b4aa91"}},
+{"name":"union_OR_malformed_refines","op":"union_floor","input":{"objects":["OR"]},"expect":{"union":"wai2.video.int_motion","floor":"wai2.video.int_motion"}},
+{"name":"parse_head_kid_string","op":"parse_head","input":{"file":"bad/OK.wai"},"expect":{"error":"head_malformed"}},
+{"name":"parse_head_kind_number","op":"parse_head","input":{"file":"bad/OKN.wai"},"expect":{"error":"head_malformed"}},
+{"name":"union_O10_layers","op":"union_floor","input":{"objects":["O10","O10L1","O10L2"]},"expect":{"union":"wai1.audio.flac+audio.int_refine","floor":"wai1.audio.flac+audio.int_refine"}},
+{"name":"union_O10_layers_unbound","op":"union_floor","input":{"objects":["O10L1","O10L2"]},"expect":{"error":"codecs_layer_unbound"}},
+{"name":"fetch_O10_base","op":"fetch","input":{"object":"O10","advertises":["wai.audio.flac"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":1910,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"67ddfc4700c518d0f0028fd03920901057f419d9fc84349e1c9cf7a75314fefc"}},
+{"name":"fetch_O10L1_discovered","op":"fetch","input":{"object":"O10L1","fragment":"#n=12711&h=1009","advertises":[]},"expect":{"role":"layer","pick":0,"verified_by":"whole-object","why_whole":"layer","body_bytes":12892,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"96c9e16b31256d323efe54d996bfab6223f4eeb017da5d55ece7fd74fee750e2"}},
+{"name":"fetch_O10L2_listed","op":"fetch","input":{"object":"O10L2","listed_as_layer":true,"advertises":[]},"expect":{"role":"layer","pick":0,"verified_by":"whole-object","why_whole":"layer","body_bytes":18367,"requests":1,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"305486882f8861a5a3bfae0f72baeb9300ce7c2f87db4e084ef7f826ab333a56"}},
+{"name":"fetch_O10L2_listed_abandoned","op":"fetch","input":{"object":"O10L2","listed_as_layer":true,"advertises":[],"tamper":{"kind":"no_refinement"}},"expect":{"role":"layer","pick":0,"verified_by":"whole-object","why_whole":"layer","body_bytes":0,"requests":1,"companions":[],"refinements":[],"abandoned":[0],"dropped":[],"skipped":[],"component_sha256":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"}},
+{"name":"fetch_O10L1_listed_refused","op":"fetch","input":{"object":"O10L1","listed_as_layer":true,"advertises":[],"tamper":{"kind":"gzip"}},"expect":{"role":"layer","pick":0,"verified_by":"whole-object","why_whole":"layer","body_bytes":12711,"requests":1,"companions":[],"refinements":[],"abandoned":[0],"dropped":[],"skipped":[],"component_sha256":"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"}},
+{"name":"fetch_O10_listed_not_layer","op":"fetch","input":{"object":"O10","listed_as_layer":true,"advertises":["wai.audio.flac"]},"expect":{"error":"not_a_layer"}},
+{"name":"fetch_O10L1_declared","op":"fetch","input":{"object":"O10L1","advertises":[],"declared":"wai1.audio.flac+audio.int_refine","layer_base":"O10"},"expect":{"role":"layer","pick":0,"verified_by":"whole-object","why_whole":"layer","body_bytes":12892,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"96c9e16b31256d323efe54d996bfab6223f4eeb017da5d55ece7fd74fee750e2"}},
+{"name":"fetch_O10L1_undeclared","op":"fetch","input":{"object":"O10L1","advertises":[],"declared":"wai1.audio.flac","layer_base":"O10"},"expect":{"error":"codecs_undeclared"}},
+{"name":"fetch_O10L1_declared_other_alt","op":"fetch","input":{"object":"O10L1","advertises":[],"declared":"wai1.audio.flac|audio.int_codec+audio.int_refine","layer_base":"O10"},"expect":{"error":"codecs_undeclared"}},
+{"name":"fetch_O10L1_declared_no_base","op":"fetch","input":{"object":"O10L1","advertises":[],"declared":"wai1.audio.flac+audio.int_refine"},"expect":{"error":"codecs_undeclared"}},
+{"name":"fetch_OPf_dispatched","op":"fetch","input":{"object":"OPf","advertises":["wai.text.zstd"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":320,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_OPf_listed_not_layer","op":"fetch","input":{"object":"OPf","listed_as_layer":true,"advertises":["wai.text.zstd"]},"expect":{"error":"not_a_layer"}},
+{"name":"union_OPf","op":"union_floor","input":{"objects":["OPf"]},"expect":{"union":"wai1.text.zstd","floor":"wai1.text.zstd"}},
+{"name":"fetch_OPf_declared","op":"fetch","input":{"object":"OPf","advertises":["wai.text.zstd"],"declared":"wai1.text.zstd"},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":320,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_OPe_dispatched","op":"fetch","input":{"object":"OPe","advertises":["wai.text.zstd"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":317,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_OPe_listed_not_layer","op":"fetch","input":{"object":"OPe","listed_as_layer":true,"advertises":["wai.text.zstd"]},"expect":{"error":"not_a_layer"}},
+{"name":"union_OPe","op":"union_floor","input":{"objects":["OPe"]},"expect":{"union":"wai1.text.zstd","floor":"wai1.text.zstd"}},
+{"name":"fetch_OPe_declared","op":"fetch","input":{"object":"OPe","advertises":["wai.text.zstd"],"declared":"wai1.text.zstd"},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":317,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_OPw_dispatched","op":"fetch","input":{"object":"OPw","advertises":["wai.text.zstd"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":474,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_OPw_listed_not_layer","op":"fetch","input":{"object":"OPw","listed_as_layer":true,"advertises":["wai.text.zstd"]},"expect":{"error":"not_a_layer"}},
+{"name":"union_OPw","op":"union_floor","input":{"objects":["OPw"]},"expect":{"union":"wai1.text.zstd","floor":"wai1.text.zstd"}},
+{"name":"fetch_OPw_declared","op":"fetch","input":{"object":"OPw","advertises":["wai.text.zstd"],"declared":"wai1.text.zstd"},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"single_component","body_bytes":474,"requests":2,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_ORN_whole","op":"fetch","input":{"object":"ORN","fragment":"#n=32659&h=1009","advertises":["wai.video.av1"],"applies":["wai.video.int_refine"],"threshold_permille":900},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"range_threshold","body_bytes":32872,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[[1,"component_digest_absent"]],"skipped":[],"component_sha256":"7898322c774e80346b83405764069cbf1d06484da8824fab90e18e2ce0188f8c"}},
+{"name":"fetch_ORN_ranged","op":"fetch","input":{"object":"ORN","fragment":"#n=32659&h=1009","advertises":["wai.video.av1"],"applies":["wai.video.int_refine"],"threshold_permille":1001},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":30572,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[[1,"component_digest_absent"]],"skipped":[],"component_sha256":"7898322c774e80346b83405764069cbf1d06484da8824fab90e18e2ce0188f8c"}},
+{"name":"fetch_OS_threshold_stall","op":"fetch","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","tamper":{"kind":"no_refinement"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_OS_threshold_stall_1001","op":"fetch","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","tamper":{"kind":"no_refinement"},"threshold_permille":1001},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_OS_full","op":"fetch","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS"},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":38705,"requests":4,"companions":[1],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_ON_refinement_no_digest","op":"fetch","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"ON"},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8629,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[[1,"component_digest_absent"]],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_OW_refinement_wrong_digest","op":"fetch","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OW"},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":38705,"requests":4,"companions":[],"refinements":[],"abandoned":[],"dropped":[[1,"component_digest_mismatch"]],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"plan_OS_base_only_threshold","op":"plan","input":{"object":"OS","wanted":[[0,"base"],[1,"refinement"]],"held":[[0,1008]]},"expect":{"requests":[[1009,8459,"base"],[8460,38459,"refinement"]],"dropped":[]}},
+{"name":"plan_ON_refinement_dropped","op":"plan","input":{"object":"ON","wanted":[[0,"base"],[1,"refinement"]],"held":[[0,1008]]},"expect":{"requests":[[1009,8383,"base"]],"dropped":[[1,"component_digest_absent"]]}},
+{"name":"timed_OS_base_ready_first","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base",1000],["tick",1049],["tick",1050]],"deadline_ms":50},"expect":{"ready_step":0,"ready_at":1000,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[[1049,[]],[1050,[3]]],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_refinement_after_base","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base",10],["refinement",20,"range"]]},"expect":{"ready_step":0,"ready_at":10,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":38705,"requests":4,"companions":[1],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_clock_never_ticked","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base",1759680000000],["tick",1759680000000],["tick",1759680001999],["tick",1759680002000]],"deadline_ms":2000},"expect":{"ready_step":0,"ready_at":1759680000000,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[[1759680000000,[]],[1759680001999,[]],[1759680002000,[3]]],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_clock_ticked_0","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["tick",0],["base",5000],["tick",6999],["tick",7000]],"deadline_ms":2000},"expect":{"ready_step":1,"ready_at":5000,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[[0,[]],[6999,[]],[7000,[3]]],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_clock_stepped_back","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["tick",10000],["tick",5],["base",6],["tick",2005],["tick",2006]],"deadline_ms":2000},"expect":{"ready_step":2,"ready_at":6,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[[10000,[]],[5,[]],[2005,[]],[2006,[3]]],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_clock_back_after","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base",5000],["tick",4000],["tick",0],["tick",6999],["tick",7000]],"deadline_ms":2000},"expect":{"ready_step":0,"ready_at":5000,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[[4000,[]],[0,[]],[6999,[]],[7000,[3]]],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_clock_saturates","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base",18446744073709551605],["tick",18446744073709551614],["tick",18446744073709551615]],"deadline_ms":2000},"expect":{"ready_step":0,"ready_at":18446744073709551605,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[[18446744073709551614,[]],[18446744073709551615,[3]]],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8705,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_ready_then_200_base_flipped","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base",10],["refinement",20,"whole_200"]],"flip":560},"expect":{"ready_step":0,"ready_at":10,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":47165,"requests":4,"companions":[1],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_ready_then_200_enh_flipped","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base",10],["refinement",20,"whole_200"]],"flip":8560},"expect":{"ready_step":0,"ready_at":10,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":47165,"requests":4,"companions":[],"refinements":[],"abandoned":[],"dropped":[[1,"component_digest_mismatch"]],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"timed_OS_200_before_base","op":"fetch_timed","input":{"advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"fragment":"#n=38460&h=1009","object":"OS","script":[["base_once",1],["refinement",2,"whole_200"],["base",3]],"flip":560},"expect":{"ready_step":2,"ready_at":3,"base":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"base_end":{"pick":0,"verified_by":"head-proof","component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18","companions":[],"refinements":[]},"ticks":[],"outcome":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":47165,"requests":4,"companions":[1],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}}},
+{"name":"fetch_O8_refinement_gzip","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"tamper":{"refinement":"gzip"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":28844,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O8_refinement_bad_range","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"tamper":{"refinement":"bad_range"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":28844,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O8_refinement_416","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"tamper":{"refinement":"416"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":8844,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O8_refinement_complete_length","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"tamper":{"refinement":"complete_length"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":28844,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O8_refinement_plus_sign","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"tamper":{"refinement":"plus_sign"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":28844,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_O8_refinement_short_200","op":"fetch","input":{"object":"O8","fragment":"#n=46433&h=1009","advertises":["wai.video.avc"],"applies":["wai.video.lcevc"],"tamper":{"refinement":"short_200"}},"expect":{"role":"base","pick":0,"verified_by":"head-proof","why_whole":null,"body_bytes":28844,"requests":4,"companions":[],"refinements":[],"abandoned":[1],"dropped":[],"skipped":[],"component_sha256":"e93f5c55dc5938a8cadd00477e4110d567d4a725b647a3cddf0c70c5e59dcd18"}},
+{"name":"fetch_OD_stale","op":"fetch","input":{"object":"OD","advertises":["wai.video.av1"],"tamper":{"first_range_flip":2000}},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"component_digest_mismatch","body_bytes":69399,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"f541874101876255b4baf3a739778d04cb9cba25ffa38b30bc1fb8b0701f2a45"}},
+{"name":"fetch_OT_stale_small","op":"fetch","input":{"object":"OT","advertises":["wai.video.av1"],"tamper":{"first_range_flip":2000}},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"component_digest_mismatch","body_bytes":23908,"requests":3,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"f541874101876255b4baf3a739778d04cb9cba25ffa38b30bc1fb8b0701f2a45"}},
+{"name":"head_proof_huge_O3","op":"head_proof","input":{"object":"O3","proof":"cases/head_proof_huge_O3.hp"},"expect":{"error":"head_proof_malformed"}},
+{"name":"union_OF_record_fallback","op":"union_floor","input":{"objects":["OF"]},"expect":{"union":"wai1.text.zstd","floor":"wai1.text.zstd"}},
+{"name":"fetch_OF_record_fallback","op":"fetch","input":{"object":"OF","fragment":"#n=283","advertises":["wai.text.zstd"]},"expect":{"role":"base","pick":0,"verified_by":"whole-object","why_whole":"below_one_chunk","body_bytes":283,"requests":1,"companions":[],"refinements":[],"abandoned":[],"dropped":[],"skipped":[],"component_sha256":"591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1"}},
+{"name":"fetch_O3_proof_unanswered","op":"fetch","input":{"object":"O3","advertises":["wai.video.av1"],"tamper":{"kind":"no_proof"}},"expect":{"error":"base_unanswered"}},
+{"name":"layer_tag_ok","op":"layer_tag","input":{"line":"#WAI-LAYER:N=1,URI=\"objects/a.wai#n=5,6\""},"expect":{"n":1,"uri":"objects/a.wai#n=5,6"}},
+{"name":"layer_tag_unknown_attribute","op":"layer_tag","input":{"line":"#WAI-LAYER:URI=\"x.wai\",N=255,X-FUTURE=ENUM"},"expect":{"n":255,"uri":"x.wai"}},
+{"name":"layer_tag_zero","op":"layer_tag","input":{"line":"#WAI-LAYER:N=0,URI=\"x\""},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_256","op":"layer_tag","input":{"line":"#WAI-LAYER:N=256,URI=\"x\""},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_no_uri","op":"layer_tag","input":{"line":"#WAI-LAYER:N=1"},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_unquoted_uri","op":"layer_tag","input":{"line":"#WAI-LAYER:N=1,URI=x"},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_twice","op":"layer_tag","input":{"line":"#WAI-LAYER:N=1,N=2,URI=\"x\""},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_plus","op":"layer_tag","input":{"line":"#WAI-LAYER:N=+1,URI=\"x\""},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_non_ascii_digit","op":"layer_tag","input":{"line":"#WAI-LAYER:N=١,URI=\"x\""},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_lower_name","op":"layer_tag","input":{"line":"#WAI-LAYER:n=1,URI=\"x\""},"expect":{"error":"layer_tag_malformed"}},
+{"name":"layer_tag_unterminated","op":"layer_tag","input":{"line":"#WAI-LAYER:N=1,URI=\"x"},"expect":{"error":"layer_tag_malformed"}},
+{"name":"supports_floor","op":"supports","input":{"floor":"wai2.video.av1","containers":["WAI1","WAI2"],"caps":["wai.video.av1"]},"expect":{"supports":true}},
+{"name":"supports_union_only","op":"supports","input":{"floor":"wai2.video.av1","containers":["WAI1","WAI2"],"caps":["wai.video.int_hyper"]},"expect":{"supports":false}},
+{"name":"supports_container_gate","op":"supports","input":{"floor":"wai2.video.av1","containers":["WAI1"],"caps":["wai.video.av1"]},"expect":{"supports":false}},
+{"name":"supports_wai1","op":"supports","input":{"floor":"wai1.video.av1","containers":["WAI1"],"caps":["wai.video.av1"]},"expect":{"supports":true}},
+{"name":"supports_companion_ignored","op":"supports","input":{"floor":"wai2.video.av1+meta.hdr10plus","containers":["WAI1","WAI2"],"caps":["wai.video.av1"]},"expect":{"supports":true}}
+]
diff --git a/wai/http-conformance/cases/head_proof_drop_cv_O3.hp b/wai/http-conformance/cases/head_proof_drop_cv_O3.hp
new file mode 100644
index 000000000..98b7ed088
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_drop_cv_O3.hp differ
diff --git a/wai/http-conformance/cases/head_proof_envelope_len_O3.hp b/wai/http-conformance/cases/head_proof_envelope_len_O3.hp
new file mode 100644
index 000000000..0a7e8e716
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_envelope_len_O3.hp differ
diff --git a/wai/http-conformance/cases/head_proof_extra_cv_O3.hp b/wai/http-conformance/cases/head_proof_extra_cv_O3.hp
new file mode 100644
index 000000000..e67e503c7
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_extra_cv_O3.hp differ
diff --git a/wai/http-conformance/cases/head_proof_flip_cv_O3.hp b/wai/http-conformance/cases/head_proof_flip_cv_O3.hp
new file mode 100644
index 000000000..a05a1cb4f
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_flip_cv_O3.hp differ
diff --git a/wai/http-conformance/cases/head_proof_huge_O3.hp b/wai/http-conformance/cases/head_proof_huge_O3.hp
new file mode 100644
index 000000000..4f2d574b2
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_huge_O3.hp differ
diff --git a/wai/http-conformance/cases/head_proof_magic.hp b/wai/http-conformance/cases/head_proof_magic.hp
new file mode 100644
index 000000000..c27341ad2
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_magic.hp differ
diff --git a/wai/http-conformance/cases/head_proof_not_formula_OH.hp b/wai/http-conformance/cases/head_proof_not_formula_OH.hp
new file mode 100644
index 000000000..73b77f0b8
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_not_formula_OH.hp differ
diff --git a/wai/http-conformance/cases/head_proof_of_O4.hp b/wai/http-conformance/cases/head_proof_of_O4.hp
new file mode 100644
index 000000000..3587e7b24
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_of_O4.hp differ
diff --git a/wai/http-conformance/cases/head_proof_unaligned_O3.hp b/wai/http-conformance/cases/head_proof_unaligned_O3.hp
new file mode 100644
index 000000000..b0dee01f4
Binary files /dev/null and b/wai/http-conformance/cases/head_proof_unaligned_O3.hp differ
diff --git a/wai/http-conformance/falsify/accept-gzip.patch b/wai/http-conformance/falsify/accept-gzip.patch
new file mode 100644
index 000000000..afbe305e9
--- /dev/null
+++ b/wai/http-conformance/falsify/accept-gzip.patch
@@ -0,0 +1,15 @@
+# must fail: response_gzip fetch_gzip_O3
+# a content coding is accepted (session::check_response)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 4730c192..da765beb 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -206,7 +206,7 @@ pub fn check_response(req: Option<ByteRange>, r: &ResponseMeta, body_len: u64, e
+     -> Result<ByteRange, RangeRefusal> {
+     let coded = |r: &ResponseMeta| r.content_encoding.as_deref()
+         .map(str::trim)
+-        .filter(|c| !c.is_empty() && !c.eq_ignore_ascii_case("identity"))
++        .filter(|_| false)
+         .map(str::to_string);
+     match r.status {
+         206 => {
diff --git a/wai/http-conformance/falsify/allow-trailing.patch b/wai/http-conformance/falsify/allow-trailing.patch
new file mode 100644
index 000000000..8b44bc2aa
--- /dev/null
+++ b/wai/http-conformance/falsify/allow-trailing.patch
@@ -0,0 +1,15 @@
+# must fail: object_length_trailing
+# bytes after the envelope are accepted (head::parse_head)
+diff --git a/wai/wai-rs/src/http_binding/head.rs b/wai/wai-rs/src/http_binding/head.rs
+index 1470133d..b861cb16 100644
+--- a/wai/wai-rs/src/http_binding/head.rs
++++ b/wai/wai-rs/src/http_binding/head.rs
+@@ -101,7 +101,7 @@ pub fn parse_head(prefix: &[u8], envelope_len: u64) -> Result<HeadParse, RangeRe
+         }
+     };
+     let total = head_len + components.iter().map(|c| c.len).sum::<u64>();
+-    if total != envelope_len {
++    if total > envelope_len {
+         return Err(RangeRefusal::ObjectLengthMismatch { expected: total, got: envelope_len });
+     }
+     let bytes = prefix[..head_len as usize].to_vec();
diff --git a/wai/http-conformance/falsify/base-ready-at-done.patch b/wai/http-conformance/falsify/base-ready-at-done.patch
new file mode 100644
index 000000000..cbc735910
--- /dev/null
+++ b/wai/http-conformance/falsify/base-ready-at-done.patch
@@ -0,0 +1,15 @@
+# must fail: timed_OS_base_ready_first timed_OS_clock_ticked_0 timed_OS_ready_then_200_base_flipped
+# the base is ready only when its refinements are done (session::FetchSession::advance_components)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index ec31518e..e8478b40 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -766,7 +766,7 @@ impl FetchSession {
+                 requests: s.requests,
+             }
+         };
+-        if !base_pending && self.base.is_none() {
++        if !pending && self.base.is_none() {
+             // §10.1: the base is presentable now, whatever its refinements do.
+             self.base = Some((assemble(&parts, true, self), self.now_ms));
+         }
diff --git a/wai/http-conformance/falsify/base-unanswered.patch b/wai/http-conformance/falsify/base-unanswered.patch
new file mode 100644
index 000000000..97472f8d8
--- /dev/null
+++ b/wai/http-conformance/falsify/base-unanswered.patch
@@ -0,0 +1,15 @@
+# must fail: fetch_O3_proof_unanswered
+# an unanswered base is reported as a malformed head (session::drive)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 4730c192..9ba8287a 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -802,7 +802,7 @@ pub fn drive(
+             }
+             if session.queued.is_empty() {
+                 if session.outstanding() > 0 {
+-                    return Err(RangeRefusal::BaseUnanswered);
++                    return Err(RangeRefusal::HeadMalformed("unanswered".into()));
+                 }
+                 return Err(RangeRefusal::HeadMalformed("the session wants nothing and has no outcome".into()));
+             }
diff --git a/wai/http-conformance/falsify/counter.patch b/wai/http-conformance/falsify/counter.patch
new file mode 100644
index 000000000..f22f7ba1a
--- /dev/null
+++ b/wai/http-conformance/falsify/counter.patch
@@ -0,0 +1,15 @@
+# must fail: head_proof_ok_OH
+# covered subtrees are hashed with chunk counter 0 (head_proof::node_cv)
+diff --git a/wai/wai-rs/src/http_binding/head_proof.rs b/wai/wai-rs/src/http_binding/head_proof.rs
+index 40b6f1fa..d13bcdac 100644
+--- a/wai/wai-rs/src/http_binding/head_proof.rs
++++ b/wai/wai-rs/src/http_binding/head_proof.rs
+@@ -66,7 +66,7 @@ fn node_cv(
+     if start >= c {
+         it.next().ok_or(RangeRefusal::HeadProofMismatch)
+     } else if start + len <= c {
+-        Ok(subtree_cv(&x_prefix[start as usize..(start + len) as usize], start))
++        Ok(subtree_cv(&x_prefix[start as usize..(start + len) as usize], 0))
+     } else {
+         let l = left_len(len);
+         let left = node_cv(x_prefix, start, l, c, it)?;
diff --git a/wai/http-conformance/falsify/deadline-wraps.patch b/wai/http-conformance/falsify/deadline-wraps.patch
new file mode 100644
index 000000000..e0537ee87
--- /dev/null
+++ b/wai/http-conformance/falsify/deadline-wraps.patch
@@ -0,0 +1,15 @@
+# must fail: timed_OS_clock_saturates
+# the deadline wraps past the end of u64 (session::FetchSession::tick)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index ec31518e..d5f96691 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -398,7 +398,7 @@ impl FetchSession {
+     pub fn tick(&mut self, now_ms: u64) -> Vec<u32> {
+         self.now_ms = now_ms;
+         let (Some(at), Some(d)) = (self.base_ready_at(), self.policy.refinement_deadline_ms) else { return Vec::new() };
+-        if self.result.is_some() || now_ms < at.saturating_add(u64::from(d)) {
++        if self.result.is_some() || now_ms < at.wrapping_add(u64::from(d)) {
+             return Vec::new();
+         }
+         let ids = self.outstanding_of(Class::Refinement);
diff --git a/wai/http-conformance/falsify/dispatch-layer.patch b/wai/http-conformance/falsify/dispatch-layer.patch
new file mode 100644
index 000000000..75bb37294
--- /dev/null
+++ b/wai/http-conformance/falsify/dispatch-layer.patch
@@ -0,0 +1,15 @@
+# must fail: fetch_O10L1_discovered
+# a layer is dispatched under SPEC §4 (session::advance_head)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 4730c192..44fa50f2 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -575,7 +575,7 @@ impl FetchSession {
+         }
+         self.head = Some(head.clone());
+         match head.version {
+-            Version::Wai1 if head.is_layer() => {
++            Version::Wai1 if false && head.is_layer() => {
+                 // A layer goes to staged delivery, never to SPEC §4 (§10.4): the rest of
+                 // it at refinement class, then the whole envelope against the cid.
+                 self.to_rest(&head, WhyWhole::Layer, Class::Refinement);
diff --git a/wai/http-conformance/falsify/drop-domain.patch b/wai/http-conformance/falsify/drop-domain.patch
new file mode 100644
index 000000000..a80747661
--- /dev/null
+++ b/wai/http-conformance/falsify/drop-domain.patch
@@ -0,0 +1,14 @@
+# must fail: head_proof_ok_O3 fetch_O3_low
+# the content hash loses its domain (jwp_hash::content_hash)
+diff --git a/wai/wai-rs/src/jwp_hash.rs b/wai/wai-rs/src/jwp_hash.rs
+index d20bc358..f773f1fd 100644
+--- a/wai/wai-rs/src/jwp_hash.rs
++++ b/wai/wai-rs/src/jwp_hash.rs
+@@ -13,7 +13,6 @@ pub const DOMAIN_OBJECT: &[u8] = b"moq-jwp:object\x01";
+ /// followed by the envelope bytes.
+ pub fn content_hash(envelope_bytes: &[u8]) -> [u8; 32] {
+     let mut h = blake3::Hasher::new();
+-    h.update(DOMAIN_OBJECT);
+     h.update(envelope_bytes);
+     *h.finalize().as_bytes()
+ }
diff --git a/wai/http-conformance/falsify/dup-caps.patch b/wai/http-conformance/falsify/dup-caps.patch
new file mode 100644
index 000000000..c75c9fa55
--- /dev/null
+++ b/wai/http-conformance/falsify/dup-caps.patch
@@ -0,0 +1,15 @@
+# must fail: codecs_dup_alt codecs_dup_plus
+# a capability may be named twice (codecs::parse_element)
+diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
+index 530ae822..99f6eba8 100644
+--- a/wai/wai-rs/src/http_binding/codecs.rs
++++ b/wai/wai-rs/src/http_binding/codecs.rs
+@@ -144,7 +144,7 @@ pub fn parse_element(s: &str) -> Result<Element, CodecsError> {
+         let alt = Alt { cap, plus: caps.map(str::to_string).collect() };
+         check_alt(&alt)?;
+         let repeated_plus = alt.plus.iter().enumerate().any(|(i, p)| alt.plus[..i].contains(p) || *p == alt.cap);
+-        if repeated_plus || alts.iter().any(|x| x.cap == alt.cap) {
++        if false && (repeated_plus || alts.iter().any(|x| x.cap == alt.cap)) {
+             return Err(CodecsError::Malformed(format!("{s}: a capability named twice")));
+         }
+         alts.push(alt);
diff --git a/wai/http-conformance/falsify/intersection.patch b/wai/http-conformance/falsify/intersection.patch
new file mode 100644
index 000000000..c7965e86a
--- /dev/null
+++ b/wai/http-conformance/falsify/intersection.patch
@@ -0,0 +1,17 @@
+# must fail: union_O9
+# the union is the floor, the intersection (codecs::union_of)
+diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
+index 530ae822..97e32ca4 100644
+--- a/wai/wai-rs/src/http_binding/codecs.rs
++++ b/wai/wai-rs/src/http_binding/codecs.rs
+@@ -338,8 +338,9 @@ pub fn union_of(objects: &[SeqObject]) -> Result<Element, CodecsError> {
+     let each = described(objects)?;
+     let prefix = objects.iter().map(|o| if o.head.version == Version::Wai2 { Prefix::Wai2 } else { Prefix::Wai1 }).max().unwrap_or(Prefix::Wai1);
+     let mut alts: Vec<Alt> = Vec::new();
++    let all = each.clone();
+     for e in each {
+-        for a in e.alts {
++        for a in e.alts.into_iter().filter(|a| all.iter().all(|o| o.alts.iter().any(|x| x.cap == a.cap))) {
+             match alts.iter_mut().find(|x| x.cap == a.cap) {
+                 Some(x) => {
+                     for p in a.plus {
diff --git a/wai/http-conformance/falsify/layer-any-alt.patch b/wai/http-conformance/falsify/layer-any-alt.patch
new file mode 100644
index 000000000..34ba8b403
--- /dev/null
+++ b/wai/http-conformance/falsify/layer-any-alt.patch
@@ -0,0 +1,15 @@
+# must fail: fetch_O10L1_declared_other_alt
+# a layer is declared after + in any alt, not only its base's (codecs::check_declared)
+diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
+index 568a3c5a..b3ea95e5 100644
+--- a/wai/wai-rs/src/http_binding/codecs.rs
++++ b/wai/wai-rs/src/http_binding/codecs.rs
+@@ -393,7 +393,7 @@ pub fn check_declared(head: &Head, union: &Element, base: Option<&SeqObject>) ->
+             .and_then(|r| super::unhex32(&r.base))
+             .ok_or_else(undeclared)?;
+         let base_cap = base.and_then(|b| base_capability(b, &refines)).ok_or_else(undeclared)?;
+-        return if union.alts.iter().any(|a| a.cap == base_cap && a.plus.contains(&cap)) { Ok(()) } else { Err(undeclared()) };
++        return if union.alts.iter().any(|a| { let _ = &base_cap; a.plus.contains(&cap) }) { Ok(()) } else { Err(undeclared()) };
+     }
+     let e = element_of(head)?;
+     if e.prefix > union.prefix {
diff --git a/wai/http-conformance/falsify/layer-without-base.patch b/wai/http-conformance/falsify/layer-without-base.patch
new file mode 100644
index 000000000..2490a1d10
--- /dev/null
+++ b/wai/http-conformance/falsify/layer-without-base.patch
@@ -0,0 +1,15 @@
+# must fail: fetch_O10L1_declared_no_base
+# a layer is declared with no base held (codecs::check_declared)
+diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
+index 568a3c5a..40a04044 100644
+--- a/wai/wai-rs/src/http_binding/codecs.rs
++++ b/wai/wai-rs/src/http_binding/codecs.rs
+@@ -392,7 +392,7 @@ pub fn check_declared(head: &Head, union: &Element, base: Option<&SeqObject>) ->
+             .and_then(|v| Refines::from_value(v, RefForm::ContentHash).ok())
+             .and_then(|r| super::unhex32(&r.base))
+             .ok_or_else(undeclared)?;
+-        let base_cap = base.and_then(|b| base_capability(b, &refines)).ok_or_else(undeclared)?;
++        let Some(base_cap) = base.and_then(|b| base_capability(b, &refines)) else { return Ok(()) };
+         return if union.alts.iter().any(|a| a.cap == base_cap && a.plus.contains(&cap)) { Ok(()) } else { Err(undeclared()) };
+     }
+     let e = element_of(head)?;
diff --git a/wai/http-conformance/falsify/left-len.patch b/wai/http-conformance/falsify/left-len.patch
new file mode 100644
index 000000000..e09b4f81c
--- /dev/null
+++ b/wai/http-conformance/falsify/left-len.patch
@@ -0,0 +1,15 @@
+# must fail: head_proof_ok_O3
+# the left subtree is half the length, rounded down to a chunk (head_proof::left_len)
+diff --git a/wai/wai-rs/src/http_binding/head_proof.rs b/wai/wai-rs/src/http_binding/head_proof.rs
+index 40b6f1fa..ea665c22 100644
+--- a/wai/wai-rs/src/http_binding/head_proof.rs
++++ b/wai/wai-rs/src/http_binding/head_proof.rs
+@@ -35,7 +35,7 @@ pub struct HeadProof {
+ /// leaves at least one byte to the right.
+ fn left_len(n: u64) -> u64 {
+     let q = (n - 1) / CHUNK;
+-    CHUNK << (63 - q.leading_zeros())
++    ((n / 2) / CHUNK).max(1) * CHUNK
+ }
+ 
+ /// The root of a tree from its two children: BLAKE3's parent node with the ROOT flag.
diff --git a/wai/http-conformance/falsify/merge-classes.patch b/wai/http-conformance/falsify/merge-classes.patch
new file mode 100644
index 000000000..a51827528
--- /dev/null
+++ b/wai/http-conformance/falsify/merge-classes.patch
@@ -0,0 +1,15 @@
+# must fail: plan_classes_O8
+# ranges of different classes are merged (plan::plan_components)
+diff --git a/wai/wai-rs/src/http_binding/plan.rs b/wai/wai-rs/src/http_binding/plan.rs
+index 1d2902f7..fc58b047 100644
+--- a/wai/wai-rs/src/http_binding/plan.rs
++++ b/wai/wai-rs/src/http_binding/plan.rs
+@@ -151,7 +151,7 @@ pub fn plan_components(
+     let mut merged: Vec<(Class, u64, u64)> = Vec::new();
+     for (class, a, b) in pieces {
+         match merged.last_mut() {
+-            Some((c, _, e)) if *c == class && *e >= a => *e = (*e).max(b),
++            Some((_, _, e)) if *e >= a => *e = (*e).max(b),
+             _ => merged.push((class, a, b)),
+         }
+     }
diff --git a/wai/http-conformance/falsify/no-root-flag.patch b/wai/http-conformance/falsify/no-root-flag.patch
new file mode 100644
index 000000000..022e97dff
--- /dev/null
+++ b/wai/http-conformance/falsify/no-root-flag.patch
@@ -0,0 +1,15 @@
+# must fail: head_proof_ok_O3
+# the root merge drops the ROOT flag (head_proof::merge_root)
+diff --git a/wai/wai-rs/src/http_binding/head_proof.rs b/wai/wai-rs/src/http_binding/head_proof.rs
+index 40b6f1fa..69ba8a98 100644
+--- a/wai/wai-rs/src/http_binding/head_proof.rs
++++ b/wai/wai-rs/src/http_binding/head_proof.rs
+@@ -40,7 +40,7 @@ fn left_len(n: u64) -> u64 {
+ 
+ /// The root of a tree from its two children: BLAKE3's parent node with the ROOT flag.
+ fn merge_root(l: &ChainingValue, r: &ChainingValue) -> [u8; 32] {
+-    *merge_subtrees_root(l, r, Mode::Hash).as_bytes()
++    merge_subtrees_non_root(l, r, Mode::Hash)
+ }
+ 
+ /// The non-root chaining value of the subtree `x[..len]` whose first chunk is at
diff --git a/wai/http-conformance/falsify/plus-sign.patch b/wai/http-conformance/falsify/plus-sign.patch
new file mode 100644
index 000000000..99fddd082
--- /dev/null
+++ b/wai/http-conformance/falsify/plus-sign.patch
@@ -0,0 +1,15 @@
+# must fail: response_plus_first
+# a Content-Range number may carry a sign (session::digits)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 4730c192..8b8f7e67 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -194,7 +194,7 @@ impl Selector {
+ /// Whether `s` is one or more ASCII digits: the `1*DIGIT` of RFC 9110 §14.4. No sign,
+ /// separator, space or other script's digit.
+ fn digits(s: &str) -> Option<u64> {
+-    if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {
++    if s.is_empty() {
+         return None;
+     }
+     s.parse().ok()
diff --git a/wai/http-conformance/falsify/record-alt.patch b/wai/http-conformance/falsify/record-alt.patch
new file mode 100644
index 000000000..5af044f33
--- /dev/null
+++ b/wai/http-conformance/falsify/record-alt.patch
@@ -0,0 +1,15 @@
+# must fail: union_OF_record_fallback
+# a WAI1 lists a capability SPEC §4 never dispatches (codecs::element_of)
+diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
+index 530ae822..ff531eb8 100644
+--- a/wai/wai-rs/src/http_binding/codecs.rs
++++ b/wai/wai-rs/src/http_binding/codecs.rs
+@@ -241,7 +241,7 @@ pub fn element_of(head: &Head) -> Result<Element, CodecsError> {
+             let m = head.manifest_v1().map_err(bad)?;
+             let mut alts: Vec<Alt> = Vec::new();
+             for c in [Some(m.model_requirement.capability.as_str()), m.model_requirement.fallback.as_deref()].into_iter().flatten() {
+-                if is_dispatchable(c) && !alts.iter().any(|a| a.cap == short(c)) {
++                if !alts.iter().any(|a| a.cap == short(c)) {
+                     alts.push(Alt { cap: short(c), plus: Vec::new() });
+                 }
+             }
diff --git a/wai/http-conformance/falsify/refinement-200-whole.patch b/wai/http-conformance/falsify/refinement-200-whole.patch
new file mode 100644
index 000000000..d6b57bf41
--- /dev/null
+++ b/wai/http-conformance/falsify/refinement-200-whole.patch
@@ -0,0 +1,15 @@
+# must fail: timed_OS_200_before_base
+# a refinement 200 keeps the whole object it carries (session::FetchSession::take)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index ec31518e..6300eea5 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -533,7 +533,7 @@ impl FetchSession {
+                     return Ok(());
+                 };
+                 match check_response(Some(r), meta, body.len() as u64, len) {
+-                    Ok(got) if class == Class::Refinement => {
++                    Ok(got) if false && class == Class::Refinement => {
+                         // A refinement's response adds the bytes it was asked for and no
+                         // others: a `200` carrying the whole object is cut to the range.
+                         let (first, end) = (got.first.max(r.first), got.end().min(r.end()));
diff --git a/wai/http-conformance/falsify/refines-makes-layer.patch b/wai/http-conformance/falsify/refines-makes-layer.patch
new file mode 100644
index 000000000..8ab8bd599
--- /dev/null
+++ b/wai/http-conformance/falsify/refines-makes-layer.patch
@@ -0,0 +1,14 @@
+# must fail: fetch_OPf_dispatched fetch_OPe_dispatched fetch_OPw_dispatched fetch_OPf_listed_not_layer fetch_OPw_listed_not_layer union_OPw
+# a payload carrying refines is taken for a layer (head::Head::is_layer)
+diff --git a/wai/wai-rs/src/http_binding/head.rs b/wai/wai-rs/src/http_binding/head.rs
+index 97ff1fac..d5f6339e 100644
+--- a/wai/wai-rs/src/http_binding/head.rs
++++ b/wai/wai-rs/src/http_binding/head.rs
+@@ -164,6 +164,6 @@ impl Head {
+     /// ordinary object: SPEC §4 dispatches it, and `refines` is not read there.
+     pub fn is_layer(&self) -> bool {
+         self.version == Version::Wai1
+-            && self.manifest_v1().is_ok_and(|m| crate::codecs::is_refinement_only(&m.model_requirement.capability))
++            && self.manifest_v1().is_ok_and(|m| m.refines.is_some() || crate::codecs::is_refinement_only(&m.model_requirement.capability))
+     }
+ }
diff --git a/wai/http-conformance/falsify/refusal-ends.patch b/wai/http-conformance/falsify/refusal-ends.patch
new file mode 100644
index 000000000..6383a89f9
--- /dev/null
+++ b/wai/http-conformance/falsify/refusal-ends.patch
@@ -0,0 +1,18 @@
+# must fail: fetch_O8_refinement_gzip fetch_O8_refinement_bad_range
+# a refused refinement response ends the fetch (session::take)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 4730c192..70f19622 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -481,10 +481,7 @@ impl FetchSession {
+                         self.held.push((got, body.to_vec()));
+                         Ok(())
+                     }
+-                    Err(_) if class == Class::Refinement => {
+-                        self.abandon(&want);
+-                        Ok(())
+-                    }
++                    Err(e) if class == Class::Refinement => Err(e),
+                     Err(e) => Err(e),
+                 }
+             }
diff --git a/wai/http-conformance/falsify/response-no-clock.patch b/wai/http-conformance/falsify/response-no-clock.patch
new file mode 100644
index 000000000..619b07944
--- /dev/null
+++ b/wai/http-conformance/falsify/response-no-clock.patch
@@ -0,0 +1,15 @@
+# must fail: timed_OS_clock_never_ticked timed_OS_clock_ticked_0 timed_OS_clock_stepped_back
+# a response does not carry the clock, so the base is stamped with the last tick (session::FetchSession::on_response)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index ec31518e..8b35b343 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -463,7 +463,7 @@ impl FetchSession {
+     /// range requested are kept, whatever else a `200` carries: no refinement's response
+     /// touches its base's bytes.
+     pub fn on_response(&mut self, id: u32, meta: &ResponseMeta, body: &[u8], now_ms: u64) -> Result<(), RangeRefusal> {
+-        self.now_ms = now_ms;
++        let _ = now_ms;
+         if let Some(Err(e)) = &self.result {
+             return Err(e.clone());
+         }
diff --git a/wai/http-conformance/falsify/reuse-stale.patch b/wai/http-conformance/falsify/reuse-stale.patch
new file mode 100644
index 000000000..33949fc46
--- /dev/null
+++ b/wai/http-conformance/falsify/reuse-stale.patch
@@ -0,0 +1,15 @@
+# must fail: fetch_OD_stale fetch_OT_stale_small
+# bytes past covered_len are reused after a mismatch (session::advance_components)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index ec31518e..d7874048 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -728,7 +728,7 @@ impl FetchSession {
+                     self.abandoned.clear();
+                     self.dropped.clear();
+                     self.verified.clear();
+-                    self.drop_from(head.covered_len());
++                    let _ = head.covered_len();
+                     self.to_rest(&head, WhyWhole::DigestMismatch { index: i }, Class::Base);
+                     return self.advance_rest();
+                 }
diff --git a/wai/http-conformance/falsify/run.sh b/wai/http-conformance/falsify/run.sh
new file mode 100755
index 000000000..55437a71c
--- /dev/null
+++ b/wai/http-conformance/falsify/run.sh
@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+# Falsify the HTTP corpus tool: each patch here breaks one function of wai-rs. For each,
+# in a fresh worktree of HEAD: apply it, require the build to succeed, and require
+# `wai_http_vectors verify` to exit non-zero and to name every case the patch's first
+# line lists. Then the Python side: each `http_verify.py --mutate` must fail, and the
+# differential must verify every proof and refuse exactly the flipped ones.
+#
+#   bash wai/http-conformance/falsify/run.sh [work-dir [patch-name…]]
+#
+# With patch names, only those patches run (and nothing else).
+# Run from the repository root. CARGO_TARGET_DIR, if set, is shared by the builds.
+set -uo pipefail
+ROOT="$(git rev-parse --show-toplevel)"
+WORK="${1:-${RUNNER_TEMP:-/tmp}/wai-http-falsify}"
+shift || true
+ONLY="$*"
+mkdir -p "$WORK"
+fail=0
+for patch in "$ROOT"/wai/http-conformance/falsify/*.patch; do
+  name="$(basename "$patch" .patch)"
+  if [ -n "$ONLY" ] && ! printf ' %s ' $ONLY | grep -q " $name "; then continue; fi
+  wt="$WORK/f-$name"
+  rm -rf "$wt"
+  git -C "$ROOT" worktree add --detach --quiet "$wt" HEAD
+  must="$(head -1 "$patch" | sed 's/^# must fail: //')"
+  if ! git -C "$wt" apply "$patch"; then
+    echo "::error::$name: the patch does not apply"; fail=1
+  elif ! (cd "$wt/wai/wai-rs" && cargo build --release --no-default-features --features http --bin wai_http_vectors) > "$WORK/$name.build.log" 2>&1; then
+    echo "::error::$name: the patched tree does not build"; tail -20 "$WORK/$name.build.log"; fail=1
+  else
+    bin="${CARGO_TARGET_DIR:-$wt/wai/wai-rs/target}/release/wai_http_vectors"
+    "$bin" verify "$wt/wai/http-conformance" > "$WORK/$name.verify.log" 2>&1
+    rc=$?
+    missing=""
+    for c in $must; do grep -q "^FAIL $c:" "$WORK/$name.verify.log" || missing="$missing $c"; done
+    if [ $rc -eq 0 ] || [ -n "$missing" ]; then
+      echo "::error::$name: verify exited $rc; cases not failed:$missing"; fail=1
+    else
+      echo "ok  $name: verify exited $rc and failed$(printf ' %s' $must) ($(grep -c '^FAIL' "$WORK/$name.verify.log") failures)"
+    fi
+  fi
+  git -C "$ROOT" worktree remove --force "$wt"
+done
+
+[ -n "$ONLY" ] && exit $fail
+cd "$ROOT/wai/http-conformance"
+for m in left-half no-root counter-zero floor-as-codecs blake3-iv base-at-done tick-noop refinement-unclipped; do
+  if python3 http_verify.py . --mutate "$m" > "$WORK/py-$m.log" 2>&1; then
+    echo "::error::http_verify.py --mutate $m passed"; fail=1
+  else
+    echo "ok  http_verify.py --mutate $m: $(grep -c '^FAIL' "$WORK/py-$m.log") failures"
+  fi
+done
+# The differential runs the unpatched tool: build it again (the patched builds shared
+# its output path).
+(cd "$ROOT/wai/wai-rs" && cargo build --release --no-default-features --features http --bin wai_http_vectors) > "$WORK/unpatched.build.log" 2>&1 || fail=1
+bin="${CARGO_TARGET_DIR:-$ROOT/wai/wai-rs/target}/release/wai_http_vectors"
+if [ -x "$bin" ]; then
+  "$bin" diff . --seed 7 --count 500 --out "$WORK/diff.jsonl" > /dev/null || fail=1
+  python3 http_verify.py diff "$WORK/diff.jsonl" || fail=1
+  python3 http_verify.py diff "$WORK/diff.jsonl" --flip 10 --seed 3 || fail=1
+else
+  echo "::error::no release wai_http_vectors at $bin for the differential"; fail=1
+fi
+exit $fail
diff --git a/wai/http-conformance/falsify/select-no-digest.patch b/wai/http-conformance/falsify/select-no-digest.patch
new file mode 100644
index 000000000..fbd77188b
--- /dev/null
+++ b/wai/http-conformance/falsify/select-no-digest.patch
@@ -0,0 +1,15 @@
+# must fail: select_O7
+# selection does not test the payload digest (container::select_entries)
+diff --git a/wai/wai-rs/src/container.rs b/wai/wai-rs/src/container.rs
+index aeb5d235..7fefc8da 100644
+--- a/wai/wai-rs/src/container.rs
++++ b/wai/wai-rs/src/container.rs
+@@ -2670,7 +2670,7 @@ pub fn select_entries<V>(
+             skipped.push((index, why));
+             continue;
+         }
+-        if !digest_ok(index, meta) {
++        if false && !digest_ok(index, meta) {
+             skipped.push((index, Skip::ComponentDigest));
+             continue;
+         }
diff --git a/wai/http-conformance/falsify/skip-digest.patch b/wai/http-conformance/falsify/skip-digest.patch
new file mode 100644
index 000000000..9c2a50104
--- /dev/null
+++ b/wai/http-conformance/falsify/skip-digest.patch
@@ -0,0 +1,15 @@
+# must fail: fetch_O7
+# a fetched component is not checked against its sha256 (session::check_component)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 05e6cb08..7d4e3b38 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -181,7 +181,7 @@ pub fn check_response(req: Option<ByteRange>, r: &ResponseMeta, body_len: u64, e
+ 
+ /// Whether `bytes` match entry `index`'s `sha256` in `m`; false when it states none.
+ fn check_component(m: &ManifestV2, index: usize, bytes: &[u8]) -> bool {
+-    m.renditions.get(index).is_some_and(|e| e.sha256.is_some() && e.payload_digest_matches(bytes))
++    m.renditions.get(index).is_some()
+ }
+ 
+ enum Stage {
diff --git a/wai/http-conformance/falsify/skip-on-absent.patch b/wai/http-conformance/falsify/skip-on-absent.patch
new file mode 100644
index 000000000..702aa7b4d
--- /dev/null
+++ b/wai/http-conformance/falsify/skip-on-absent.patch
@@ -0,0 +1,15 @@
+# must fail: plan_no_digest_O4 fetch_O4
+# a base component with no sha256 is fetched by range (plan::plan_components)
+diff --git a/wai/wai-rs/src/http_binding/plan.rs b/wai/wai-rs/src/http_binding/plan.rs
+index 42c4bf47..c5dbc3ed 100644
+--- a/wai/wai-rs/src/http_binding/plan.rs
++++ b/wai/wai-rs/src/http_binding/plan.rs
+@@ -149,7 +149,7 @@ pub fn plan_components(
+     let mut plan = Plan { requests: Vec::new(), whole_rest: None, dropped: Vec::new() };
+     let Some(rest) = rest_of(head) else { return plan };
+     let has_digest = |i: usize| digests_present.get(i).copied().unwrap_or(false);
+-    if let Some(&(index, _)) = wanted.iter().find(|&&(i, c)| c == Class::Base && !has_digest(i)) {
++    if let Some(&(index, _)) = wanted.iter().find(|_| false) {
+         plan.whole_rest = Some((rest, WhyWhole::DigestAbsent { index }));
+         return plan;
+     }
diff --git a/wai/http-conformance/falsify/threshold-all.patch b/wai/http-conformance/falsify/threshold-all.patch
new file mode 100644
index 000000000..1825c92bc
--- /dev/null
+++ b/wai/http-conformance/falsify/threshold-all.patch
@@ -0,0 +1,15 @@
+# must fail: plan_OS_base_only_threshold fetch_OS_threshold_stall
+# refinement bytes count toward the threshold (plan::plan_components)
+diff --git a/wai/wai-rs/src/http_binding/plan.rs b/wai/wai-rs/src/http_binding/plan.rs
+index 42c4bf47..4d021ecd 100644
+--- a/wai/wai-rs/src/http_binding/plan.rs
++++ b/wai/wai-rs/src/http_binding/plan.rs
+@@ -172,7 +172,7 @@ pub fn plan_components(
+             _ => merged.push((class, a, b)),
+         }
+     }
+-    let base: u128 = merged.iter().filter(|(c, _, _)| *c == Class::Base).map(|(_, a, b)| u128::from(b - a)).sum();
++    let base: u128 = merged.iter().map(|(_, a, b)| u128::from(b - a)).sum();
+     if base * 1000 >= u128::from(policy.full_threshold_permille) * u128::from(rest.len()) && base > 0 {
+         plan.whole_rest = Some((rest, WhyWhole::Threshold));
+         plan.dropped.clear();
diff --git a/wai/http-conformance/falsify/tick-noop.patch b/wai/http-conformance/falsify/tick-noop.patch
new file mode 100644
index 000000000..0d66a06a5
--- /dev/null
+++ b/wai/http-conformance/falsify/tick-noop.patch
@@ -0,0 +1,16 @@
+# must fail: timed_OS_base_ready_first timed_OS_clock_never_ticked timed_OS_clock_saturates
+# tick never abandons a refinement past its deadline (session::FetchSession::tick)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index ec31518e..6a10e5a6 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -397,6 +397,9 @@ impl FetchSession {
+     /// the end of `u64` gives a deadline at `u64::MAX`.
+     pub fn tick(&mut self, now_ms: u64) -> Vec<u32> {
+         self.now_ms = now_ms;
++        if self.policy.refinement_deadline_ms.is_some() {
++            return Vec::new();
++        }
+         let (Some(at), Some(d)) = (self.base_ready_at(), self.policy.refinement_deadline_ms) else { return Vec::new() };
+         if self.result.is_some() || now_ms < at.saturating_add(u64::from(d)) {
+             return Vec::new();
diff --git a/wai/http-conformance/falsify/trust-content-range.patch b/wai/http-conformance/falsify/trust-content-range.patch
new file mode 100644
index 000000000..a43d4b970
--- /dev/null
+++ b/wai/http-conformance/falsify/trust-content-range.patch
@@ -0,0 +1,15 @@
+# must fail: response_wrong_range
+# Content-Range is not compared with the request (session::check_response)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 4730c192..6cd93bea 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -221,7 +221,7 @@ pub fn check_response(req: Option<ByteRange>, r: &ResponseMeta, body_len: u64, e
+             let (a, b) = span.split_once('-').ok_or_else(mismatch)?;
+             let (a, b) = (digits(a).ok_or_else(mismatch)?, digits(b).ok_or_else(mismatch)?);
+             let expect_last = want.last.min(envelope_len.saturating_sub(1));
+-            if a != want.first || b != expect_last || b < a || (b - a).checked_add(1) != Some(body_len) {
++            if b < a || (b - a).checked_add(1) != Some(body_len) {
+                 return Err(mismatch());
+             }
+             match digits(complete) {
diff --git a/wai/http-conformance/falsify/union-no-layer.patch b/wai/http-conformance/falsify/union-no-layer.patch
new file mode 100644
index 000000000..fd3392a45
--- /dev/null
+++ b/wai/http-conformance/falsify/union-no-layer.patch
@@ -0,0 +1,15 @@
+# must fail: union_O10_layers
+# a layer joins no alt (codecs::described)
+diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
+index 530ae822..161ed997 100644
+--- a/wai/wai-rs/src/http_binding/codecs.rs
++++ b/wai/wai-rs/src/http_binding/codecs.rs
+@@ -326,7 +326,7 @@ fn described(objects: &[SeqObject]) -> Result<Vec<Element>, CodecsError> {
+         let el = els[k].as_mut().expect("a base is not a layer");
+         let alt = el.alts.iter_mut().find(|a| a.cap == base_cap)
+             .ok_or_else(|| CodecsError::LayerUnbound(format!("wai.{cap}: its base's capability is not dispatched")))?;
+-        push_unique(&mut alt.plus, cap);
++        let _ = (alt, cap);
+     }
+     Ok(els.into_iter().flatten().collect())
+ }
diff --git a/wai/http-conformance/falsify/wai-prefix-case.patch b/wai/http-conformance/falsify/wai-prefix-case.patch
new file mode 100644
index 000000000..865e3c370
--- /dev/null
+++ b/wai/http-conformance/falsify/wai-prefix-case.patch
@@ -0,0 +1,15 @@
+# must fail: codecs_upper_prefix
+# an element beginning WAI is read as classical (codecs::is_wai_element)
+diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
+index 530ae822..cdc19410 100644
+--- a/wai/wai-rs/src/http_binding/codecs.rs
++++ b/wai/wai-rs/src/http_binding/codecs.rs
+@@ -156,7 +156,7 @@ pub fn parse_element(s: &str) -> Result<Element, CodecsError> {
+ /// any ASCII case. Such an element that is not a well-formed `wai1.` or `wai2.` element
+ /// is malformed, never classical.
+ fn is_wai_element(e: &str) -> bool {
+-    e.as_bytes().get(..3).is_some_and(|b| b.eq_ignore_ascii_case(b"wai"))
++    e.as_bytes().get(..3) == Some(&b"wai"[..])
+ }
+ 
+ /// Parse a `codecs` value: one entry per `,`-separated element, `None` for a
diff --git a/wai/http-conformance/falsify/whole-applies-no-digest.patch b/wai/http-conformance/falsify/whole-applies-no-digest.patch
new file mode 100644
index 000000000..634639e54
--- /dev/null
+++ b/wai/http-conformance/falsify/whole-applies-no-digest.patch
@@ -0,0 +1,15 @@
+# must fail: fetch_ORN_whole
+# the whole path applies a refinement that states no digest (session::FetchSession::advance_rest)
+diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
+index 47a906ec..c65b2871 100644
+--- a/wai/wai-rs/src/http_binding/session.rs
++++ b/wai/wai-rs/src/http_binding/session.rs
+@@ -816,7 +816,7 @@ impl FetchSession {
+                 for (i, class) in self.sel.applied(&w.manifest, index) {
+                     // A refinement that states no digest is dropped on this path as on the
+                     // range path (§7 step 5, §10.3).
+-                    if class == Class::Refinement && w.manifest.renditions[i].sha256.is_none() {
++                    if false && class == Class::Refinement && w.manifest.renditions[i].sha256.is_none() {
+                         dropped.push((i, WhyWhole::DigestAbsent { index: i }));
+                         continue;
+                     }
diff --git a/wai/http-conformance/http_verify.py b/wai/http-conformance/http_verify.py
new file mode 100644
index 000000000..5c9736f53
--- /dev/null
+++ b/wai/http-conformance/http_verify.py
@@ -0,0 +1,1439 @@
+#!/usr/bin/env python3
+"""Second verifier for http-conformance/ — HTTP delivery (extensions/http-delivery.md).
+
+Written from the extension text and SPEC §7.1. It shares no code with wai-rs, which
+generates the corpus: the head (§2, §5.1), covered_len, the head proof (§6), the
+response checks (§7.1), the plans and classes of the reference client (§7, §10.1), the
+byte-range procedure with its whole-object fallback (§7), the base presented as it
+verifies and the refinement deadline on the caller's clock (§10.1, §10.2), SPEC §7.1's selection with
+companions and refinements, the codecs grammar, union, floor and support (§4), all
+written here. BLAKE3 is ../claim-conformance/_blake3.py (written from its specification,
+shared with the other Python verifiers) and SHA-256 is hashlib. The registry's kinds,
+roles and classes are read from ../registry/capabilities.json, the published export.
+Only the standard library is needed.
+
+Pins (SPEC §3.1) are read as far as the corpus needs: a pin applies to a capability that
+decodes against a parameter set (registry class neural-int-exact, neural-entropy-exact,
+neural-float or generative-exact) or that the registry does not hold; a form-less pin
+resolves when the sink holds a file whose SHA-256 is the pin's; a pin in the set form
+resolves to nothing here, since the corpus's sinks hold no set listing. Any other shape
+stops the verifier, never passes.
+
+    python3 http_verify.py [dir]                       verify every case and the self-test
+    python3 http_verify.py [dir] --mutate NAME         the same with a deliberate defect:
+        left-half | no-root | counter-zero | floor-as-codecs | blake3-iv | base-at-done |
+        tick-noop | refinement-unclipped
+    python3 http_verify.py cases FILE [dir]
+        give every case of a case file (wai_http_vectors fuzz) its stated outcome
+    python3 http_verify.py diff FILE [--flip N --seed S]
+        verify every head proof `wai_http_vectors diff` wrote; with --flip, change one
+        chaining-value byte in N of them, chosen by S, and require exactly those refused
+
+Exit status 0 only when every case gives its committed outcome (or, for diff, every
+proof verifies, or exactly the flipped ones fail).
+"""
+import hashlib, json, os, random, re, sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, os.path.join(HERE, "..", "claim-conformance"))
+sys.path.insert(0, os.path.join(HERE, "..", "staged-conformance"))
+import _blake3 as B3  # noqa: E402
+import staged_verify as SV  # noqa: E402  (strict JSON, the manifest members, refines, explode)
+
+MUTATE = None
+DOMAIN = b"moq-jwp:object\x01"
+READABLE = ["wai.prior.set"]
+
+
+class Refusal(Exception):
+    def __init__(self, code, skipped=None):
+        super().__init__(code)
+        self.code, self.skipped = code, skipped
+
+
+def sha(b):
+    return hashlib.sha256(b).hexdigest()
+
+
+def blake3(b):
+    return B3.blake3(b)
+
+
+def content_hash(env):
+    return blake3(DOMAIN + env)
+
+
+# ------------------------------------------------------------------ the registry
+
+REG = {}
+
+
+def load_registry():
+    d = json.load(open(os.path.join(HERE, "..", "registry", "capabilities.json")))
+    for c in d["capabilities"]:
+        REG[c["capability"]] = c
+
+
+def kind(cap):
+    return REG[cap]["kind"] if cap in REG else None
+
+
+def candidate(cap):
+    return cap in REG and REG[cap]["status"] == "candidate"
+
+
+def dispatchable(cap):
+    k = kind(cap)
+    return k is None or (k == "payload" and not candidate(cap))
+
+
+def enhancement(cap):
+    return cap in REG and REG[cap]["role"] == "enhancement"
+
+
+def pin_applies(cap):
+    return cap not in REG or REG[cap]["replicate"] in ("neural-int-exact", "neural-entropy-exact", "neural-float", "generative-exact")
+
+
+# ---------------------------------------------------------------------- the head
+
+def u32(b, at):
+    return int.from_bytes(b[at:at + 4], "little")
+
+
+def read_manifest(b, v2):
+    """SPEC §2, §3, §7.1: the manifest read strictly, with the members SPEC requires and
+    their types (staged_verify's reader); `head_malformed` otherwise."""
+    try:
+        m = SV.strict_json(b)
+        (SV.check_manifest_v2 if v2 else SV.check_manifest_v1)(m)
+    except (SV.NotJSON, SV.Schema):
+        raise Refusal("head_malformed")
+    return m
+
+
+def parse_head(prefix, n):
+    """§2, §5.1: ("need", k) or a head dict; Refusal on a malformed or mis-sized object."""
+    if len(prefix) < 8:
+        return ("need", 8)
+    magic = prefix[:4]
+    if magic not in (b"WAI1", b"WAI2"):
+        raise Refusal("head_malformed")
+    ml = u32(prefix, 4)
+    if magic == b"WAI1":
+        head_len = 12 + ml
+        if len(prefix) < head_len:
+            return ("need", head_len)
+        comps = [(head_len, u32(prefix, 8 + ml))]
+    else:
+        if len(prefix) < 10 + ml:
+            return ("need", 10 + ml)
+        k = int.from_bytes(prefix[8 + ml:10 + ml], "little")
+        head_len = 10 + ml + 8 * k
+        if len(prefix) < head_len:
+            return ("need", head_len)
+        comps, expected = [], 0
+        for i in range(k):
+            off, ln = u32(prefix, 10 + ml + 8 * i), u32(prefix, 14 + ml + 8 * i)
+            if off != expected:
+                raise Refusal("head_malformed")
+            comps.append((head_len + off, ln))
+            expected += ln
+    if head_len + sum(c[1] for c in comps) != n:
+        raise Refusal("object_length_mismatch")
+    m = read_manifest(prefix[8:8 + ml], magic == b"WAI2")
+    if magic == b"WAI2" and len(m["renditions"]) != len(comps):
+        raise Refusal("head_malformed")
+    return {"version": magic.decode(), "head_len": head_len, "envelope_len": n, "components": comps, "manifest": m}
+
+
+def is_layer(h):
+    """§10.4: a WAI1 whose capability is refinement-only (staged delivery §3). A payload
+    capability that carries `refines` is an ordinary object: SPEC §4 dispatches it and
+    `refines` is not read."""
+    if h["version"] != "WAI1":
+        return False
+    return kind(h["manifest"]["model_requirement"]["capability"]) == "refinement"
+
+
+def whole_head(env):
+    """The head of a whole envelope; one shorter than its head is malformed."""
+    h = parse_head(env, len(env))
+    if isinstance(h, tuple):
+        raise Refusal("head_malformed")
+    return h
+
+
+def covered_len(head_len, n):
+    return min(n, 1024 * -(-(15 + head_len) // 1024) - 15)
+
+
+# ------------------------------------------------------------------ the head proof
+
+def left(n):
+    if MUTATE == "left-half":
+        return max(1, (n // 2) // 1024) * 1024
+    return 1024 * 2 ** ((((n - 1) // 1024)).bit_length() - 1)
+
+
+def merge(l, r, root):
+    if MUTATE == "no-root":
+        root = False
+    return B3.parent_cv(l, r, root)
+
+
+def subtree(x, start):
+    return B3.subtree_cv(x, 0 if MUTATE == "counter-zero" else start)
+
+
+def read_proof(b):
+    if len(b) < 53 or b[:4] != b"WHP1":
+        raise Refusal("head_proof_malformed")
+    k = b[52]
+    if k > 64 or len(b) != 53 + 32 * k:
+        raise Refusal("head_proof_malformed")
+    n, c = int.from_bytes(b[36:44], "little"), int.from_bytes(b[44:52], "little")
+    if n > 2 ** 64 - 1 - 15 or c > n:
+        raise Refusal("head_proof_malformed")
+    if not (c == n or (c < n and (15 + c) % 1024 == 0)) or (c == n and k):
+        raise Refusal("head_proof_malformed")
+    return {"cid": b[4:36], "n": n, "covered": c, "cvs": [b[53 + 32 * i:85 + 32 * i] for i in range(k)]}
+
+
+def verify_proof(p, cid, prefix):
+    """§6.3, checks 1-3, in order."""
+    if p["cid"] != cid or len(prefix) < p["covered"]:
+        raise Refusal("head_proof_malformed")
+    covered = prefix[:p["covered"]]
+    if p["covered"] == p["n"]:
+        if content_hash(covered) != cid:
+            raise Refusal("head_proof_mismatch")
+    else:
+        x, L, c = DOMAIN + covered, 15 + p["n"], 15 + p["covered"]
+        it = iter(p["cvs"])
+
+        def cv(start, ln):
+            if start >= c:
+                v = next(it, None)
+                if v is None:
+                    raise Refusal("head_proof_mismatch")
+                return v
+            if start + ln <= c:
+                return subtree(x[start:start + ln], start)
+            l = left(ln)
+            return merge(cv(start, l), cv(start + l, ln - l), False)
+
+        l = left(L)
+        root = merge(cv(0, l), cv(l, L - l), True)
+        if next(it, None) is not None or root != cid:
+            raise Refusal("head_proof_mismatch")
+    try:
+        h = parse_head(covered, p["n"])
+    except Refusal as e:
+        if e.code == "object_length_mismatch":
+            raise Refusal("head_proof_malformed")
+        raise
+    if isinstance(h, tuple) or covered_len(h["head_len"], p["n"]) != p["covered"]:
+        raise Refusal("head_proof_malformed")
+
+
+# ------------------------------------------------------------- responses (§7.1)
+
+DIGITS = re.compile(r"[0-9]+", re.ASCII)
+
+
+def digits(s):
+    """RFC 9110's 1*DIGIT: ASCII digits only, no sign, separator, space or other script."""
+    return int(s) if DIGITS.fullmatch(s) else None
+
+
+def check_response(req, status, cr, enc, body_len, n):
+    coded = enc is not None and enc.strip() and enc.strip().lower() != "identity"
+    if status == 206:
+        if req is None:
+            raise Refusal("http_status_unexpected")
+        if coded:
+            raise Refusal("content_coding_present")
+        field = (cr or "").strip(" \t")
+        if not field.startswith("bytes ") or "/" not in field:
+            raise Refusal("content_range_mismatch")
+        span, complete = field[len("bytes "):].split("/", 1)
+        if "-" not in span:
+            raise Refusal("content_range_mismatch")
+        a, b = span.split("-", 1)
+        a, b = digits(a), digits(b)
+        if a is None or b is None or a != req[0] or b != min(req[1], max(n - 1, 0)) or b < a or body_len != b - a + 1:
+            raise Refusal("content_range_mismatch")
+        if digits(complete) != n:
+            raise Refusal("complete_length_mismatch")
+        return (a, b)
+    if status == 200:
+        if coded:
+            raise Refusal("content_coding_present")
+        if body_len != n or n == 0:
+            raise Refusal("complete_length_mismatch")
+        return (0, n - 1)
+    raise Refusal("http_status_unexpected")
+
+
+def origin_serve(n, rng):
+    """An origin's answer to a Range header on n bytes (RFC 9110 §14), as the corpus's
+    origin gives it: (status, Content-Range, first, end)."""
+    if rng is None or not rng.startswith("bytes=") or "," in rng:
+        return 200, None, 0, n
+    a, b = rng[len("bytes="):].split("-")
+    if a == "":
+        s = int(b)
+        return 206, "bytes %d-%d/%d" % (max(0, n - s), n - 1, n), max(0, n - s), n
+    first = int(a)
+    last = n - 1 if b == "" else min(int(b), n - 1)
+    if first >= n:
+        return 416, "bytes */%d" % n, 0, 0
+    return 206, "bytes %d-%d/%d" % (first, last, n), first, last + 1
+
+
+# ------------------------------------------------------------------ selection
+
+def selectable(e):
+    return e.get("role") not in ("companion", "refinement") and dispatchable(e["capability"])
+
+
+def resolve_pin(cap, prior, held):
+    if not isinstance(prior, dict) or "sha256" not in prior:
+        raise SystemExit("http_verify: a pin shape this verifier does not read")
+    form = prior.get("form")
+    if form is None:
+        return "ok" if any(sha(h) == prior["sha256"] for h in held) else "prior_not_held"
+    if form in READABLE:
+        return "prior_not_held"
+    raise SystemExit("http_verify: a pin form this verifier does not read")
+
+
+def plaintext_v2(m):
+    """SPEC §6.4 step 2 for a WAI2: `security` absent or null, or an object whose
+    `encryption` is absent, null or "none"; a member that is not a security object (a
+    string, `true`, a mistyped member) means the payloads cannot be read here."""
+    sec = m.get("security")
+    if sec is None:
+        return True
+    if not isinstance(sec, dict):
+        return False
+    enc, kid = sec.get("encryption"), sec.get("kid")
+    if enc is not None and not isinstance(enc, str):
+        return False
+    if kid is not None and not SV.a_u64(kid):
+        return False
+    return enc in (None, "none")
+
+
+def select(m, order, adv, held, digest_ok):
+    """SPEC §7.1 step 2 in `order`: (pick, skipped) or Refusal('inert', skipped)."""
+    entries, skipped = m["renditions"], []
+    if not plaintext_v2(m):
+        raise Refusal("inert", [[i, "unsupported_encryption"] for i in range(len(entries))])
+    for i in order:
+        if i >= len(entries):
+            continue
+        e = entries[i]
+        if not selectable(e):
+            skipped.append([i, "not_selectable"]); continue
+        if e["capability"] not in adv:
+            skipped.append([i, "missing_capability"]); continue
+        if not digest_ok(i, e):
+            skipped.append([i, "component_digest_mismatch"]); continue
+        if e.get("prior") is not None and pin_applies(e["capability"]):
+            r = resolve_pin(e["capability"], e["prior"], held)
+            if r != "ok":
+                skipped.append([i, r]); continue
+        return i, skipped
+    raise Refusal("inert", skipped)
+
+
+def dispatch_wai1(m, adv, held):
+    """SPEC §4 with §6.4 step 2 first: an encrypted payload is inert at a sink that
+    opens no scheme."""
+    sec = m.get("security")
+    if sec is not None and sec.get("encryption") not in (None, "none"):
+        raise Refusal("inert", [[0, "unsupported_encryption"]])
+    mr = m["model_requirement"]
+    cap, fb = mr["capability"], mr.get("fallback")
+    if kind(cap) in ("companion", "refinement"):
+        raise Refusal("inert", [[0, "missing_capability"]])
+    first = None
+    for c in [cap, fb]:
+        if c is None or not dispatchable(c) or c not in adv:
+            continue
+        p = m.get("conditioning", {}).get("prior")
+        if p is not None and pin_applies(c):
+            r = resolve_pin(c, p, held)
+            if r == "ok":
+                return 0
+            first = first or r
+            continue
+        return 0
+    raise Refusal("inert", [[0, first or "missing_capability"]])
+
+
+def companions_of(entries, i):
+    base = entries[i]
+    out = []
+    for j, e in enumerate(entries):
+        if e.get("role") != "companion":
+            continue
+        cid = e.get("companion_of_id")
+        if (cid is not None and base.get("id") == cid) or (cid is None and e.get("companion_of") == base["capability"]):
+            out.append(j)
+    return out
+
+
+def refinements_of(entries, i):
+    """The refinement components whose well-formed `refines` (staged-delivery §3, ids in
+    place of hashes) names entry i's id as its base."""
+    bid = entries[i].get("id")
+    if bid is None:
+        return []
+    out = []
+    for j, e in enumerate(entries):
+        if e.get("role") != "refinement":
+            continue
+        try:
+            if SV.parse_refines_ids(e.get("refines"))["base"] == bid:
+                out.append(j)
+        except (SV.Malformed, KeyError, TypeError):
+            pass
+    return out
+
+
+def payload_ok(e, payload):
+    return e.get("sha256") is None or e["sha256"] == sha(payload)
+
+
+# ------------------------------------------------------------------- the plan
+
+def plan(head, wanted, held, permille):
+    """§7 steps 5-6 and the threshold, over base-class bytes only:
+    ("rest", (first, last), why) or ("ranges", [...], dropped)."""
+    n, cov = head["envelope_len"], covered_len(head["head_len"], head["envelope_len"])
+    if cov == n:
+        return ("ranges", [], [])
+    rest = (cov, n - 1)
+    entries = head["manifest"]["renditions"]
+    for i, cl in wanted:
+        if cl == "base" and entries[i].get("sha256") is None:
+            return ("rest", rest, "component_digest_absent")
+    pieces, dropped = [], []
+    for i, cl in wanted:
+        if entries[i].get("sha256") is None:
+            dropped.append([i, "component_digest_absent"])
+            continue
+        s, ln = head["components"][i]
+        segs = [(s, s + ln)]
+        for (hf, hl) in held:
+            nxt = []
+            for a, b in segs:
+                hs, he = hf, hl + 1
+                if he <= a or hs >= b:
+                    nxt.append((a, b)); continue
+                if a < hs:
+                    nxt.append((a, hs))
+                if he < b:
+                    nxt.append((he, b))
+            segs = nxt
+        pieces += [(0 if cl == "base" else 1, a, b) for a, b in segs]
+    pieces.sort()
+    merged = []
+    for c, a, b in pieces:
+        if merged and merged[-1][0] == c and merged[-1][2] >= a:
+            merged[-1][2] = max(merged[-1][2], b)
+        else:
+            merged.append([c, a, b])
+    base = sum(b - a for c, a, b in merged if c == 0)
+    if base > 0 and base * 1000 >= permille * (n - cov):
+        return ("rest", rest, "range_threshold")
+    return ("ranges", [(a, b - 1, "base" if c == 0 else "refinement") for c, a, b in merged if b > a], dropped)
+
+
+# ---------------------------------------------------------------- the codecs
+
+def cap_ok(cap):
+    parts = cap.split(".")
+    lc = lambda s, extra="": s and all(ch in "abcdefghijklmnopqrstuvwxyz0123456789" + extra for ch in s)
+    return len(parts) >= 2 and lc(parts[0]) and all(lc(p, "_") for p in parts[1:])
+
+
+def check_cap(c, first):
+    if not cap_ok(c):
+        raise Refusal("codecs_malformed")
+    full = "wai." + c
+    k = kind(full)
+    if k in ("derivation", "record"):
+        raise Refusal("codecs_not_media")
+    if candidate(full):
+        raise Refusal("codecs_candidate")
+    if first and k in ("companion", "refinement"):
+        raise Refusal("codecs_malformed")
+    if not first and k == "payload":
+        raise Refusal("codecs_malformed")
+
+
+def check_alt(alt):
+    for i, c in enumerate(alt):
+        check_cap(c, i == 0)
+
+
+def parse_element(s):
+    if "." not in s:
+        raise Refusal("codecs_malformed")
+    prefix, rest = s.split(".", 1)
+    if prefix not in ("wai1", "wai2"):
+        raise Refusal("codecs_malformed")
+    alts = []
+    for a in rest.split("|"):
+        alt = a.split("+")
+        check_alt(alt)
+        if len(set(alt)) != len(alt) or any(x[0] == alt[0] for x in alts):
+            raise Refusal("codecs_malformed")
+        alts.append(alt)
+    return (prefix, alts)
+
+
+def render(e):
+    return e[0] + "." + "|".join("+".join(a) for a in e[1])
+
+
+def parse_codecs(value):
+    out = []
+    for e in (x.strip(" \t") for x in value.split(",")):
+        if e == "":
+            raise Refusal("codecs_malformed")
+        if e.encode("utf-8")[:3].lower() == b"wai":
+            out.append(render(parse_element(e)))
+        else:
+            out.append(None)
+    return out
+
+
+def short(c):
+    return c[4:] if c.startswith("wai.") else c
+
+
+def element_of(head):
+    if is_layer(head):
+        raise Refusal("codecs_malformed")
+    m = head["manifest"]
+    if head["version"] == "WAI1":
+        mr = m["model_requirement"]
+        alts, prefix = [], "wai1"
+        for c in [mr["capability"], mr.get("fallback")]:
+            if c is not None and dispatchable(c) and short(c) not in [a[0] for a in alts]:
+                alts.append([short(c)])
+    else:
+        e, alts, prefix = m["renditions"], [], "wai2"
+        for i, r in enumerate(e):
+            if not selectable(r):
+                continue
+            cap = short(r["capability"])
+            a = next((x for x in alts if x[0] == cap), None)
+            if a is None:
+                a = [cap]; alts.append(a)
+            for j in sorted(companions_of(e, i) + refinements_of(e, i)):
+                p = short(e[j]["capability"])
+                if p not in a[1:]:
+                    a.append(p)
+        pos = lambda p: next(k for k, r in enumerate(e) if short(r["capability"]) == p)
+        alts = [[a[0]] + sorted(a[1:], key=pos) for a in alts]
+    if not alts:
+        raise Refusal("codecs_not_media")
+    for a in alts:
+        check_alt(a)
+    return (prefix, alts)
+
+
+def seq_object(env):
+    h = whole_head(env)
+    comps = []
+    if h["version"] == "WAI2":
+        try:
+            comps = [content_hash(x).hex() if x is not None else None for x in SV.explode_each(env)]
+        except (SV.NotWai2, SV.NotJSON, SV.Schema, ValueError, KeyError):
+            comps = []
+    return {"cid": content_hash(env).hex(), "head": h, "components": comps}
+
+
+def base_capability(b, base):
+    """The capability through which object b is the base whose content hash is `base`: a
+    WAI1's capability when its cid is `base`, or the capability of the selectable component
+    of a WAI2 whose exploded envelope has that hash; None otherwise (§4.2)."""
+    if is_layer(b["head"]):
+        return None
+    if b["cid"] == base and b["head"]["version"] == "WAI1":
+        return short(b["head"]["manifest"]["model_requirement"]["capability"])
+    if base in b["components"]:
+        r = b["head"]["manifest"]["renditions"][b["components"].index(base)]
+        return short(r["capability"]) if selectable(r) else None
+    return None
+
+
+def described(objects):
+    els = [None if is_layer(o["head"]) else element_of(o["head"]) for o in objects]
+    for o in objects:
+        if not is_layer(o["head"]):
+            continue
+        m = o["head"]["manifest"]
+        cap = short(m["model_requirement"]["capability"])
+        check_cap(cap, False)
+        try:
+            base = SV.parse_refines(m.get("refines"))["base"]
+        except SV.Malformed:
+            raise Refusal("codecs_malformed")
+        target = None
+        for k, b in enumerate(objects):
+            bc = base_capability(b, base)
+            if bc is not None:
+                target = (k, bc)
+                break
+        if target is None:
+            raise Refusal("codecs_layer_unbound")
+        alt = next((a for a in els[target[0]][1] if a[0] == target[1]), None)
+        if alt is None:
+            raise Refusal("codecs_layer_unbound")
+        if cap not in alt[1:]:
+            alt.append(cap)
+    return [e for e in els if e is not None]
+
+
+def union_of(objects):
+    if MUTATE == "floor-as-codecs":
+        return floor_of(objects)
+    each = described(objects)
+    prefix = "wai2" if any(o["head"]["version"] == "WAI2" for o in objects) else "wai1"
+    alts = []
+    for p, al in each:
+        for a in al:
+            x = next((x for x in alts if x[0] == a[0]), None)
+            if x is None:
+                alts.append(list(a))
+            else:
+                x += [c for c in a[1:] if c not in x[1:]]
+    if not alts:
+        raise Refusal("codecs_no_common_capability")
+    return (prefix, alts)
+
+
+def floor_of(objects):
+    each = described(objects)
+    prefix = "wai2" if any(o["head"]["version"] == "WAI2" for o in objects) else "wai1"
+    seen = []
+    for e in each:
+        for a in e[1]:
+            x = next((s for s in seen if s[0] == a[0]), None)
+            if x is None:
+                seen.append(list(a))
+            else:
+                x += [c for c in a[1:] if c not in x[1:]]
+    out = []
+    for a in seen:
+        found = [next((x for x in e[1] if x[0] == a[0]), None) for e in each]
+        if any(f is None for f in found):
+            continue
+        out.append([a[0]] + [c for c in a[1:] if all(c in f[1:] for f in found)])
+    if not out:
+        raise Refusal("codecs_no_common_capability")
+    return (prefix, out)
+
+
+def check_declared(head, union, base):
+    """§4.2: a layer is declared only after `+` in the alt of its own base's capability,
+    the base (`base`, a sequence object) being the one its `refines.base` names."""
+    if is_layer(head):
+        m = head["manifest"]
+        cap = short(m["model_requirement"]["capability"])
+        try:
+            named = SV.parse_refines(m.get("refines"))["base"]
+        except SV.Malformed:
+            raise Refusal("codecs_undeclared")
+        bc = base_capability(base, named) if base is not None else None
+        if bc is None or not any(a[0] == bc and cap in a[1:] for a in union[1]):
+            raise Refusal("codecs_undeclared")
+        return
+    p, alts = element_of(head)
+    if p > union[0]:
+        raise Refusal("codecs_undeclared")
+    for a in alts:
+        u = next((x for x in union[1] if x[0] == a[0]), None)
+        if u is None or any(c not in u[1:] for c in a[1:]):
+            raise Refusal("codecs_undeclared")
+
+
+def supports(floor, containers, caps):
+    reads = "WAI1" in containers and (floor[0] == "wai1" or "WAI2" in containers)
+    return reads and any(("wai." + a[0]) in caps for a in floor[1])
+
+
+def parse_layer_tag(line):
+    """§10.4's #WAI-LAYER line, as an HLS attribute list."""
+    bad = Refusal("layer_tag_malformed")
+    if not line.startswith("#WAI-LAYER:"):
+        raise bad
+    rest = line[len("#WAI-LAYER:"):].encode("utf-8")
+    n, uri, names = None, None, []
+    while True:
+        eq = rest.find(b"=")
+        if eq < 0:
+            raise bad
+        name = rest[:eq]
+        if not name or not re.fullmatch(rb"[A-Z0-9-]+", name) or name in names:
+            raise bad
+        names.append(name)
+        rest = rest[eq + 1:]
+        if rest[:1] == b'"':
+            close = rest.find(b'"', 1)
+            if close < 0:
+                raise bad
+            value, quoted, after = rest[1:close], True, rest[close + 1:]
+            if b"\r" in value or b"\n" in value:
+                raise bad
+        else:
+            end = rest.find(b",")
+            end = len(rest) if end < 0 else end
+            value, quoted, after = rest[:end], False, rest[end:]
+            if not value or b'"' in value or re.search(rb"[ \t\n\r\x0b\x0c]", value):
+                raise bad
+        if name == b"N":
+            if quoted or len(value) > 3 or not re.fullmatch(rb"[0-9]+", value) or not 1 <= int(value) <= 255:
+                raise bad
+            n = int(value)
+        elif name == b"URI":
+            if not quoted:
+                raise bad
+            try:
+                uri = value.decode("utf-8")
+            except UnicodeDecodeError:
+                raise bad
+        if not after:
+            break
+        if after[:1] != b",":
+            raise bad
+        rest = after[1:]
+    if n is None or uri is None:
+        raise bad
+    return {"n": n, "uri": uri}
+
+
+# ------------------------------------------------------------- the session (§7)
+
+class Session:
+    """The reference client of §7, step by step as the requests are answered: it says
+    which requests to make, checks each response, and decides as each arrives."""
+
+    def __init__(self, cid, frag, permille, sink, layer=False, deadline=None):
+        self.cid, self.frag, self.permille, self.sink, self.deadline = cid, frag, permille, sink, deadline
+        self.next_id, self.queued, self.issued, self.early = 0, [], {}, []
+        self.proof, self.held, self.head, self.stage = None, [], None, ("head",)
+        self.abandoned, self.dropped, self.body, self.requests, self.result = [], [], 0, 0, None
+        # §10.1, §10.2: the caller's clock as last given; the base once it verified, with
+        # the time of the response that verified it; each verified component, frozen.
+        self.now, self.base, self.base_at, self.verified = 0, None, None, {}
+        if layer:
+            self.stage = ("layer",)
+            self.queue(("whole", "refinement"))
+            return
+        n = frag.get("n")
+        if n is not None and n < 1009:
+            self.stage = ("rest", "below_one_chunk", "base")
+            self.queue(("whole", "base"))
+            return
+        e = frag.get("h") or 16369
+        if n is not None:
+            e = min(e, n)
+        self.queue(("range", (0, e - 1), "base"))
+        self.queue(("proof",))
+
+    @staticmethod
+    def cls(w):
+        return "base" if w[0] == "proof" else w[-1]
+
+    def queue(self, w):
+        self.queued.append((self.next_id, w)); self.next_id += 1
+
+    def wants(self):
+        out, self.queued = self.queued, []
+        for i, w in out:
+            self.issued[i] = w
+            self.requests += 1
+        return out
+
+    def finish(self, r):
+        self.stage, self.queued, self.result = ("done",), [], r
+
+    def abandon(self, w):
+        st = self.stage[0]
+        if st == "layer" or (st == "rest" and self.stage[2] == "refinement"):
+            if 0 not in self.abandoned:
+                self.abandoned.append(0)
+        elif st == "components" and w[0] == "range" and w[2] == "refinement":
+            (a, b) = w[1]
+            for i, cl in self.stage[3]:
+                s, ln = self.head["components"][i]
+                if cl == "refinement" and s <= b and a < s + ln and i not in self.abandoned:
+                    self.abandoned.append(i)
+
+    def on_deadline(self, i):
+        if self.result is not None:
+            return
+        w = self.issued.get(i)
+        if w is not None and self.cls(w) == "refinement":
+            del self.issued[i]
+            self.abandon(w)
+            self.advance()
+
+    def base_ready(self):
+        if self.base is not None:
+            return self.base
+        return self.result if self.result is not None and "error" not in self.result else None
+
+    def tick(self, now):
+        """§10.2: the deadline runs from the response that verified the base; the sum
+        saturates at the end of u64, and a clock that steps back has not passed it."""
+        self.now = now
+        if self.base_at is None or self.deadline is None or MUTATE == "tick-noop":
+            return []
+        if self.result is not None or now < min(self.base_at + self.deadline, 2 ** 64 - 1):
+            return []
+        ids = sorted(i for i, w in self.issued.items() if self.cls(w) == "refinement")
+        for i in ids:
+            self.on_deadline(i)
+        return ids
+
+    def on_response(self, i, status, cr, enc, body, now):
+        self.now = now
+        if self.result is not None and "error" in self.result:
+            raise Refusal(self.result["error"], self.result.get("skipped"))
+        w = self.issued.pop(i, None)
+        if w is None or self.result is not None:
+            return
+        self.body += len(body)
+        try:
+            self.take(w, status, cr, enc, body)
+            self.advance()
+        except Refusal as e:
+            self.finish(refusal(e))
+            raise
+
+    def n(self):
+        return self.proof["n"] if self.proof else None
+
+    def take(self, w, status, cr, enc, body):
+        if w[0] == "proof":
+            if status != 200:
+                raise Refusal("http_status_unexpected")
+            if enc is not None and enc.strip() and enc.strip().lower() != "identity":
+                raise Refusal("content_coding_present")
+            p = read_proof(body)
+            if p["cid"] != self.cid:
+                raise Refusal("head_proof_malformed")
+            self.proof = p
+            early, self.early = self.early, []
+            for x in early:
+                self.take(*x)
+            return
+        if w[0] == "whole":
+            try:
+                check_response(None, status, cr, enc, len(body), len(body))
+            except Refusal:
+                if w[1] == "refinement":
+                    self.abandon(w); return
+                raise
+            if content_hash(body) != self.cid:
+                raise Refusal("object_digest_mismatch")
+            if body:
+                self.held.append((0, len(body) - 1, body))
+            return
+        if self.proof is None:
+            self.early.append((w, status, cr, enc, body)); return
+        try:
+            a, b = check_response(w[1], status, cr, enc, len(body), self.n())
+        except Refusal:
+            if w[2] == "refinement":
+                self.abandon(w); return
+            raise
+        if w[2] == "refinement" and MUTATE != "refinement-unclipped":
+            # A refinement's response adds the bytes it asked for and no others (§10.1).
+            first, last = max(a, w[1][0]), min(b, w[1][1])
+            if first <= last:
+                self.held.append((first, last, body[first - a:last + 1 - a]))
+            return
+        self.held.append((a, b, body))
+
+    def have(self, first, end):
+        out, at = b"", first
+        while at < end:
+            best = max((h for h in self.held if h[0] <= at <= h[1]), key=lambda h: h[1], default=None)
+            if best is None:
+                return None
+            take = min(best[1] + 1, end)
+            out += best[2][at - best[0]:take - best[0]]
+            at = take
+        return out
+
+    def drop_from(self, frm):
+        kept = []
+        for a, b, body in self.held:
+            if a >= frm:
+                continue
+            kept.append((a, b, body) if b < frm else (a, frm - 1, body[:frm - a]))
+        self.held = kept
+
+    def prefix_len(self):
+        at = 0
+        while True:
+            e = max((h[1] + 1 for h in self.held if h[0] <= at <= h[1]), default=None)
+            if e is None:
+                return at
+            at = e
+
+    def advance(self):
+        if self.result is not None:
+            return
+        st = self.stage[0]
+        if st == "head":
+            self.advance_head()
+        elif st == "components":
+            self.advance_components()
+        elif st in ("rest", "layer"):
+            self.advance_rest()
+
+    def to_rest(self, why, cl):
+        self.stage = ("rest", why, cl)
+        n, cov = self.head["envelope_len"], covered_len(self.head["head_len"], self.head["envelope_len"])
+        if cov < n and self.have(cov, n) is None:
+            self.queue(("rest", (cov, n - 1), cl))
+
+    def applied(self, entries, pick):
+        adv, applies = self.sink[0], self.sink[1]
+        out = [(j, "refinement" if enhancement(entries[j]["capability"]) else "base")
+               for j in companions_of(entries, pick) if entries[j]["capability"] in applies]
+        out += [(j, "refinement") for j in refinements_of(entries, pick) if entries[j]["capability"] in applies]
+        return out
+
+    def advance_head(self):
+        if self.proof is None:
+            return
+        cov = self.proof["covered"]
+        h0 = self.prefix_len()
+        if h0 < cov:
+            pending = [w for w in list(self.issued.values()) + [w for _, w in self.queued] if w[0] in ("range", "rest") and w[-1] == "base"]
+            if not pending:
+                self.queue(("range", (h0, cov - 1), "base"))
+            return
+        prefix = self.have(0, cov)
+        verify_proof(self.proof, self.cid, prefix)
+        head = parse_head(prefix, self.proof["n"])
+        if isinstance(head, tuple):
+            raise Refusal("head_malformed")
+        adv, applies, held_sets, order, declared, base = self.sink
+        if declared is not None:
+            check_declared(head, declared, base)
+        self.head = head
+        if is_layer(head):
+            self.to_rest("layer", "refinement")
+        elif head["version"] == "WAI1":
+            dispatch_wai1(head["manifest"], adv, held_sets)
+            self.to_rest("single_component", "base")
+        else:
+            entries = head["manifest"]["renditions"]
+            ordr = order if order is not None else list(range(len(entries)))
+            pick, skipped = select(head["manifest"], ordr, adv, held_sets, lambda i, e: True)
+            wanted = [(pick, "base")] + self.applied(entries, pick)
+            pl = plan(head, wanted, [(a, b) for a, b, _ in self.held], self.permille)
+            if pl[0] == "rest":
+                self.to_rest(pl[2], "base")
+            else:
+                for (a, b, cl) in pl[1]:
+                    self.queue(("range", (a, b), cl))
+                self.dropped = pl[2]
+                gone = [i for i, _ in pl[2]]
+                self.stage = ("components", pick, skipped, [(i, c) for i, c in wanted if i not in gone])
+        if self.stage[0] == "components":
+            self.advance_components()
+        elif self.stage[0] == "rest":
+            self.advance_rest()
+
+    def advance_components(self):
+        _, pick, skipped, wanted = self.stage
+        entries = self.head["manifest"]["renditions"]
+        parts, pending, base_pending = {}, False, False
+        for i, cl in wanted:
+            if i in self.abandoned or any(d == i for d, _ in self.dropped):
+                continue
+            if i in self.verified:
+                parts[i] = self.verified[i]
+                continue
+            s, ln = self.head["components"][i]
+            bts = self.have(s, s + ln)
+            if bts is None:
+                pending = True
+                base_pending = base_pending or cl == "base"
+            elif entries[i].get("sha256") is not None and sha(bts) == entries[i]["sha256"]:
+                parts[i] = self.verified[i] = bts
+            elif cl == "refinement":
+                self.dropped.append([i, "component_digest_mismatch"])
+            else:
+                self.issued, self.queued, self.abandoned, self.dropped, self.verified = {}, [], [], [], {}
+                self.drop_from(covered_len(self.head["head_len"], self.head["envelope_len"]))
+                self.to_rest("component_digest_mismatch", "base")
+                self.advance_rest()
+                return
+        classes = dict(wanted)
+
+        def assemble(only_base):
+            js = [j for j, _ in wanted[1:] if j in parts and not (only_base and classes[j] == "refinement")]
+            comps = [j for j in js if entries[j].get("role") == "companion"]
+            refs = [j for j in js if entries[j].get("role") != "companion"]
+            return self.fetched("base", pick, parts[pick], comps, refs, self.abandoned, self.dropped, skipped, "head-proof", None)
+        if not (pending if MUTATE == "base-at-done" else base_pending) and self.base is None:
+            self.base, self.base_at = assemble(True), self.now
+        if pending:
+            return
+        self.finish(assemble(False))
+
+    def fetched(self, role, pick, comp, comps, refs, abandoned, dropped, skipped, by, why):
+        return {"role": role, "pick": pick, "verified_by": by, "why_whole": why, "body_bytes": self.body, "requests": self.requests,
+                "companions": comps, "refinements": refs, "abandoned": list(abandoned), "dropped": [list(x) for x in dropped],
+                "skipped": skipped, "component_sha256": sha(comp)}
+
+    def advance_rest(self):
+        layer_listed = self.stage[0] == "layer"
+        why = "layer" if layer_listed else self.stage[1]
+        if 0 in self.abandoned and (layer_listed or why == "layer"):
+            self.finish(self.fetched("layer", 0, b"", [], [], [0], [], [], "whole-object", "layer"))
+            return
+        if self.proof is not None:
+            n = self.proof["n"]
+        elif self.held and self.held[0][0] == 0:
+            n = self.held[0][1] + 1
+        else:
+            return
+        envb = self.have(0, n)
+        if envb is None:
+            return
+        if content_hash(envb) != self.cid:
+            raise Refusal("object_digest_mismatch")
+        head = parse_head(envb, n)
+        adv, applies, held_sets, order, declared, base = self.sink
+        if declared is not None:
+            check_declared(head, declared, base)
+        if is_layer(head):
+            s, ln = head["components"][0]
+            self.finish(self.fetched("layer", 0, envb[s:s + ln], [], [], [], [], [], "whole-object", "layer"))
+            return
+        if layer_listed:
+            raise Refusal("not_a_layer")
+        m = head["manifest"]
+        if head["version"] == "WAI1":
+            dispatch_wai1(m, adv, held_sets)
+            s, ln = head["components"][0]
+            self.finish(self.fetched("base", 0, envb[s:s + ln], [], [], [], [], [], "whole-object", why))
+            return
+        entries = m["renditions"]
+        pay = [envb[s:s + ln] for s, ln in head["components"]]
+        ordr = order if order is not None else list(range(len(entries)))
+        pick, skipped = select(m, ordr, adv, held_sets, lambda i, e: payload_ok(e, pay[i]))
+        comps, refs, dropped = [], [], []
+        for j, cl in self.applied(entries, pick):
+            # A refinement stating no digest is dropped here as on the range path (§7 step 5).
+            if cl == "refinement" and entries[j].get("sha256") is None:
+                dropped.append([j, "component_digest_absent"])
+                continue
+            if not payload_ok(entries[j], pay[j]):
+                if cl == "refinement":
+                    dropped.append([j, "component_digest_mismatch"])
+                continue
+            (comps if entries[j].get("role") == "companion" else refs).append(j)
+        self.finish(self.fetched("base", pick, pay[pick], comps, refs, [], dropped, skipped, "whole-object", why))
+
+
+def drive(s, answer):
+    """Run a session: `answer(want)` gives (status, Content-Range, Content-Encoding,
+    body) or None for a request that never arrives."""
+    while True:
+        if s.result is not None:
+            if "error" in s.result:
+                raise Refusal(s.result["error"], s.result.get("skipped"))
+            return s.result
+        ws = s.wants()
+        if not ws:
+            for i in [i for i, w in s.issued.items() if Session.cls(w) == "refinement"]:
+                s.on_deadline(i)
+            if s.result is not None:
+                continue
+            if not s.queued:
+                if s.issued:
+                    raise Refusal("base_unanswered")
+                raise SystemExit("http_verify: the session stalled")
+            continue
+        for i, w in ws:
+            r = answer(w)
+            if r is not None:
+                s.on_response(i, *r, s.now)
+
+
+def fetch(env, served, frag, sink, permille, tamper, listed_as_layer=False):
+    """The reference client against an origin serving `served` under the name of `env`,
+    with the corpus's tampers."""
+    proof_bytes = make_proof_file(env) if not listed_as_layer else b""
+    n_real = len(served)
+    kind_t, ref_t, first_flip = tamper.get("kind"), tamper.get("refinement"), tamper.get("first_range_flip")
+    state = {"first": True}
+
+    def answer(w):
+        cl = Session.cls(w)
+        if kind_t == "no_refinement" and cl == "refinement":
+            return None
+        if w[0] == "proof":
+            return None if kind_t == "no_proof" else (200, None, None, proof_bytes)
+        rng = None if w[0] == "whole" else ("bytes=%d-%d" % w[1] if w[0] == "range" else "bytes=%d-" % w[1][0])
+        status, cr, a, b = origin_serve(n_real, rng)
+        body = served[a:b]
+        enc = "gzip" if kind_t == "gzip" else None
+        if first_flip is not None and w[0] == "range" and state["first"]:
+            state["first"] = False
+            if a <= first_flip < b:
+                body = bytearray(body); body[first_flip - a] ^= 1; body = bytes(body)
+        if ref_t is not None and cl == "refinement" and w[0] == "range":
+            (ra, rb) = w[1]
+            if ref_t == "gzip":
+                enc = "gzip"
+            elif ref_t == "bad_range":
+                cr = "bytes %d-%d/%d" % (ra + 1, rb + 1, n_real)
+            elif ref_t == "416":
+                return (416, "bytes */%d" % n_real, None, b"")
+            elif ref_t == "complete_length":
+                cr = "bytes %d-%d/1" % (ra, rb)
+            elif ref_t == "plus_sign":
+                cr = cr.replace("bytes ", "bytes +", 1)
+            elif ref_t == "short_200":
+                return (200, None, None, body)
+        return (status, cr, enc, body)
+
+    s = Session(content_hash(env), frag, permille, sink, layer=listed_as_layer)
+    return drive(s, answer)
+
+
+def fetch_timed(env, frag, sink, permille, deadline, script, flip):
+    """The reference client on a clock (§10.1, §10.2), driven by the corpus's script."""
+    proof_bytes = make_proof_file(env)
+    n = len(env)
+
+    def answer(w):
+        if w[0] == "proof":
+            return (200, None, None, proof_bytes)
+        rng = None if w[0] == "whole" else ("bytes=%d-%d" % w[1] if w[0] == "range" else "bytes=%d-" % w[1][0])
+        status, cr, a, b = origin_serve(n, rng)
+        return (status, cr, None, env[a:b])
+
+    def summary(f):
+        return {"pick": f["pick"], "verified_by": f["verified_by"], "component_sha256": f["component_sha256"],
+                "companions": f["companions"], "refinements": f["refinements"]}
+
+    s = Session(content_hash(env), frag, permille, sink, deadline=deadline)
+    pending, ready_step, first, ticks = [], None, None, []
+    stop = False
+    for k, step in enumerate(script):
+        kind, t = step[0], step[1]
+        if kind in ("base", "base_once", "refinement"):
+            cl = "refinement" if kind == "refinement" else "base"
+            while True:
+                pending += s.wants()
+                now = [(i, w) for i, w in pending if Session.cls(w) == cl]
+                if not now:
+                    break
+                pending = [(i, w) for i, w in pending if Session.cls(w) != cl]
+                for i, w in now:
+                    if len(step) > 2 and step[2] == "whole_200":
+                        b = bytearray(env)
+                        if flip is not None:
+                            b[flip] ^= 1
+                        r = (200, None, None, bytes(b))
+                    else:
+                        r = answer(w)
+                    try:
+                        s.on_response(i, *r, t)
+                    except Refusal:
+                        stop = True
+                        break
+                if stop or kind != "base":
+                    break
+        elif kind == "tick":
+            ids = s.tick(t)
+            pending = [(i, w) for i, w in pending if i not in ids]
+            ticks.append([t, ids])
+        else:
+            raise SystemExit("unknown step " + kind)
+        if ready_step is None and s.base_ready() is not None:
+            ready_step, first = k, summary(s.base_ready())
+        if stop:
+            break
+    end = s.base_ready()
+    return {"ready_step": ready_step, "ready_at": s.base_at, "base": first, "base_end": summary(end) if end is not None else None,
+            "ticks": ticks, "outcome": s.result}
+
+
+def make_proof_file(env):
+    """A producer's head proof (§6.2), written from the text: the chaining values of the
+    subtrees at or after c, in the order §6.3 consumes them."""
+    h = whole_head(env)
+    cov = covered_len(h["head_len"], len(env))
+    cvs = []
+    if cov < len(env):
+        x, L, c = DOMAIN + env, 15 + len(env), 15 + cov
+
+        def walk(start, ln):
+            if start >= c:
+                cvs.append(B3.subtree_cv(x[start:start + ln], start))
+            elif start + ln > c:
+                l = 1024 * 2 ** ((((ln - 1) // 1024)).bit_length() - 1)
+                walk(start, l); walk(start + l, ln - l)
+
+        l = 1024 * 2 ** ((((L - 1) // 1024)).bit_length() - 1)
+        walk(0, l); walk(l, L - l)
+    return b"WHP1" + content_hash(env) + len(env).to_bytes(8, "little") + cov.to_bytes(8, "little") + bytes([len(cvs)]) + b"".join(cvs)
+
+
+# ----------------------------------------------------------------- the cases
+
+def apply_patch(b, patch):
+    b = bytearray(b)
+    for off, hx in patch or []:
+        bs = bytes.fromhex(hx)
+        b[off:off + len(bs)] = bs
+    return bytes(b)
+
+
+def frag_of(s):
+    out = {}
+    if s and "#" in s:
+        for kv in s.split("#", 1)[1].split("&"):
+            if "=" in kv:
+                k, v = kv.split("=", 1)
+                if k in ("n", "h") and v.isdigit():
+                    out[k] = int(v)
+    return out
+
+
+def sink_of(d, inp, objs):
+    """The sink a case describes. Its declared union is parsed, and the base a layer is
+    declared against read, before anything is fetched: either refuses the case."""
+    held = [open(os.path.join(d, p), "rb").read() for p in inp.get("held") or []]
+    declared = parse_element(inp["declared"]) if isinstance(inp.get("declared"), str) else None
+    base = None
+    if inp.get("layer_base") is not None or inp.get("layer_base_hex") is not None:
+        b = bytes.fromhex(inp["layer_base_hex"]) if isinstance(inp.get("layer_base_hex"), str) else objs[inp["layer_base"]]
+        base = seq_object(b)
+    return (inp.get("advertises") or [], inp.get("applies") or [], held, inp.get("order"), declared, base)
+
+
+def refusal(e):
+    out = {"error": e.code}
+    if e.skipped is not None:
+        out["skipped"] = e.skipped
+    return out
+
+
+def evaluate(d, objs, op, inp):
+    def obj(i, patch=True):
+        if "envelope_hex" in i:
+            b = bytes.fromhex(i["envelope_hex"])
+        elif "object" in i:
+            b = objs[i["object"]]
+        else:
+            b = open(os.path.join(d, i["file"]), "rb").read()
+        return apply_patch(b, i.get("patch_object")) if patch else b
+
+    try:
+        if op == "parse_head":
+            b = obj(inp)
+            n = inp.get("envelope_len", len(b))
+            p = min(inp.get("prefix", len(b)), len(b))
+            h = parse_head(b[:p], n)
+            if isinstance(h, tuple):
+                return {"need": h[1]}
+            return {"version": h["version"], "head_len": h["head_len"], "envelope_len": h["envelope_len"],
+                    "covered_len": covered_len(h["head_len"], n), "components": [list(c) for c in h["components"]]}
+        if op == "head_proof":
+            b = obj(inp)
+            original = obj(inp, patch=False)
+            cid = content_hash(original)
+            pf = open(os.path.join(d, inp["proof"]), "rb").read() if "proof" in inp else make_proof_file(original)
+            p = read_proof(pf)
+            verify_proof(p, cid, b)
+            return {"covered_len": p["covered"], "n_cv": len(p["cvs"]), "envelope_len": p["n"]}
+        if op == "plan":
+            b = obj(inp)
+            h = parse_head(b, len(b))
+            pl = plan(h, [tuple(w) for w in inp["wanted"]], [tuple(r) for r in inp.get("held", [])], inp.get("threshold_permille", 900))
+            if pl[0] == "rest":
+                return {"whole_rest": list(pl[1]), "why": pl[2]}
+            return {"requests": [list(r) for r in pl[1]], "dropped": pl[2]}
+        if op == "response":
+            r = check_response(inp.get("request"), inp["status"], inp.get("content_range"), inp.get("content_encoding"), inp["body_len"], inp["envelope_len"])
+            return {"ok": list(r)}
+        if op == "select":
+            b = obj(inp)
+            h = whole_head(b)
+            pay = [b[s:s + ln] for s, ln in h["components"]]
+            adv, _, held, order, _, _ = sink_of(d, inp, objs)
+            order = order if order is not None else list(range(len(pay)))
+            try:
+                i, sk = select(h["manifest"], order, adv, held, lambda i, e: payload_ok(e, pay[i]))
+                return {"pick": i, "skipped": sk}
+            except Refusal as e:
+                return {"inert": e.skipped}
+        if op in ("fetch", "same_pick"):
+            env = obj(inp, patch=False)
+            t = inp.get("tamper") or {}
+            served = apply_patch(env, t.get("patch_object"))
+            r = fetch(env, served, frag_of(inp.get("fragment")), sink_of(d, inp, objs), inp.get("threshold_permille", 900), t,
+                      inp.get("listed_as_layer", False))
+            if op == "fetch":
+                return r
+            whole_pick = evaluate(d, objs, "select", inp)
+            if "pick" not in whole_pick or whole_pick["pick"] != r["pick"]:
+                return {"paths_differ": [whole_pick, r]}
+            return {"pick": r["pick"]}
+        if op == "fetch_timed":
+            env = obj(inp, patch=False)
+            sk = sink_of(d, inp, objs)
+            return fetch_timed(env, frag_of(inp.get("fragment")), sk, inp.get("threshold_permille", 900), inp.get("deadline_ms"),
+                               inp["script"], inp.get("flip"))
+        if op == "codecs":
+            return {"elements": parse_codecs(inp["value"])}
+        if op == "union_floor":
+            envs = [bytes.fromhex(x) for x in inp["envelopes_hex"]] if "envelopes_hex" in inp else [objs[i] for i in inp["objects"]]
+            os_ = [seq_object(e) for e in envs]
+            return {"union": render(union_of(os_)), "floor": render(floor_of(os_))}
+        if op == "supports":
+            return {"supports": supports(parse_element(inp["floor"]), inp["containers"], inp["caps"])}
+        if op == "layer_tag":
+            return parse_layer_tag(inp["line"])
+    except Refusal as e:
+        if op == "same_pick" and e.code == "inert":
+            try:
+                evaluate(d, objs, "select", inp)["inert"]
+                return {"inert": True}
+            except KeyError:
+                return {"paths_differ": "range inert, whole picks"}
+        return refusal(e)
+    raise SystemExit("unknown op " + op)
+
+
+# ------------------------------------------------------------------ self-test
+
+def self_test():
+    v = json.load(open(os.path.join(HERE, "blake3_vectors.json")))
+    for c in v["cases"]:
+        data = bytes(i % 251 for i in range(c["input_len"]))
+        got = blake3(data)
+        if MUTATE == "blake3-iv":
+            got = bytes([got[0] ^ 1]) + got[1:]
+        if got.hex() != c["hash"]:
+            print("FAIL self-test: BLAKE3 of %d bytes" % c["input_len"])
+            return False
+        if c["input_len"] > 1024:
+            n = c["input_len"]
+            l = 1024 * 2 ** ((((n - 1) // 1024)).bit_length() - 1)
+            if B3.parent_cv(B3.subtree_cv(data[:l], 0), B3.subtree_cv(data[l:], l), True) != got:
+                print("FAIL self-test: the tree functions over %d bytes" % n)
+                return False
+    return True
+
+
+def run_cases(d, path):
+    """Evaluate every case of a case file (the corpus's format) against the corpus at d,
+    and require each committed outcome."""
+    load_registry()
+    objs = {i: open(os.path.join(d, o["path"]), "rb").read() for i, o in json.load(open(os.path.join(d, "objects.json"))).items()}
+    cases = json.load(open(path))
+    bad = 0
+    for c in cases:
+        got = evaluate(d, objs, c["op"], c["input"])
+        if got != c["expect"]:
+            bad += 1
+            if bad <= 20:
+                print("DIFF %s: rust %s, python %s" % (c["name"], json.dumps(c["expect"]), json.dumps(got)))
+    print("%d/%d cases agree" % (len(cases) - bad, len(cases)))
+    return bad == 0
+
+
+def run(d):
+    load_registry()
+    ok = self_test()
+    listing = json.load(open(os.path.join(d, "objects.json")))
+    objs = {}
+    for i, o in listing.items():
+        b = open(os.path.join(d, o["path"]), "rb").read()
+        if content_hash(b).hex() != o["cid"]:
+            print("FAIL object %s: its bytes do not hash to its cid" % i)
+            ok = False
+        if open(os.path.join(d, o["path"] + ".hp"), "rb").read() != make_proof_file(b):
+            print("FAIL object %s: its head proof is not the one the text gives" % i)
+            ok = False
+        objs[i] = b
+    cases = json.load(open(os.path.join(d, "cases.json")))
+    passed = 0
+    for c in cases:
+        got = evaluate(d, objs, c["op"], c["input"])
+        if got == c["expect"]:
+            passed += 1
+        else:
+            print("FAIL %s: expected %s, got %s" % (c["name"], json.dumps(c["expect"]), json.dumps(got)))
+            ok = False
+    print("%d/%d cases give their outcome%s" % (passed, len(cases), " (mutation %s)" % MUTATE if MUTATE else ""))
+    return ok
+
+
+def diff(path, flip, seed):
+    load_registry()
+    lines = [json.loads(l) for l in open(path) if l.strip()]
+    rng = random.Random(seed)
+    candidates = [i for i, l in enumerate(lines) if len(bytes.fromhex(l["proof"])) > 53]
+    flipped = set(rng.sample(candidates, flip)) if flip else set()
+    refused = set()
+    for i, l in enumerate(lines):
+        proof = bytearray(bytes.fromhex(l["proof"]))
+        if i in flipped:
+            k = proof[52]
+            at = 53 + 32 * rng.randrange(k) + rng.randrange(32)
+            proof[at] ^= 1 << rng.randrange(8)
+        try:
+            p = read_proof(bytes(proof))
+            if p["n"] != l["envelope_len"]:
+                raise Refusal("head_proof_malformed")
+            verify_proof(p, bytes.fromhex(l["cid"]), bytes.fromhex(l["prefix"]))
+        except Refusal:
+            refused.add(i)
+    print("%d proofs; %d flipped; %d refused" % (len(lines), len(flipped), len(refused)))
+    if refused != flipped:
+        print("FAIL: refused %s, flipped %s" % (sorted(refused - flipped)[:10], sorted(flipped - refused)[:10]))
+        return False
+    return True
+
+
+def main(argv):
+    global MUTATE
+    if "--mutate" in argv:
+        i = argv.index("--mutate")
+        MUTATE = argv[i + 1]
+        argv = argv[:i] + argv[i + 2:]
+    if argv and argv[0] == "cases":
+        return 0 if run_cases(argv[2] if len(argv) > 2 else HERE, argv[1]) else 1
+    if argv and argv[0] == "diff":
+        flip = int(argv[argv.index("--flip") + 1]) if "--flip" in argv else 0
+        seed = int(argv[argv.index("--seed") + 1]) if "--seed" in argv else 1
+        return 0 if diff(argv[1], flip, seed) else 1
+    d = argv[0] if argv else HERE
+    return 0 if run(d) else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/wai/http-conformance/objects.json b/wai/http-conformance/objects.json
new file mode 100644
index 000000000..e342c4c46
--- /dev/null
+++ b/wai/http-conformance/objects.json
@@ -0,0 +1,226 @@
+{
+  "O1": {
+    "cid": "df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2",
+    "path": "objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai",
+    "n": 859,
+    "h": 859,
+    "codecs": "wai1.neural.int_mlicpp",
+    "what": "WAI1, pinned, below one chunk is not reached: the head proof covers it whole"
+  },
+  "O2": {
+    "cid": "25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34",
+    "path": "objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai",
+    "n": 20250,
+    "h": 1009,
+    "codecs": "wai2.neural.int_mlicpp|image.avif|image.jxl|image.png",
+    "what": "WAI2 image: a pinned integer learned rendition, AVIF, JPEG XL and PNG of one picture"
+  },
+  "O3": {
+    "cid": "6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9",
+    "path": "objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai",
+    "n": 98613,
+    "h": 1009,
+    "codecs": "wai2.video.av1+meta.hdr10plus",
+    "what": "WAI2 video: AV1 at two rates, HDR10+ metadata bound to the higher by id"
+  },
+  "O4": {
+    "cid": "6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15",
+    "path": "objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai",
+    "n": 39361,
+    "h": 1009,
+    "codecs": "wai2.video.av1",
+    "what": "WAI2 whose first selectable entry states no sha256"
+  },
+  "O5": {
+    "cid": "e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b",
+    "path": "objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai",
+    "n": 251,
+    "h": 251,
+    "codecs": "wai1.text.zstd",
+    "what": "a small WAI1, fetched whole"
+  },
+  "O7": {
+    "cid": "922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f",
+    "path": "objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai",
+    "n": 39437,
+    "h": 1009,
+    "codecs": "wai2.video.av1",
+    "what": "WAI2 whose first entry states a wrong sha256"
+  },
+  "O8": {
+    "cid": "a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09",
+    "path": "objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai",
+    "n": 46433,
+    "h": 1009,
+    "codecs": "wai2.video.avc+video.lcevc|video.av1",
+    "what": "WAI2: an AVC base, an LCEVC enhancement bound to it, and an AV1 alternative"
+  },
+  "O9a": {
+    "cid": "31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3",
+    "path": "objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai",
+    "n": 21034,
+    "h": 1009,
+    "codecs": "wai2.video.av1|video.int_hyper",
+    "what": "segment 1 of 3: AV1 and an integer learned video rendition"
+  },
+  "O9b": {
+    "cid": "b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb",
+    "path": "objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai",
+    "n": 18004,
+    "h": 1009,
+    "codecs": "wai1.video.av1",
+    "what": "segment 2 of 3: AV1 only (WAI1)"
+  },
+  "O9c": {
+    "cid": "a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133",
+    "path": "objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai",
+    "n": 18381,
+    "h": 1009,
+    "codecs": "wai1.video.av1",
+    "what": "segment 3 of 3: AV1 only (WAI1)"
+  },
+  "OD": {
+    "cid": "eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228",
+    "path": "objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai",
+    "n": 53794,
+    "h": 1009,
+    "codecs": "wai2.video.av1+meta.hdr10plus",
+    "what": "Appendix D's synthetic envelope"
+  },
+  "OH": {
+    "cid": "fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3",
+    "path": "objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai",
+    "n": 23519,
+    "h": 6129,
+    "codecs": "wai2.video.av1",
+    "what": "a WAI2 whose head spans several chunks"
+  },
+  "O10": {
+    "cid": "1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8",
+    "path": "objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai",
+    "n": 1825,
+    "h": 1009,
+    "codecs": "wai1.audio.flac",
+    "what": "a staged-delivery base: WAI1 FLAC"
+  },
+  "O10L1": {
+    "cid": "53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab",
+    "path": "objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai",
+    "n": 12711,
+    "h": 1009,
+    "codecs": null,
+    "what": "layer 1 over O10: WAI1 audio refinement"
+  },
+  "O10L2": {
+    "cid": "753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c",
+    "path": "objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai",
+    "n": 18367,
+    "h": 1009,
+    "codecs": null,
+    "what": "layer 2 over O10, after layer 1"
+  },
+  "OS": {
+    "cid": "9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0",
+    "path": "objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai",
+    "n": 38460,
+    "h": 1009,
+    "codecs": "wai2.video.avc+video.lcevc",
+    "what": "WAI2: an AVC base and an LCEVC enhancement nearly four times its size"
+  },
+  "ON": {
+    "cid": "ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b",
+    "path": "objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai",
+    "n": 38384,
+    "h": 1009,
+    "codecs": "wai2.video.avc+video.lcevc",
+    "what": "OS with the enhancement stating no sha256"
+  },
+  "OW": {
+    "cid": "2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314",
+    "path": "objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai",
+    "n": 38460,
+    "h": 1009,
+    "codecs": "wai2.video.avc+video.lcevc",
+    "what": "OS with the enhancement stating a wrong sha256"
+  },
+  "OT": {
+    "cid": "45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6",
+    "path": "objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai",
+    "n": 12368,
+    "h": 1009,
+    "codecs": "wai2.video.av1",
+    "what": "WAI2 small enough for the first request to hold whole"
+  },
+  "OF": {
+    "cid": "3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644",
+    "path": "objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai",
+    "n": 283,
+    "h": 283,
+    "codecs": "wai1.text.zstd",
+    "what": "WAI1 naming a record capability with a payload fallback"
+  },
+  "OE1": {
+    "cid": "4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c",
+    "path": "objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai",
+    "n": 299,
+    "h": 299,
+    "codecs": "wai1.text.zstd",
+    "what": "WAI1 whose payload is encrypted"
+  },
+  "OE2s": {
+    "cid": "2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f",
+    "path": "objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai",
+    "n": 5251,
+    "h": 1009,
+    "codecs": "wai2.text.zstd",
+    "what": "WAI2 whose security member is a string"
+  },
+  "OE2t": {
+    "cid": "374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263",
+    "path": "objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai",
+    "n": 5242,
+    "h": 1009,
+    "codecs": "wai2.text.zstd",
+    "what": "WAI2 whose security member is true"
+  },
+  "OR": {
+    "cid": "fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419",
+    "path": "objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai",
+    "n": 9434,
+    "h": 1009,
+    "codecs": "wai2.video.int_motion",
+    "what": "WAI2 with a refinement component whose refines is malformed"
+  },
+  "OPf": {
+    "cid": "9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f",
+    "path": "objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai",
+    "n": 267,
+    "h": 267,
+    "codecs": "wai1.text.zstd",
+    "what": "WAI1 text whose refines is false: an ordinary object"
+  },
+  "OPe": {
+    "cid": "0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7",
+    "path": "objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai",
+    "n": 264,
+    "h": 264,
+    "codecs": "wai1.text.zstd",
+    "what": "WAI1 text whose refines is {}: an ordinary object"
+  },
+  "OPw": {
+    "cid": "d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da",
+    "path": "objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai",
+    "n": 421,
+    "h": 421,
+    "codecs": "wai1.text.zstd",
+    "what": "WAI1 text with a well-formed refines: an ordinary object"
+  },
+  "ORN": {
+    "cid": "a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8",
+    "path": "objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai",
+    "n": 32659,
+    "h": 1009,
+    "codecs": "wai2.video.av1+video.int_refine",
+    "what": "WAI2: an AV1 base and a refinement stating no sha256"
+  }
+}
diff --git a/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai b/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai
new file mode 100644
index 000000000..d17b5ec63
Binary files /dev/null and b/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai differ
diff --git a/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai.etag b/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai.etag
new file mode 100644
index 000000000..a70005ea6
--- /dev/null
+++ b/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai.etag
@@ -0,0 +1 @@
+"0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7"
diff --git a/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai.hp b/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai.hp
new file mode 100644
index 000000000..d5edf9ffb
Binary files /dev/null and b/wai/http-conformance/objects/0223dac27b41616c470d3c8e3f14d24d1e7294153226678051e9f84a0a5a07d7.wai.hp differ
diff --git a/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai b/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai
new file mode 100644
index 000000000..5ee396a23
Binary files /dev/null and b/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai differ
diff --git a/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai.etag b/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai.etag
new file mode 100644
index 000000000..b165fdff1
--- /dev/null
+++ b/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai.etag
@@ -0,0 +1 @@
+"1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8"
diff --git a/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai.hp b/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai.hp
new file mode 100644
index 000000000..296d656fb
Binary files /dev/null and b/wai/http-conformance/objects/1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8.wai.hp differ
diff --git a/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai b/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai
new file mode 100644
index 000000000..eefcc6bd5
Binary files /dev/null and b/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai differ
diff --git a/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai.etag b/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai.etag
new file mode 100644
index 000000000..5ce8759c6
--- /dev/null
+++ b/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai.etag
@@ -0,0 +1 @@
+"25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34"
diff --git a/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai.hp b/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai.hp
new file mode 100644
index 000000000..6d21ce5ad
Binary files /dev/null and b/wai/http-conformance/objects/25130382f5d9c73ae59a04d1fbae1463693f3769c090744ebd5f1e80fa3b0a34.wai.hp differ
diff --git a/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai b/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai
new file mode 100644
index 000000000..eff110aa1
Binary files /dev/null and b/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai differ
diff --git a/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai.etag b/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai.etag
new file mode 100644
index 000000000..022f73625
--- /dev/null
+++ b/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai.etag
@@ -0,0 +1 @@
+"2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314"
diff --git a/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai.hp b/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai.hp
new file mode 100644
index 000000000..4ecdb0abe
Binary files /dev/null and b/wai/http-conformance/objects/2e91576dd7feb0405a41eec039bfd1264fe6e52f81880850bbaa4c30c5a24314.wai.hp differ
diff --git a/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai b/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai
new file mode 100644
index 000000000..da6e33ae8
Binary files /dev/null and b/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai differ
diff --git a/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai.etag b/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai.etag
new file mode 100644
index 000000000..75113e9c9
--- /dev/null
+++ b/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai.etag
@@ -0,0 +1 @@
+"2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f"
diff --git a/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai.hp b/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai.hp
new file mode 100644
index 000000000..3a90474c6
Binary files /dev/null and b/wai/http-conformance/objects/2f1336eddd3eb02bab5ffca9b44fd4f38a530bc35f6d42ca98a55ce28997c23f.wai.hp differ
diff --git a/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai b/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai
new file mode 100644
index 000000000..b4dfaefa3
Binary files /dev/null and b/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai differ
diff --git a/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai.etag b/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai.etag
new file mode 100644
index 000000000..9236b16df
--- /dev/null
+++ b/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai.etag
@@ -0,0 +1 @@
+"31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3"
diff --git a/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai.hp b/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai.hp
new file mode 100644
index 000000000..ecf476edf
Binary files /dev/null and b/wai/http-conformance/objects/31abc1da2cdf927191f3f447f68508ead30d078690cb7bea2435ae3d1df5f4f3.wai.hp differ
diff --git a/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai b/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai
new file mode 100644
index 000000000..de5742fb0
Binary files /dev/null and b/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai differ
diff --git a/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai.etag b/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai.etag
new file mode 100644
index 000000000..a067f8f41
--- /dev/null
+++ b/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai.etag
@@ -0,0 +1 @@
+"374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263"
diff --git a/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai.hp b/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai.hp
new file mode 100644
index 000000000..9ce73bb66
Binary files /dev/null and b/wai/http-conformance/objects/374d7f60814b24e8cec94b288e2a5fda87bbb047defb550f778c54fe177d8263.wai.hp differ
diff --git a/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai b/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai
new file mode 100644
index 000000000..de15b2759
Binary files /dev/null and b/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai differ
diff --git a/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai.etag b/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai.etag
new file mode 100644
index 000000000..49bd58930
--- /dev/null
+++ b/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai.etag
@@ -0,0 +1 @@
+"3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644"
diff --git a/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai.hp b/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai.hp
new file mode 100644
index 000000000..cde269bc8
Binary files /dev/null and b/wai/http-conformance/objects/3b54ebe898cf23b1e5e7b651c860d8548c7f8f6c060dc1c79eecaf47bc4d2644.wai.hp differ
diff --git a/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai b/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai
new file mode 100644
index 000000000..6d39f8679
Binary files /dev/null and b/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai differ
diff --git a/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai.etag b/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai.etag
new file mode 100644
index 000000000..8569d87d7
--- /dev/null
+++ b/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai.etag
@@ -0,0 +1 @@
+"45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6"
diff --git a/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai.hp b/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai.hp
new file mode 100644
index 000000000..22f333f9a
Binary files /dev/null and b/wai/http-conformance/objects/45280f543b7eb77cf29e9752c2a0b47af8e12b8fe289b720c0e1b152ad5179e6.wai.hp differ
diff --git a/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai b/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai
new file mode 100644
index 000000000..7533aa507
Binary files /dev/null and b/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai differ
diff --git a/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai.etag b/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai.etag
new file mode 100644
index 000000000..7bb6de3ce
--- /dev/null
+++ b/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai.etag
@@ -0,0 +1 @@
+"4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c"
diff --git a/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai.hp b/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai.hp
new file mode 100644
index 000000000..7b09fd8c2
Binary files /dev/null and b/wai/http-conformance/objects/4bae50654cbba982c74f55082e5d2ee090c50cb54be34d71d26958464819aa4c.wai.hp differ
diff --git a/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai b/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai
new file mode 100644
index 000000000..38836a01b
Binary files /dev/null and b/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai differ
diff --git a/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai.etag b/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai.etag
new file mode 100644
index 000000000..c81bacdd0
--- /dev/null
+++ b/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai.etag
@@ -0,0 +1 @@
+"53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab"
diff --git a/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai.hp b/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai.hp
new file mode 100644
index 000000000..3b0dc2605
Binary files /dev/null and b/wai/http-conformance/objects/53a48057cb99b88fd235b9165799122df2d1b55a4b84245112a5a5ea948458ab.wai.hp differ
diff --git a/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai b/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai
new file mode 100644
index 000000000..bf70114b9
Binary files /dev/null and b/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai differ
diff --git a/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai.etag b/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai.etag
new file mode 100644
index 000000000..83e2a9676
--- /dev/null
+++ b/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai.etag
@@ -0,0 +1 @@
+"6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15"
diff --git a/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai.hp b/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai.hp
new file mode 100644
index 000000000..3587e7b24
Binary files /dev/null and b/wai/http-conformance/objects/6bc4da2051c4c4cef757b2a7ee927a5353a6717224de27fdb6a26dd6c0485a15.wai.hp differ
diff --git a/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai b/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai
new file mode 100644
index 000000000..2d7e0b318
Binary files /dev/null and b/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai differ
diff --git a/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai.etag b/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai.etag
new file mode 100644
index 000000000..337282e13
--- /dev/null
+++ b/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai.etag
@@ -0,0 +1 @@
+"6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9"
diff --git a/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai.hp b/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai.hp
new file mode 100644
index 000000000..41f8853d4
Binary files /dev/null and b/wai/http-conformance/objects/6e485f112e849422fb9cfd279cb16b88c8d5ee1e72bafe4892992fc6bef88be9.wai.hp differ
diff --git a/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai b/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai
new file mode 100644
index 000000000..ce9b7ec72
Binary files /dev/null and b/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai differ
diff --git a/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai.etag b/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai.etag
new file mode 100644
index 000000000..0214fd5d4
--- /dev/null
+++ b/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai.etag
@@ -0,0 +1 @@
+"753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c"
diff --git a/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai.hp b/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai.hp
new file mode 100644
index 000000000..4c0b6de69
Binary files /dev/null and b/wai/http-conformance/objects/753e8ac465d347547c688690eb51615f19118c0a4c17490499fbb31aefd5cd0c.wai.hp differ
diff --git a/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai b/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai
new file mode 100644
index 000000000..549370be6
Binary files /dev/null and b/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai differ
diff --git a/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai.etag b/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai.etag
new file mode 100644
index 000000000..15698b698
--- /dev/null
+++ b/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai.etag
@@ -0,0 +1 @@
+"922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f"
diff --git a/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai.hp b/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai.hp
new file mode 100644
index 000000000..2e9e2753a
Binary files /dev/null and b/wai/http-conformance/objects/922db9b513790966272927c4f542fb01cb25ff9c7b189fb6699bf92894c29a6f.wai.hp differ
diff --git a/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai b/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai
new file mode 100644
index 000000000..70ca04686
Binary files /dev/null and b/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai differ
diff --git a/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai.etag b/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai.etag
new file mode 100644
index 000000000..ff26bb74a
--- /dev/null
+++ b/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai.etag
@@ -0,0 +1 @@
+"9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0"
diff --git a/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai.hp b/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai.hp
new file mode 100644
index 000000000..6d0132ee5
Binary files /dev/null and b/wai/http-conformance/objects/9aecf3c0a15e19e0ff127071afe1bf03ef2587083b5fb0aeb8283e642fb27cc0.wai.hp differ
diff --git a/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai b/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai
new file mode 100644
index 000000000..569285e28
Binary files /dev/null and b/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai differ
diff --git a/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai.etag b/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai.etag
new file mode 100644
index 000000000..c8b717d65
--- /dev/null
+++ b/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai.etag
@@ -0,0 +1 @@
+"9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f"
diff --git a/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai.hp b/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai.hp
new file mode 100644
index 000000000..6634b1315
Binary files /dev/null and b/wai/http-conformance/objects/9c79f069e1ad17932f27059a763dc2aec26ca3e19c70cf45aafe40d8e3e9893f.wai.hp differ
diff --git a/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai b/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai
new file mode 100644
index 000000000..0aa2fbee0
Binary files /dev/null and b/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai differ
diff --git a/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai.etag b/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai.etag
new file mode 100644
index 000000000..3127c101c
--- /dev/null
+++ b/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai.etag
@@ -0,0 +1 @@
+"a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09"
diff --git a/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai.hp b/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai.hp
new file mode 100644
index 000000000..509aa2818
Binary files /dev/null and b/wai/http-conformance/objects/a016e64f311ac1128481d0da292c7cbcb1d98d6c9edd6983ad8b9e385e6c0b09.wai.hp differ
diff --git a/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai b/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai
new file mode 100644
index 000000000..8549a913a
Binary files /dev/null and b/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai differ
diff --git a/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai.etag b/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai.etag
new file mode 100644
index 000000000..1a50b67d4
--- /dev/null
+++ b/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai.etag
@@ -0,0 +1 @@
+"a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8"
diff --git a/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai.hp b/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai.hp
new file mode 100644
index 000000000..febd8053f
Binary files /dev/null and b/wai/http-conformance/objects/a1cc741a342c2f3301523b887ebea597938b4a2e92e8c159c6fefcc4c5b507e8.wai.hp differ
diff --git a/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai b/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai
new file mode 100644
index 000000000..8a9392156
Binary files /dev/null and b/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai differ
diff --git a/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai.etag b/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai.etag
new file mode 100644
index 000000000..14e1a472e
--- /dev/null
+++ b/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai.etag
@@ -0,0 +1 @@
+"a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133"
diff --git a/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai.hp b/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai.hp
new file mode 100644
index 000000000..69cb41097
Binary files /dev/null and b/wai/http-conformance/objects/a8ab2cd0cc277ef7109aacdee6bb55ff713aa0d4dc4c2e3dfe40aab759a90133.wai.hp differ
diff --git a/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai b/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai
new file mode 100644
index 000000000..6afc8c912
Binary files /dev/null and b/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai differ
diff --git a/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai.etag b/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai.etag
new file mode 100644
index 000000000..d9413c916
--- /dev/null
+++ b/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai.etag
@@ -0,0 +1 @@
+"b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb"
diff --git a/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai.hp b/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai.hp
new file mode 100644
index 000000000..9a5aea7a3
Binary files /dev/null and b/wai/http-conformance/objects/b7a711ab4b0a0939a561a16b3167039e7fe65c640d73a040ebc5d5cf86e4ecbb.wai.hp differ
diff --git a/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai b/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai
new file mode 100644
index 000000000..54a09779e
Binary files /dev/null and b/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai differ
diff --git a/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai.etag b/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai.etag
new file mode 100644
index 000000000..2e13017b0
--- /dev/null
+++ b/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai.etag
@@ -0,0 +1 @@
+"ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b"
diff --git a/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai.hp b/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai.hp
new file mode 100644
index 000000000..24d502635
Binary files /dev/null and b/wai/http-conformance/objects/ce447337900fd74988ee4fec8277e1726c1bb1fb6fbd65a74900219d1ded741b.wai.hp differ
diff --git a/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai b/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai
new file mode 100644
index 000000000..b2122fe6a
Binary files /dev/null and b/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai differ
diff --git a/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai.etag b/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai.etag
new file mode 100644
index 000000000..338dbd9f4
--- /dev/null
+++ b/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai.etag
@@ -0,0 +1 @@
+"d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da"
diff --git a/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai.hp b/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai.hp
new file mode 100644
index 000000000..bcc1b8782
Binary files /dev/null and b/wai/http-conformance/objects/d3301aea0e39f84acf41e3075d0b0789bc065105520623dda98053cb1eb071da.wai.hp differ
diff --git a/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai b/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai
new file mode 100644
index 000000000..808357456
Binary files /dev/null and b/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai differ
diff --git a/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai.etag b/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai.etag
new file mode 100644
index 000000000..77f5fa12d
--- /dev/null
+++ b/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai.etag
@@ -0,0 +1 @@
+"df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2"
diff --git a/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai.hp b/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai.hp
new file mode 100644
index 000000000..f8762ab50
Binary files /dev/null and b/wai/http-conformance/objects/df5337ea38c4d61fd15f006c08df937f480788fd669e7337b0f8105a5816a9d2.wai.hp differ
diff --git a/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai b/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai
new file mode 100644
index 000000000..df84a059e
Binary files /dev/null and b/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai differ
diff --git a/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai.etag b/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai.etag
new file mode 100644
index 000000000..2855e64e3
--- /dev/null
+++ b/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai.etag
@@ -0,0 +1 @@
+"e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b"
diff --git a/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai.hp b/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai.hp
new file mode 100644
index 000000000..c0cdf6831
Binary files /dev/null and b/wai/http-conformance/objects/e43e038c10c0494d9647444fd4daf54b19fc3a946a3c7980431bc6e0a236093b.wai.hp differ
diff --git a/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai b/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai
new file mode 100644
index 000000000..af8942a8c
Binary files /dev/null and b/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai differ
diff --git a/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai.etag b/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai.etag
new file mode 100644
index 000000000..1cd36744c
--- /dev/null
+++ b/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai.etag
@@ -0,0 +1 @@
+"eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228"
diff --git a/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai.hp b/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai.hp
new file mode 100644
index 000000000..13b0d2745
Binary files /dev/null and b/wai/http-conformance/objects/eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228.wai.hp differ
diff --git a/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai b/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai
new file mode 100644
index 000000000..c2c2c3e91
Binary files /dev/null and b/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai differ
diff --git a/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai.etag b/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai.etag
new file mode 100644
index 000000000..3ffb4a4f3
--- /dev/null
+++ b/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai.etag
@@ -0,0 +1 @@
+"fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3"
diff --git a/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai.hp b/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai.hp
new file mode 100644
index 000000000..c5810c714
Binary files /dev/null and b/wai/http-conformance/objects/fcc4e739d1ddb9fbe55d45ec3e9e1df9c867492bdd4009109e5195ed58638ef3.wai.hp differ
diff --git a/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai b/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai
new file mode 100644
index 000000000..5189b9f9c
Binary files /dev/null and b/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai differ
diff --git a/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai.etag b/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai.etag
new file mode 100644
index 000000000..5aed4e9b7
--- /dev/null
+++ b/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai.etag
@@ -0,0 +1 @@
+"fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419"
diff --git a/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai.hp b/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai.hp
new file mode 100644
index 000000000..1c9dc6630
Binary files /dev/null and b/wai/http-conformance/objects/fd3d6101b76dd3c0b01373d3da28997e2ba499d1ee5d1b27396005a748ca4419.wai.hp differ
diff --git a/wai/http-conformance/src/SOURCES.json b/wai/http-conformance/src/SOURCES.json
new file mode 100644
index 000000000..609bdc66a
--- /dev/null
+++ b/wai/http-conformance/src/SOURCES.json
@@ -0,0 +1,50 @@
+{
+  "note": "Frozen sources of http-conformance. Each was encoded once, outside this repository, by an encoder of its format; the AV1 streams were checked to decode. Only their bytes matter to the corpus, which checks transport, not decoding.",
+  "files": {
+    "image64.avif": {
+      "sha256": "c56f9ab9a3b1df0bd650c3177bd85427f4a4be8fde82547219bcea4ec254162c",
+      "bytes": 2619,
+      "what": "AVIF of the same picture"
+    },
+    "image64.jxl": {
+      "sha256": "6db8812530d69b6f33069289ee7bc68105f95f0c6a6e8ffffa5b1a7494c30ca1",
+      "bytes": 4433,
+      "what": "JPEG XL of the same picture"
+    },
+    "image64.png": {
+      "sha256": "eb67f66a321f613886bbbed6309f432a5f27fbb5bf1eabfe6a4d1931f425f107",
+      "bytes": 11848,
+      "what": "PNG of the 64x64 picture the pinned wai.neural.int_mlicpp vector (wai-rs/tests/vectors/int_mlicpp/stream.wai) decodes to"
+    },
+    "pattern_high.av1": {
+      "sha256": "68a51be787c439226eb7bb1cf434e913fc1f0e221870da87f70615d667a7ab12",
+      "bytes": 77040,
+      "what": "AV1 of the same pattern at a higher rate, in the same framing"
+    },
+    "pattern_low.av1": {
+      "sha256": "24003cee2a7bf7fa45caa412ab4ea9f5f08b6bf44842a73d5a11c2bcf36df464",
+      "bytes": 20766,
+      "what": "AV1 of a 2 s, 320x180, 25 fps test pattern at a low rate, in the reference implementation's AV1 payload framing (n_frames, h, w, fps_num, fps_den, then each temporal unit length-prefixed)"
+    },
+    "seg0.av1": {
+      "sha256": "0c03a22bebcdb29e26fc1e6dbf040bd86751e8e0be66a2b2ba6709f786a260e8",
+      "bytes": 18293,
+      "what": "AV1 of frames 0-15 of the pattern, in the same framing"
+    },
+    "seg1.av1": {
+      "sha256": "edd595431a8992d78fd6f691c6b066efa102ac8c1ffb822505639e0d640174a4",
+      "bytes": 17834,
+      "what": "AV1 of frames 16-31 of the pattern, in the same framing"
+    },
+    "seg2.av1": {
+      "sha256": "dbf116e87034120670d459dbc4812644799b1dc3ae29cc070659103948ca59bc",
+      "bytes": 18211,
+      "what": "AV1 of frames 32-47 of the pattern, in the same framing"
+    },
+    "small.zst": {
+      "sha256": "591f780863bd571c1b868efabdf64a30ff0734b22582dad3f89486d0a97663c1",
+      "bytes": 94,
+      "what": "a zstd frame of one line of text"
+    }
+  }
+}
diff --git a/wai/http-conformance/src/image64.avif b/wai/http-conformance/src/image64.avif
new file mode 100644
index 000000000..2d51cfe83
Binary files /dev/null and b/wai/http-conformance/src/image64.avif differ
diff --git a/wai/http-conformance/src/image64.jxl b/wai/http-conformance/src/image64.jxl
new file mode 100644
index 000000000..0c08e98e1
Binary files /dev/null and b/wai/http-conformance/src/image64.jxl differ
diff --git a/wai/http-conformance/src/image64.png b/wai/http-conformance/src/image64.png
new file mode 100644
index 000000000..b310683af
Binary files /dev/null and b/wai/http-conformance/src/image64.png differ
diff --git a/wai/http-conformance/src/pattern_high.av1 b/wai/http-conformance/src/pattern_high.av1
new file mode 100644
index 000000000..d5205862c
Binary files /dev/null and b/wai/http-conformance/src/pattern_high.av1 differ
diff --git a/wai/http-conformance/src/pattern_low.av1 b/wai/http-conformance/src/pattern_low.av1
new file mode 100644
index 000000000..442e81e69
Binary files /dev/null and b/wai/http-conformance/src/pattern_low.av1 differ
diff --git a/wai/http-conformance/src/seg0.av1 b/wai/http-conformance/src/seg0.av1
new file mode 100644
index 000000000..a436db82f
Binary files /dev/null and b/wai/http-conformance/src/seg0.av1 differ
diff --git a/wai/http-conformance/src/seg1.av1 b/wai/http-conformance/src/seg1.av1
new file mode 100644
index 000000000..ab4bfa9d3
Binary files /dev/null and b/wai/http-conformance/src/seg1.av1 differ
diff --git a/wai/http-conformance/src/seg2.av1 b/wai/http-conformance/src/seg2.av1
new file mode 100644
index 000000000..2f3d1d987
Binary files /dev/null and b/wai/http-conformance/src/seg2.av1 differ
diff --git a/wai/http-conformance/src/small.zst b/wai/http-conformance/src/small.zst
new file mode 100644
index 000000000..c82269c98
Binary files /dev/null and b/wai/http-conformance/src/small.zst differ
diff --git a/wai/registry/capabilities.json b/wai/registry/capabilities.json
index ee08dbeea..20182f378 100644
--- a/wai/registry/capabilities.json
+++ b/wai/registry/capabilities.json
@@ -1474,5 +1474,224 @@
       "label": "wai.quantum.rearrange",
       "reason": "a receipt-kind label the wai-quantum crate seals; no revision of SPEC or of an extension registers it, so it is not a registered record"
     }
+  ],
+  "wire_identifiers": [
+    {
+      "name": "#WAI-LAYER",
+      "kind": "playlist-tag",
+      "document": "extensions/http-delivery.md",
+      "section": "§10.4",
+      "status": "defined"
+    },
+    {
+      "name": ".wai",
+      "kind": "path",
+      "document": "extensions/http-delivery.md",
+      "section": "§5.2",
+      "status": "defined"
+    },
+    {
+      "name": ".wai.hp",
+      "kind": "path",
+      "document": "extensions/http-delivery.md",
+      "section": "§6.2",
+      "status": "defined"
+    },
+    {
+      "name": ".wai.receipts",
+      "kind": "path",
+      "document": "extensions/http-delivery.md",
+      "section": "§8.2",
+      "status": "defined"
+    },
+    {
+      "name": "/.well-known/wai-grants/",
+      "kind": "well-known",
+      "document": "extensions/http-delivery.md",
+      "section": "§8.4",
+      "status": "defined"
+    },
+    {
+      "name": "/.well-known/wai-key-status",
+      "kind": "well-known",
+      "document": "extensions/http-delivery.md",
+      "section": "§8.4",
+      "status": "defined"
+    },
+    {
+      "name": "/.well-known/wai-keys",
+      "kind": "well-known",
+      "document": "extensions/jwp-receipts.md",
+      "section": "§7.1",
+      "status": "defined"
+    },
+    {
+      "name": "WAI1",
+      "kind": "magic",
+      "document": "SPEC.md",
+      "section": "§2",
+      "status": "defined"
+    },
+    {
+      "name": "WAI2",
+      "kind": "magic",
+      "document": "SPEC.md",
+      "section": "§7.1",
+      "status": "defined"
+    },
+    {
+      "name": "WAI_RECEIPT",
+      "kind": "catalog",
+      "document": "extensions/moq-streaming-format.md",
+      "section": "§5",
+      "status": "defined"
+    },
+    {
+      "name": "WHP1",
+      "kind": "magic",
+      "document": "extensions/http-delivery.md",
+      "section": "§6.2",
+      "status": "defined"
+    },
+    {
+      "name": "X-WAI-FLOOR",
+      "kind": "playlist-attribute",
+      "document": "extensions/http-delivery.md",
+      "section": "§11.1",
+      "status": "defined"
+    },
+    {
+      "name": "application/wai",
+      "kind": "media-type",
+      "document": "extensions/http-delivery.md",
+      "section": "§3",
+      "status": "proposed"
+    },
+    {
+      "name": "mr/",
+      "kind": "path",
+      "document": "extensions/http-delivery.md",
+      "section": "§8.6",
+      "status": "defined"
+    },
+    {
+      "name": "rcpt/",
+      "kind": "path",
+      "document": "extensions/http-delivery.md",
+      "section": "§8.1",
+      "status": "defined"
+    },
+    {
+      "name": "science.transaction.wai.multivariant",
+      "kind": "data-id",
+      "document": "extensions/http-delivery.md",
+      "section": "§11.1",
+      "status": "defined"
+    },
+    {
+      "name": "tag:transaction.science,2026:wai/floor",
+      "kind": "scheme",
+      "document": "extensions/http-delivery.md",
+      "section": "§11.1",
+      "status": "defined"
+    },
+    {
+      "name": "tag:transaction.science,2026:wai/http-delivery",
+      "kind": "scheme",
+      "document": "extensions/http-delivery.md",
+      "section": "§11.1",
+      "status": "defined"
+    },
+    {
+      "name": "wai",
+      "kind": "catalog",
+      "document": "extensions/moq-streaming-format.md",
+      "section": "§3",
+      "status": "defined"
+    },
+    {
+      "name": "wai-key-status",
+      "kind": "document-kind",
+      "document": "extensions/jwp-receipts.md",
+      "section": "§7.9",
+      "status": "defined"
+    },
+    {
+      "name": "wai-module-grant",
+      "kind": "document-kind",
+      "document": "extensions/jwp-receipts.md",
+      "section": "§7.9",
+      "status": "defined"
+    },
+    {
+      "name": "wai-module-grants",
+      "kind": "document-kind",
+      "document": "extensions/http-delivery.md",
+      "section": "§8.4",
+      "status": "defined"
+    },
+    {
+      "name": "wai-receipt-index",
+      "kind": "document-kind",
+      "document": "extensions/http-delivery.md",
+      "section": "§8.2",
+      "status": "defined"
+    },
+    {
+      "name": "wai1",
+      "kind": "codecs-prefix",
+      "document": "extensions/http-delivery.md",
+      "section": "§4.1",
+      "status": "defined"
+    },
+    {
+      "name": "wai1",
+      "kind": "fourcc",
+      "document": "extensions/http-delivery.md",
+      "section": "Appendix B",
+      "status": "provisional"
+    },
+    {
+      "name": "wai2",
+      "kind": "codecs-prefix",
+      "document": "extensions/http-delivery.md",
+      "section": "§4.1",
+      "status": "defined"
+    },
+    {
+      "name": "wai2",
+      "kind": "fourcc",
+      "document": "extensions/http-delivery.md",
+      "section": "Appendix B",
+      "status": "provisional"
+    },
+    {
+      "name": "waiC",
+      "kind": "fourcc",
+      "document": "extensions/http-delivery.md",
+      "section": "Appendix B",
+      "status": "provisional"
+    },
+    {
+      "name": "wai_capabilities",
+      "kind": "catalog",
+      "document": "extensions/moq-streaming-format.md",
+      "section": "§4",
+      "status": "defined"
+    },
+    {
+      "name": "wai_determinism",
+      "kind": "catalog",
+      "document": "extensions/moq-streaming-format.md",
+      "section": "§4",
+      "status": "defined"
+    },
+    {
+      "name": "wai_receipts",
+      "kind": "catalog",
+      "document": "extensions/moq-streaming-format.md",
+      "section": "§4",
+      "status": "defined"
+    }
   ]
 }
diff --git a/wai/registry/capabilities.schema.json b/wai/registry/capabilities.schema.json
index 1d1db5385..7ab4f36ff 100644
--- a/wai/registry/capabilities.schema.json
+++ b/wai/registry/capabilities.schema.json
@@ -9,7 +9,8 @@
     "schema",
     "capabilities",
     "identifiers",
-    "unregistered_labels"
+    "unregistered_labels",
+    "wire_identifiers"
   ],
   "properties": {
     "schema": {
@@ -178,6 +179,55 @@
           }
         }
       }
+    },
+    "wire_identifiers": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": [
+          "name",
+          "kind",
+          "document",
+          "section",
+          "status"
+        ],
+        "properties": {
+          "name": {
+            "type": "string"
+          },
+          "kind": {
+            "enum": [
+              "media-type",
+              "codecs-prefix",
+              "fourcc",
+              "magic",
+              "data-id",
+              "scheme",
+              "path",
+              "well-known",
+              "playlist-tag",
+              "playlist-attribute",
+              "document-kind",
+              "catalog"
+            ]
+          },
+          "document": {
+            "type": "string"
+          },
+          "section": {
+            "type": "string",
+            "pattern": "^(§[0-9]+(\\.[0-9]+)*|Appendix [A-Z])$"
+          },
+          "status": {
+            "enum": [
+              "defined",
+              "provisional",
+              "proposed"
+            ]
+          }
+        }
+      }
     }
   }
 }
diff --git a/wai/wai-rs/Cargo.toml b/wai/wai-rs/Cargo.toml
index a8e231313..3411f5624 100644
--- a/wai/wai-rs/Cargo.toml
+++ b/wai/wai-rs/Cargo.toml
@@ -81,7 +81,7 @@ c2pa = { version = "0.90", optional = true, default-features = false,
 # ---- interactive worlds (optional, behind the `world` feature) ----
 # extensions/interactive-worlds: WWLD container, signed CausalOps,
 # deterministic fixed-point simulation, replay-equivalence conformance.
-blake3 = { version = "1", optional = true }          # state hashes, node minting, op/seal commitments
+blake3 = { version = "1.8", optional = true }        # state hashes, node minting, op/seal commitments; `hazmat` (1.8) for the HTTP head proof
 ed25519-dalek = { version = "2", optional = true }   # op + seal signatures
 num-bigint = { version = "0.4", optional = true }    # oer: exact decimal arithmetic in the composition checks
 # The curve ed25519-dalek is built on, named directly only by `receipt_claims`: its
@@ -184,6 +184,11 @@ jwp_hash = ["dep:blake3"]
 # (WIR1) is integer rANS (neural_int); content hashes are jwp_hash's BLAKE3; stage
 # hashes are SHA-256, always on.
 staged = ["neural_int", "jwp_hash"]
+# HTTP delivery (extensions/http-delivery.md): objects named by their content hash, the
+# WHP1 head proof (BLAKE3's tree, through jwp_hash's BLAKE3), verified range fetch of one
+# WAI2 component, the codecs union and floor, and an origin's responses. Component
+# digests are SHA-256, always on. No I/O in the library; `wai http` does it.
+http = ["jwp_hash"]
 # Staged-delivery measurement (extensions/staged-measurement.md): the counted bytes of
 # an envelope, the output tree, and the deterministic evaluation of a staged title —
 # its prefixes' counted bytes, outputs and quality integers, first presentable,
@@ -544,6 +549,11 @@ name = "wai_film_vectors"
 path = "src/bin/wai_film_vectors.rs"
 required-features = ["film"]
 
+[[bin]]
+name = "wai_http_vectors"
+path = "src/bin/wai_http_vectors.rs"
+required-features = ["http"]
+
 [[bin]]
 name = "wai_world_vectors"
 path = "src/bin/wai_world_vectors.rs"
@@ -679,6 +689,11 @@ name = "int_splat"
 path = "tests/int_splat.rs"
 required-features = ["splat_int"]
 
+[[test]]
+name = "cli_http"
+path = "tests/cli_http.rs"
+required-features = ["http"]
+
 [[test]]
 name = "int_kernels_vectors"
 path = "tests/int_kernels_vectors.rs"
diff --git a/wai/wai-rs/include/wai.h b/wai/wai-rs/include/wai.h
index e80552da8..57e905f88 100644
--- a/wai/wai-rs/include/wai.h
+++ b/wai/wai-rs/include/wai.h
@@ -316,6 +316,16 @@
  */
 #define RESOLUTION_FLOOR_UJ_PPM 288676
 
+/**
+ * The most chaining values a proof may carry.
+ */
+#define HeadProof_MAX_CV 64
+
+/**
+ * The fixed part of the file: magic, cid, `envelope_len`, `covered_len`, `n_cv`.
+ */
+#define HeadProof_FIXED_LEN 53
+
 /**
  * `CausalOp::mutation_kind` for an action input (move/look/buttons + free payload).
  */
diff --git a/wai/wai-rs/src/bin/wai.rs b/wai/wai-rs/src/bin/wai.rs
index 3d1b6e722..ffdb0b173 100644
--- a/wai/wai-rs/src/bin/wai.rs
+++ b/wai/wai-rs/src/bin/wai.rs
@@ -22,6 +22,13 @@ use wai::*;
 #[path = "wai_cli/stage.rs"]
 mod stage;
 
+#[cfg(feature = "http")]
+#[path = "wai_cli/http.rs"]
+mod http;
+#[cfg(feature = "http")]
+#[path = "wai_cli/http_vectors.rs"]
+mod http_vectors;
+
 fn die(msg: impl std::fmt::Display) -> ExitCode {
     eprintln!("error: {msg}");
     ExitCode::from(2)
@@ -41,6 +48,8 @@ fn usage() {
     eprintln!("wai prior-set <root>              print the listing of a parameter set (wai.prior.set) and its pin");
     eprintln!("wai stage refine|apply|inspect|pack|explode …  staged-delivery layers (a build with `staged`,");
     eprintln!("            `video_int`, `audio_int` and `splat_int`); `wai stage` alone prints its usage");
+    eprintln!("wai http publish|codecs|origin|vectors|bench …  HTTP delivery (a build with `http`);");
+    eprintln!("            `wai http` alone prints its usage");
     eprintln!();
     eprintln!("encode and decode need a build with the `codecs` feature.");
     eprintln!("codecs: png jpeg avif jxl jxl-lossless opus flac av1 av1-lossless zstd xz");
@@ -816,6 +825,14 @@ fn main() -> ExitCode {
         "stage" => stage::main(&args[1..]),
         #[cfg(not(all(feature = "staged", feature = "video_int", feature = "audio_int", feature = "splat_int")))]
         "stage" => Err("`wai stage` needs a build with the features staged, video_int, audio_int and splat_int".into()),
+        #[cfg(feature = "http")]
+        "http" => match http::main(&args[1..]) {
+            Ok(true) => Ok(()),
+            Ok(false) => return ExitCode::from(1),
+            Err(e) => Err(e),
+        },
+        #[cfg(not(feature = "http"))]
+        "http" => Err("built without http: `wai http` needs a build with the feature `http`".into()),
         _ => { usage(); return ExitCode::from(2); }
     };
     match r {
diff --git a/wai/wai-rs/src/bin/wai_cli/http.rs b/wai/wai-rs/src/bin/wai_cli/http.rs
new file mode 100644
index 000000000..0fd7fee3e
--- /dev/null
+++ b/wai/wai-rs/src/bin/wai_cli/http.rs
@@ -0,0 +1,661 @@
+//! `wai http …` — HTTP delivery (`extensions/http-delivery.md`):
+//!
+//!   wai http publish <in.wai>… --out <dir>
+//!       write `<cid>.wai`, `<cid>.wai.hp` and `<cid>.wai.etag` for each envelope and
+//!       print its cid, `n`, `h` and `codecs` element
+//!   wai http codecs <in.wai>…
+//!       print the union and the floor of the sequence (§4.2)
+//!   wai http origin --root <dir> [--port P] [--delay-range FIRST-LAST:MS]
+//!                   [--live-prefix PATH/ --live-max-age S] [--count-hits]
+//!                   [--max-connections N] [--read-timeout-ms MS] [--max-connection-ms MS]
+//!                   [--max-per-peer N]
+//!       serve the directory as an origin (§5.3, §6.2, §8): objects with their headers,
+//!       byte ranges and `If-Range`, head proofs, receipt files, indexes, key logs and
+//!       grants, and preflights, on 127.0.0.1; objects under the live prefix with the
+//!       shorter `max-age`; with --count-hits, `GET /__hits?path=P` answers how many
+//!       requests for P reached the origin (a test aid). It reads at most 16 KiB of a
+//!       request head (431 past it); the whole head must arrive within --read-timeout-ms
+//!       of the connection's accept (10 s; 408 then), however slowly it trickles; a
+//!       connection lives at most --max-connection-ms from its accept (60 s), whatever
+//!       it is doing, so a peer that reads a large response slowly is cut off then; it
+//!       serves --max-connections at once (64), answering 503 to one more. A cap per
+//!       peer address, --max-per-peer, is off unless given: this origin listens on
+//!       127.0.0.1 only, where every client has the same address, so such a cap would
+//!       let a few clients that keep reconnecting shut every other client out. It
+//!       answers 400 to a
+//!       path segment that is empty, `.` or `..`, or holds `\`, `:`, NUL or a control
+//!       byte
+//!   wai http vectors gen|verify|diff …
+//!       the corpus tool (as `wai_http_vectors`)
+//!   wai http bench --url http://HOST:PORT/PATH[#frag] --runs N --advertise CAP… --out F
+//!                  [--refinement-deadline-ms MS]
+//!       fetch an object N times by §7 over plain HTTP and write a measurement record:
+//!       body bytes by category, header bytes, requests, the time until the base verified
+//!       (`ms_to_verified`, from the session's `base_ready`) and until the fetch ended
+//!       (`ms_to_complete`); base-class requests go first, and a refinement past its
+//!       deadline from the base's verification is abandoned. Energy is recorded as not
+//!       measured
+
+use std::io::{Read, Write};
+use std::net::{TcpListener, TcpStream};
+use std::path::PathBuf;
+use std::time::{Duration, Instant};
+
+use serde_json::json;
+
+use wai::http_binding::codecs;
+use wai::http_binding::head::{parse_head, HeadParse};
+use wai::http_binding::head_proof::HeadProof;
+use wai::http_binding::origin;
+use wai::http_binding::plan::FetchPolicy;
+use wai::http_binding::session::{FetchSession, ResponseMeta, Selector, Want};
+use wai::http_binding::{content_hash, hex, object_name, parse_fragment, unhex32};
+
+fn opt<'a>(args: &'a [String], flag: &str) -> Option<&'a str> {
+    args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).map(String::as_str))
+}
+
+/// The positional arguments: everything not a flag or a flag's value.
+fn positional(args: &[String], flags: &[&str]) -> Vec<String> {
+    let mut out = Vec::new();
+    let mut i = 0;
+    while i < args.len() {
+        if flags.contains(&args[i].as_str()) {
+            i += 2;
+        } else {
+            out.push(args[i].clone());
+            i += 1;
+        }
+    }
+    out
+}
+
+fn usage() -> String {
+    "usage: wai http publish <in.wai>… --out <dir>\n       wai http codecs <in.wai>…\n       wai http origin --root <dir> [--port P] [--delay-range FIRST-LAST:MS]\n       wai http vectors gen|verify|diff …\n       wai http bench --url URL --runs N --advertise CAP [--advertise CAP]… --out F".into()
+}
+
+pub fn main(args: &[String]) -> Result<bool, String> {
+    match args.first().map(String::as_str) {
+        Some("publish") => publish(&args[1..]).map(|()| true),
+        Some("codecs") => codecs_cmd(&args[1..]).map(|()| true),
+        Some("origin") => origin_cmd(&args[1..]).map(|()| true),
+        Some("vectors") => crate::http_vectors::main(&args[1..]),
+        Some("bench") => bench(&args[1..]).map(|()| true),
+        _ => Err(usage()),
+    }
+}
+
+fn read(p: &str) -> Result<Vec<u8>, String> {
+    std::fs::read(p).map_err(|e| format!("{p}: {e}"))
+}
+
+fn publish(args: &[String]) -> Result<(), String> {
+    let out = PathBuf::from(opt(args, "--out").ok_or("publish needs --out <dir>")?);
+    std::fs::create_dir_all(&out).map_err(|e| e.to_string())?;
+    let inputs = positional(args, &["--out"]);
+    if inputs.is_empty() {
+        return Err(usage());
+    }
+    for p in inputs {
+        let env = read(&p)?;
+        let head = match parse_head(&env, env.len() as u64).map_err(|e| format!("{p}: {e}"))? {
+            HeadParse::Head(h) => h,
+            HeadParse::Need(n) => return Err(format!("{p}: the head needs {n} bytes")),
+        };
+        let cid = content_hash(&env);
+        let name = object_name(&cid);
+        let proof = HeadProof::build(&env).map_err(|e| format!("{p}: {e}"))?;
+        std::fs::write(out.join(&name), &env).map_err(|e| e.to_string())?;
+        std::fs::write(out.join(format!("{name}.hp")), proof.to_bytes()).map_err(|e| e.to_string())?;
+        std::fs::write(out.join(format!("{name}.etag")), format!("\"{}\"\n", hex(&cid))).map_err(|e| e.to_string())?;
+        let element = codecs::element_of(&head).map(|e| codecs::render(&e)).unwrap_or_else(|e| format!("({e})"));
+        println!("{}\tn={}\th={}\t{element}\t{p}", hex(&cid), env.len(), head.covered_len());
+    }
+    Ok(())
+}
+
+fn codecs_cmd(args: &[String]) -> Result<(), String> {
+    let mut objects = Vec::new();
+    for p in args {
+        let env = read(p)?;
+        objects.push(codecs::SeqObject::from_envelope(&env).map_err(|e| format!("{p}: {e}"))?);
+    }
+    let union = codecs::union_of(&objects).map_err(|e| e.to_string())?;
+    let floor = codecs::floor_of(&objects).map_err(|e| e.to_string())?;
+    println!("union\t{}", codecs::render(&union));
+    println!("floor\t{}", codecs::render(&floor));
+    Ok(())
+}
+
+// ------------------------------------------------------------------ the origin
+
+/// A request as the origin reads it.
+struct Request {
+    method: String,
+    path: String,
+    query: String,
+    headers: Vec<(String, String)>,
+}
+
+impl Request {
+    fn header(&self, name: &str) -> Option<&str> {
+        self.headers.iter().find(|(k, _)| k.eq_ignore_ascii_case(name)).map(|(_, v)| v.as_str())
+    }
+}
+
+/// The most bytes of a request head (request line and header fields) the origin reads.
+const MAX_HEAD: u64 = 16 * 1024;
+/// How many connections the origin serves at once, unless `--max-connections` says.
+const DEFAULT_MAX_CONNECTIONS: usize = 64;
+/// How long a connection may live, counted from its accept, unless
+/// `--max-connection-ms` says: reading its head, and writing its answer to a peer that
+/// reads slowly, end there.
+const DEFAULT_MAX_CONNECTION_MS: u64 = 60_000;
+/// How long a whole request head may take to arrive, counted from the connection's
+/// accept, unless `--read-timeout-ms` says. No single read waits longer either.
+const DEFAULT_READ_TIMEOUT_MS: u64 = 10_000;
+
+/// What reading a request gave.
+enum Read1 {
+    Request(Request),
+    /// The head passed [`MAX_HEAD`] bytes.
+    TooLarge,
+    /// The head did not arrive whole before its deadline.
+    TimedOut,
+    /// The head is not a request this origin reads.
+    Bad,
+    /// The peer closed before a whole head arrived.
+    Closed,
+}
+
+/// Read one request head through `Read::take`, never more than [`MAX_HEAD`] bytes of it,
+/// and never past `deadline`, a time fixed when the connection was accepted: each read
+/// waits at most until then, so a peer that sends a byte at a time cannot hold the
+/// connection longer than one deadline.
+fn read_request(stream: &TcpStream, deadline: Instant) -> Read1 {
+    let mut limited = stream.take(MAX_HEAD);
+    let mut buf: Vec<u8> = Vec::with_capacity(1024);
+    let mut chunk = [0u8; 4096];
+    let end = loop {
+        if let Some(i) = buf.windows(4).position(|w| w == b"\r\n\r\n") {
+            break i + 2;
+        }
+        if let Some(i) = buf.windows(2).position(|w| w == b"\n\n") {
+            break i + 1;
+        }
+        if buf.len() as u64 >= MAX_HEAD {
+            return Read1::TooLarge;
+        }
+        let now = Instant::now();
+        if now >= deadline {
+            return Read1::TimedOut;
+        }
+        if stream.set_read_timeout(Some((deadline - now).max(Duration::from_millis(1)))).is_err() {
+            return Read1::Closed;
+        }
+        match limited.read(&mut chunk) {
+            Ok(0) => return if buf.len() as u64 >= MAX_HEAD { Read1::TooLarge } else { Read1::Closed },
+            Ok(n) => buf.extend_from_slice(&chunk[..n]),
+            Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut | std::io::ErrorKind::Interrupted) => {}
+            Err(_) => return Read1::Closed,
+        }
+    };
+    let lines: Vec<&[u8]> = buf[..end].split(|&b| b == b'\n').map(|l| l.strip_suffix(b"\r").unwrap_or(l)).filter(|l| !l.is_empty()).collect();
+    let Some(first) = lines.first() else { return Read1::Bad };
+    let Ok(first) = std::str::from_utf8(first) else { return Read1::Bad };
+    let mut parts = first.split(' ');
+    let (Some(method), Some(target), Some(version), None) = (parts.next(), parts.next(), parts.next(), parts.next()) else { return Read1::Bad };
+    if !version.starts_with("HTTP/1.") {
+        return Read1::Bad;
+    }
+    let mut headers = Vec::new();
+    for h in &lines[1..] {
+        let h = String::from_utf8_lossy(h);
+        if let Some((k, v)) = h.split_once(':') {
+            headers.push((k.trim().to_string(), v.trim().to_string()));
+        }
+    }
+    let target = target.split('#').next().unwrap_or("/");
+    let (path, query) = target.split_once('?').unwrap_or((target, ""));
+    Read1::Request(Request { method: method.to_string(), path: path.to_string(), query: query.to_string(), headers })
+}
+
+/// Whether a request path names a file under the root: segments that are not empty,
+/// `.` or `..`, and hold no `\`, `:`, NUL or other control byte (so no other directory,
+/// drive or device is named, on any host).
+fn path_ok(path: &str) -> bool {
+    let Some(rel) = path.strip_prefix('/') else { return false };
+    !rel.is_empty()
+        && rel.split('/').all(|seg| {
+            !seg.is_empty() && seg != "." && seg != ".." && !seg.bytes().any(|b| b == b'\\' || b == b':' || b < 0x20 || b == 0x7f)
+        })
+}
+
+/// How the origin is configured.
+#[derive(Clone)]
+struct OriginConfig {
+    root: PathBuf,
+    delay: Option<(u64, u64, u64)>,
+    live: Option<(String, u64)>,
+    hits: Option<std::sync::Arc<std::sync::Mutex<std::collections::BTreeMap<String, u64>>>>,
+    max_connections: usize,
+    /// Off (`None`) unless `--max-per-peer` gives it: on a loopback listener every client
+    /// has one address.
+    max_per_peer: Option<usize>,
+    read_timeout: Duration,
+    /// A connection's whole lifetime from its accept.
+    lifetime: Duration,
+    active: std::sync::Arc<std::sync::atomic::AtomicUsize>,
+    peers: std::sync::Arc<std::sync::Mutex<std::collections::HashMap<std::net::IpAddr, usize>>>,
+}
+
+/// What the origin serves at `path` under `root`: the file and its headers, by the
+/// kind of resource its name says it is (§5.3, §6.2, §8).
+fn resource(cfg: &OriginConfig, path: &str) -> Option<(Vec<u8>, Vec<(&'static str, String)>)> {
+    let root = &cfg.root;
+    if !path_ok(path) {
+        return None;
+    }
+    let rel = path.trim_start_matches('/');
+    let file = root.join(rel);
+    let bytes = std::fs::read(&file).ok()?;
+    let name = file.file_name()?.to_str()?;
+    let headers = if let Some(stem) = name.strip_suffix(".wai") {
+        let cid = unhex32(stem).unwrap_or_else(|| content_hash(&bytes));
+        let codecs = parse_head(&bytes, bytes.len() as u64).ok().and_then(|h| match h {
+            HeadParse::Head(h) => codecs::element_of(&h).ok().map(|e| codecs::render(&e)),
+            HeadParse::Need(_) => None,
+        });
+        match &cfg.live {
+            Some((prefix, max_age)) if rel.starts_with(prefix.as_str()) => origin::live_object_headers(&cid, codecs.as_deref(), *max_age),
+            _ => origin::object_headers(&cid, codecs.as_deref()),
+        }
+    } else if rel.starts_with(".well-known/wai-") {
+        origin::key_resource_headers()
+    } else if name.ends_with(".wai.hp") {
+        origin::immutable_headers("application/octet-stream")
+    } else if name.ends_with(".wai.receipts") {
+        vec![
+            ("Content-Type", "application/json".to_string()),
+            ("Cache-Control", "no-cache, no-transform".to_string()),
+            ("ETag", format!("\"{}\"", hex(&content_hash(&bytes)))),
+            ("Access-Control-Allow-Origin", "*".to_string()),
+        ]
+    } else if name.ends_with(".json") {
+        origin::immutable_headers("application/json")
+    } else {
+        origin::immutable_headers("application/octet-stream")
+    };
+    Some((bytes, headers))
+}
+
+/// Write `bytes` to `s`, never past `until` (the end of the connection's lifetime): in
+/// pieces, each write waiting at most until then, so a peer that reads slowly cannot hold
+/// the connection longer.
+fn write_until(mut s: &TcpStream, until: Instant, mut bytes: &[u8]) -> std::io::Result<()> {
+    while !bytes.is_empty() {
+        let now = Instant::now();
+        if now >= until {
+            return Err(std::io::Error::new(std::io::ErrorKind::TimedOut, "the connection's lifetime ended"));
+        }
+        s.set_write_timeout(Some((until - now).max(Duration::from_millis(1))))?;
+        match s.write(&bytes[..bytes.len().min(64 * 1024)]) {
+            Ok(0) => return Err(std::io::ErrorKind::WriteZero.into()),
+            Ok(n) => bytes = &bytes[n..],
+            Err(e) if e.kind() == std::io::ErrorKind::Interrupted => {}
+            Err(e) => return Err(e),
+        }
+    }
+    Ok(())
+}
+
+fn respond(s: &TcpStream, until: Instant, status: u16, headers: &[(&str, String)], body: &[u8], head_only: bool) -> std::io::Result<()> {
+    let reason = match status {
+        200 => "OK",
+        204 => "No Content",
+        206 => "Partial Content",
+        404 => "Not Found",
+        400 => "Bad Request",
+        405 => "Method Not Allowed",
+        408 => "Request Timeout",
+        416 => "Range Not Satisfiable",
+        431 => "Request Header Fields Too Large",
+        503 => "Service Unavailable",
+        _ => "Status",
+    };
+    let mut out = format!("HTTP/1.1 {status} {reason}\r\n");
+    for (k, v) in headers {
+        out.push_str(&format!("{k}: {v}\r\n"));
+    }
+    out.push_str(&format!("Content-Length: {}\r\nConnection: close\r\n\r\n", body.len()));
+    write_until(s, until, out.as_bytes())?;
+    if !head_only {
+        write_until(s, until, body)?;
+    }
+    Ok(())
+}
+
+fn serve_one(cfg: &OriginConfig, stream: TcpStream, accepted: Instant) -> std::io::Result<()> {
+    let until = accepted + cfg.lifetime;
+    let req = match read_request(&stream, (accepted + cfg.read_timeout).min(until)) {
+        Read1::Request(r) => r,
+        Read1::TimedOut => return respond(&stream, until, 408, &[], b"request head not received in time\n", false),
+        Read1::TooLarge => {
+            // Answer, then stop sending and read a little more before closing, so the
+            // answer is not lost to a reset while the client is still writing.
+            respond(&stream, until, 431, &[], b"request head too large\n", false)?;
+            let _ = stream.shutdown(std::net::Shutdown::Write);
+            let _ = stream.set_read_timeout(Some(Duration::from_millis(200)));
+            let mut sink = [0u8; 64 * 1024];
+            let (t0, mut drained) = (Instant::now(), 0usize);
+            while t0.elapsed() < Duration::from_secs(1) && drained < 1 << 20 {
+                match (&stream).read(&mut sink) {
+                    Ok(n) if n > 0 => drained += n,
+                    _ => break,
+                }
+            }
+            return Ok(());
+        }
+        Read1::Bad => return respond(&stream, until, 400, &[], b"bad request\n", false),
+        Read1::Closed => return Ok(()),
+    };
+    let s = stream;
+    if let Some(hits) = &cfg.hits {
+        if req.path == "/__hits" {
+            let want = req.query.strip_prefix("path=").map(percent_decode).unwrap_or_default();
+            let n = hits.lock().map(|h| h.get(&want).copied().unwrap_or(0)).unwrap_or(0);
+            return respond(&s, until, 200, &[("Cache-Control", "no-store".to_string())], n.to_string().as_bytes(), false);
+        }
+        if let Ok(mut h) = hits.lock() {
+            *h.entry(req.path.clone()).or_insert(0) += 1;
+        }
+    }
+    if req.method == "OPTIONS" {
+        return respond(&s, until, 204, &origin::preflight_headers(), &[], false);
+    }
+    if req.method != "GET" && req.method != "HEAD" {
+        return respond(&s, until, 405, &[("Allow", "GET, HEAD, OPTIONS".to_string())], &[], false);
+    }
+    if !path_ok(&req.path) {
+        return respond(&s, until, 400, &[], b"bad path\n", req.method == "HEAD");
+    }
+    let Some((bytes, mut headers)) = resource(cfg, &req.path) else {
+        return respond(&s, until, 404, &[("Cache-Control", "no-store".to_string())], b"not found\n", req.method == "HEAD");
+    };
+    let etag = headers.iter().find(|(k, _)| *k == "ETag").map(|(_, v)| v.clone()).unwrap_or_default();
+    let range = if req.path.ends_with(".wai") && origin::if_range_allows(req.header("If-Range"), &etag) { req.header("Range") } else { None };
+    let a = origin::serve(bytes.len() as u64, range);
+    if let Some(cr) = &a.content_range {
+        headers.push(("Content-Range", cr.clone()));
+    }
+    if let (Some((first, last, ms)), Some(_)) = (cfg.delay, &a.content_range) {
+        if a.body.start <= last && first < a.body.end {
+            std::thread::sleep(Duration::from_millis(ms));
+        }
+    }
+    respond(&s, until, a.status, &headers, &bytes[a.body.start as usize..a.body.end as usize], req.method == "HEAD")
+}
+
+fn origin_cmd(args: &[String]) -> Result<(), String> {
+    let root = PathBuf::from(opt(args, "--root").ok_or("origin needs --root <dir>")?);
+    let port: u16 = opt(args, "--port").map_or(Ok(8380), str::parse).map_err(|e| format!("--port: {e}"))?;
+    let delay = match opt(args, "--delay-range") {
+        None => None,
+        Some(s) => {
+            let (r, ms) = s.split_once(':').ok_or("--delay-range FIRST-LAST:MS")?;
+            let (a, b) = r.split_once('-').ok_or("--delay-range FIRST-LAST:MS")?;
+            Some((a.parse().map_err(|_| "--delay-range")?, b.parse().map_err(|_| "--delay-range")?, ms.parse().map_err(|_| "--delay-range")?))
+        }
+    };
+    let live = match (opt(args, "--live-prefix"), opt(args, "--live-max-age")) {
+        (Some(p), Some(s)) => Some((p.trim_start_matches('/').to_string(), s.parse().map_err(|_| "--live-max-age")?)),
+        (None, None) => None,
+        _ => return Err("--live-prefix and --live-max-age go together".into()),
+    };
+    let hits = args.iter().any(|a| a == "--count-hits").then(Default::default);
+    let max_connections = opt(args, "--max-connections").map_or(Ok(DEFAULT_MAX_CONNECTIONS), str::parse).map_err(|e| format!("--max-connections: {e}"))?;
+    let read_timeout = Duration::from_millis(opt(args, "--read-timeout-ms").map_or(Ok(DEFAULT_READ_TIMEOUT_MS), str::parse).map_err(|e| format!("--read-timeout-ms: {e}"))?);
+    let lifetime = Duration::from_millis(opt(args, "--max-connection-ms").map_or(Ok(DEFAULT_MAX_CONNECTION_MS), str::parse).map_err(|e| format!("--max-connection-ms: {e}"))?);
+    let max_per_peer = opt(args, "--max-per-peer").map(str::parse).transpose().map_err(|e| format!("--max-per-peer: {e}"))?;
+    let active = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
+    let cfg = OriginConfig { root: root.clone(), delay, live, hits, max_connections, max_per_peer, read_timeout, lifetime, active, peers: Default::default() };
+    let listener = TcpListener::bind(("127.0.0.1", port)).map_err(|e| format!("bind 127.0.0.1:{port}: {e}"))?;
+    println!("serving {} on http://127.0.0.1:{}/", root.display(), listener.local_addr().map_err(|e| e.to_string())?.port());
+    for stream in listener.incoming().flatten() {
+        let accepted = Instant::now();
+        let cfg = cfg.clone();
+        std::thread::spawn(move || {
+            use std::sync::atomic::Ordering;
+            let busy = |stream: &TcpStream| {
+                let _ = respond(stream, Instant::now() + cfg.read_timeout, 503, &[("Retry-After", "1".to_string())], b"busy\n", false);
+            };
+            // At most `max_connections` in all and, when `--max-per-peer` is given, that
+            // many from one address; one more is told so and closed.
+            let peer = cfg.max_per_peer.and_then(|_| stream.peer_addr().map(|a| a.ip()).ok());
+            if let (Some(ip), Some(max)) = (peer, cfg.max_per_peer) {
+                let mut peers = cfg.peers.lock().unwrap_or_else(|e| e.into_inner());
+                let n = peers.entry(ip).or_insert(0);
+                if *n >= max {
+                    drop(peers);
+                    return busy(&stream);
+                }
+                *n += 1;
+            }
+            let release_peer = || {
+                if let Some(ip) = peer {
+                    let mut peers = cfg.peers.lock().unwrap_or_else(|e| e.into_inner());
+                    if let Some(n) = peers.get_mut(&ip) {
+                        *n -= 1;
+                        if *n == 0 {
+                            peers.remove(&ip);
+                        }
+                    }
+                }
+            };
+            if cfg.active.fetch_add(1, Ordering::SeqCst) >= cfg.max_connections {
+                cfg.active.fetch_sub(1, Ordering::SeqCst);
+                release_peer();
+                return busy(&stream);
+            }
+            let _ = serve_one(&cfg, stream, accepted);
+            cfg.active.fetch_sub(1, Ordering::SeqCst);
+            release_peer();
+        });
+    }
+    Ok(())
+}
+
+/// `%XX` escapes decoded byte by byte, `+` left as it is, and the result read as UTF-8
+/// with any invalid sequence replaced.
+fn percent_decode(s: &str) -> String {
+    let b = s.as_bytes();
+    let hex = |x: u8| (x as char).to_digit(16).map(|d| d as u8);
+    let mut out = Vec::with_capacity(b.len());
+    let mut i = 0;
+    while i < b.len() {
+        if b[i] == b'%' && i + 2 < b.len() {
+            if let (Some(h), Some(l)) = (hex(b[i + 1]), hex(b[i + 2])) {
+                out.push(h << 4 | l);
+                i += 3;
+                continue;
+            }
+        }
+        out.push(b[i]);
+        i += 1;
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+// ------------------------------------------------------------------- the bench
+
+/// One plain-HTTP exchange: the response's status and headers, its body, and the
+/// bytes of its status line and headers as received.
+/// [`get`] that gives up at `limit`: `Ok(None)` when the whole response has not arrived
+/// by then.
+fn get_within(host: &str, path: &str, range: Option<&str>, limit: Option<Instant>) -> Result<Option<(ResponseMeta, Vec<u8>, u64)>, String> {
+    let Some(limit) = limit else { return get(host, path, range, None).map(Some) };
+    match get(host, path, range, Some(limit)) {
+        Ok(r) => Ok(Some(r)),
+        Err(e) if e == "timed out" => Ok(None),
+        Err(e) => Err(e),
+    }
+}
+
+fn get(host: &str, path: &str, range: Option<&str>, limit: Option<Instant>) -> Result<(ResponseMeta, Vec<u8>, u64), String> {
+    let mut s = TcpStream::connect(host).map_err(|e| format!("{host}: {e}"))?;
+    let mut req = format!("GET {path} HTTP/1.1\r\nHost: {host}\r\nConnection: close\r\nAccept-Encoding: identity\r\n");
+    if let Some(r) = range {
+        req.push_str(&format!("Range: {r}\r\n"));
+    }
+    req.push_str("\r\n");
+    s.write_all(req.as_bytes()).map_err(|e| e.to_string())?;
+    let mut raw = Vec::new();
+    match limit {
+        None => {
+            s.read_to_end(&mut raw).map_err(|e| e.to_string())?;
+        }
+        Some(limit) => {
+            let mut chunk = [0u8; 64 * 1024];
+            loop {
+                let now = Instant::now();
+                if now >= limit {
+                    return Err("timed out".into());
+                }
+                s.set_read_timeout(Some(limit - now)).map_err(|e| e.to_string())?;
+                match s.read(&mut chunk) {
+                    Ok(0) => break,
+                    Ok(n) => raw.extend_from_slice(&chunk[..n]),
+                    Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => return Err("timed out".into()),
+                    Err(e) => return Err(e.to_string()),
+                }
+            }
+        }
+    }
+    let end = raw.windows(4).position(|w| w == b"\r\n\r\n").ok_or("no header end")? + 4;
+    let head = String::from_utf8_lossy(&raw[..end]).to_string();
+    let mut lines = head.lines();
+    let status: u16 = lines.next().and_then(|l| l.split_whitespace().nth(1)).and_then(|s| s.parse().ok()).ok_or("no status")?;
+    let mut meta = ResponseMeta { status, ..Default::default() };
+    for l in lines {
+        if let Some((k, v)) = l.split_once(':') {
+            match k.trim().to_ascii_lowercase().as_str() {
+                "content-range" => meta.content_range = Some(v.trim().to_string()),
+                "content-encoding" => meta.content_encoding = Some(v.trim().to_string()),
+                _ => {}
+            }
+        }
+    }
+    Ok((meta, raw[end..].to_vec(), end as u64))
+}
+
+fn median_iqr(mut v: Vec<f64>) -> serde_json::Value {
+    v.sort_by(|a, b| a.partial_cmp(b).expect("finite"));
+    let q = |p: f64| v[((v.len() - 1) as f64 * p).round() as usize];
+    json!({ "median": q(0.5), "iqr": [q(0.25), q(0.75)] })
+}
+
+fn bench(args: &[String]) -> Result<(), String> {
+    if opt(args, "--energy").is_some() {
+        return Err("--energy: this build brackets no meter around the fetch; run without it, and the record states energy as not measured".into());
+    }
+    let url = opt(args, "--url").ok_or("bench needs --url")?;
+    let runs: usize = opt(args, "--runs").unwrap_or("30").parse().map_err(|_| "--runs")?;
+    let out = opt(args, "--out").ok_or("bench needs --out")?;
+    let adv: Vec<String> = args.iter().enumerate().filter(|(_, a)| *a == "--advertise").filter_map(|(i, _)| args.get(i + 1).cloned()).collect();
+    let (base, frag) = parse_fragment(url);
+    let rest = base.strip_prefix("http://").ok_or("bench fetches over plain http:// only")?;
+    let (host, path) = rest.split_once('/').map(|(h, p)| (h.to_string(), format!("/{p}"))).ok_or("URL has no path")?;
+    let stem = path.rsplit('/').next().and_then(|n| n.strip_suffix(".wai")).ok_or("the URL names <cid>.wai")?;
+    let cid = frag.cid.or_else(|| unhex32(stem)).ok_or("no cid: name the object <cid>.wai or give #cid=")?;
+    let deadline: Option<u32> = opt(args, "--refinement-deadline-ms").map(str::parse).transpose().map_err(|_| "--refinement-deadline-ms")?;
+    let (mut ms, mut ms_all, mut media, mut proof, mut headers) = (Vec::new(), Vec::new(), Vec::new(), Vec::new(), Vec::new());
+    let mut last = None;
+    for _ in 0..runs {
+        let adv2 = adv.clone();
+        let policy = FetchPolicy { refinement_deadline_ms: deadline, ..FetchPolicy::default() };
+        let mut s = FetchSession::new(cid, frag.clone(), policy, Selector::new(move |c| adv2.iter().any(|a| a == c)));
+        let t0 = Instant::now();
+        let elapsed = |t0: Instant| t0.elapsed().as_millis() as u64;
+        let (mut b_media, mut b_proof, mut b_head) = (0u64, 0u64, 0u64);
+        let mut t_base: Option<f64> = None;
+        while s.result().is_none() {
+            let mut wants = s.wants();
+            if wants.is_empty() {
+                // A refinement left outstanding when nothing else is wanted: abandoned.
+                for id in s.outstanding_of(wai::http_binding::plan::Class::Refinement) {
+                    s.on_deadline(id);
+                }
+                if s.result().is_none() {
+                    return Err("the fetch stalled".into());
+                }
+                break;
+            }
+            // Base-class requests first: a refinement never delays its base (§10.1).
+            wants.sort_by_key(|(_, w)| w.class());
+            for (id, w) in wants {
+                // The refinement deadline runs from the base's verification (§10.2).
+                if s.tick(elapsed(t0)).contains(&id) || s.result().is_some() {
+                    continue;
+                }
+                let (p, range) = match &w {
+                    Want::HeadProof => (format!("{path}.hp"), None),
+                    Want::Whole(_) => (path.clone(), None),
+                    Want::Range(r, _) => (path.clone(), Some(r.header())),
+                    Want::Rest(r, _) => (path.clone(), Some(format!("bytes={}-", r.first))),
+                };
+                // A refinement's request may take only what is left of its deadline.
+                let limit = match (w.class(), s.base_ready_at(), deadline) {
+                    (wai::http_binding::plan::Class::Refinement, Some(at), Some(d)) => Some(t0 + Duration::from_millis(at + u64::from(d))),
+                    _ => None,
+                };
+                let Some((meta, body, hb)) = get_within(&host, &p, range.as_deref(), limit)? else {
+                    s.tick(elapsed(t0));
+                    s.on_deadline(id);
+                    continue;
+                };
+                b_head += hb;
+                if matches!(w, Want::HeadProof) { b_proof += body.len() as u64 } else { b_media += body.len() as u64 }
+                let now = elapsed(t0);
+                s.tick(now);
+                if let Err(e) = s.on_response(id, &meta, &body, now) {
+                    return Err(format!("refused: {e}"));
+                }
+                if t_base.is_none() && s.base_ready().is_some() {
+                    t_base = Some(t0.elapsed().as_secs_f64() * 1000.0);
+                }
+            }
+        }
+        ms.push(t_base.unwrap_or_else(|| t0.elapsed().as_secs_f64() * 1000.0));
+        ms_all.push(t0.elapsed().as_secs_f64() * 1000.0);
+        media.push(b_media as f64);
+        proof.push(b_proof as f64);
+        headers.push(b_head as f64);
+        last = s.done().cloned();
+    }
+    let f = last.ok_or("no run completed")?;
+    let rec = json!({
+        "tool": "wai-http-bench",
+        "git": opt(args, "--git").unwrap_or("unknown"),
+        "env": { "os": std::env::consts::OS, "arch": std::env::consts::ARCH, "browser": null,
+                 "network": if host.starts_with("127.0.0.1") || host.starts_with("localhost") { "loopback" } else { "site" },
+                 "condition": "origin, no cache" },
+        "object": hex(&cid),
+        "plan": match f.why_whole { Some(w) => format!("whole ({})", w.code()), None => "ranges".into() },
+        "pick": f.index,
+        "runs": runs,
+        "body_bytes_media": median_iqr(media),
+        "body_bytes_proof": median_iqr(proof),
+        "header_bytes": median_iqr(headers),
+        "envelope_len": f.head.envelope_len,
+        "component_len": f.head.components.get(f.index).map(|c| c.len),
+        "requests": f.requests,
+        "ms_to_verified": median_iqr(ms),
+        "ms_to_complete": median_iqr(ms_all),
+        "refinements_abandoned": f.abandoned,
+        "refinement_deadline_ms": deadline,
+        "energy": "omitted: not measured",
+    });
+    std::fs::write(out, serde_json::to_string_pretty(&rec).expect("json") + "\n").map_err(|e| e.to_string())?;
+    println!("wrote {out}");
+    Ok(())
+}
diff --git a/wai/wai-rs/src/bin/wai_cli/http_vectors.rs b/wai/wai-rs/src/bin/wai_cli/http_vectors.rs
new file mode 100644
index 000000000..338a90589
--- /dev/null
+++ b/wai/wai-rs/src/bin/wai_cli/http_vectors.rs
@@ -0,0 +1,1692 @@
+//! The HTTP delivery corpus (`extensions/http-delivery.md` §14, `wai/http-conformance/`):
+//!
+//!   gen    <dir>                         write every object, head proof, case proof,
+//!                                        `objects.json` and `cases.json`
+//!   verify <dir>                         regenerate every file in memory and require the
+//!                                        committed bytes; evaluate every case and require
+//!                                        its committed outcome; print each failing case
+//!   diff   <dir> --seed S --count N --out F
+//!                                        write N random envelopes' covered prefixes and
+//!                                        head proofs, as JSON lines, for http_verify.py
+//!   fuzz   <dir> --seed S --count N --out F
+//!                                        write about N seeded cases per input family
+//!                                        (Content-Range, codecs, #WAI-LAYER, manifests and
+//!                                        their member types, encryption, refines, layer
+//!                                        sequences) with this build's outcomes, in the
+//!                                        corpus's case format, for `http_verify.py cases`
+//!
+//! Every object is built from the frozen sources in `src/` (whose SHA-256 values
+//! `src/SOURCES.json` states and `verify` checks), two committed vectors of this tree,
+//! and payloads computed here; every case's outcome is computed by `wai::http_binding`,
+//! and the negative cases are held, at generation, to the reason they exist for.
+
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+use serde_json::{json, Value};
+
+use wai::container::{Prior, Rendition, RenditionMeta, Skip, Wai, WaiMulti};
+use wai::http_binding::codecs::{self, Prefix, SeqObject};
+use wai::http_binding::head::{parse_head, Head, HeadParse};
+use wai::http_binding::head_proof::HeadProof;
+use wai::http_binding::origin;
+use wai::http_binding::plan::{plan_components, Class, FetchPolicy, WhyWhole};
+use wai::http_binding::session::{check_response, drive, FetchSession, Fetched, ResponseMeta, Selector, Want};
+use wai::http_binding::{content_hash, hex, parse_fragment, ByteRange, RangeRefusal};
+use wai::pin::HeldBytes;
+
+/// The committed vectors the corpus carries objects of, relative to the corpus.
+const STREAM_WAI: &str = "../wai-rs/tests/vectors/int_mlicpp/stream.wai";
+const MLICPP_SET: &str = "../wai-rs/tests/vectors/int_mlicpp/model.wmb";
+const INT_HYPER_WAI: &str = "../staged-conformance/cases/video_int_hyper_keyframe/base.wai";
+/// A staged-delivery stage set: a FLAC base and two layers over it.
+const LADDER: &str = "../staged-conformance/cases/audio_flac_rate_ladder";
+
+/// Forms the corpus's sink reads (SPEC §3.1): the set listing form.
+const READABLE: &[&str] = &["wai.prior.set"];
+
+fn usage() -> String {
+    "usage: wai_http_vectors gen|verify <http-conformance dir>\n       wai_http_vectors diff|fuzz <dir> --seed S --count N --out F".into()
+}
+
+fn opt<'a>(args: &'a [String], flag: &str) -> Option<&'a str> {
+    args.iter().position(|a| a == flag).and_then(|i| args.get(i + 1).map(String::as_str))
+}
+
+/// Run the tool on `args` (after the program or subcommand name). `Ok(false)`: a
+/// verification failed.
+pub fn main(args: &[String]) -> Result<bool, String> {
+    match (args.first().map(String::as_str), args.get(1)) {
+        (Some("gen"), Some(dir)) => {
+            let dir = PathBuf::from(dir);
+            let files = generate(&dir)?;
+            for (rel, bytes) in &files {
+                let p = dir.join(rel);
+                std::fs::create_dir_all(p.parent().expect("a parent")).map_err(|e| e.to_string())?;
+                std::fs::write(&p, bytes).map_err(|e| format!("{}: {e}", p.display()))?;
+            }
+            println!("wrote {} files under {}", files.len(), dir.display());
+            Ok(true)
+        }
+        (Some("verify"), Some(dir)) => verify(Path::new(dir)),
+        (Some("fuzz"), Some(dir)) => {
+            let seed: u64 = opt(args, "--seed").and_then(|s| s.parse().ok()).ok_or("fuzz needs --seed")?;
+            let count: usize = opt(args, "--count").and_then(|s| s.parse().ok()).ok_or("fuzz needs --count")?;
+            let out = opt(args, "--out").ok_or("fuzz needs --out")?;
+            let (bytes, n, stats) = fuzz(Path::new(dir), seed, count)?;
+            std::fs::write(out, bytes).map_err(|e| e.to_string())?;
+            println!("wrote {n} cases to {out}");
+            for (family, (generated, refused)) in &stats {
+                println!("  {family}: {generated} generated, {refused} refused");
+            }
+            Ok(true)
+        }
+        (Some("diff"), Some(dir)) => {
+            let seed: u64 = opt(args, "--seed").and_then(|s| s.parse().ok()).ok_or("diff needs --seed")?;
+            let count: usize = opt(args, "--count").and_then(|s| s.parse().ok()).ok_or("diff needs --count")?;
+            let out = opt(args, "--out").ok_or("diff needs --out")?;
+            let _ = dir;
+            std::fs::write(out, differential(seed, count)?).map_err(|e| e.to_string())?;
+            println!("wrote {count} envelopes' prefixes and proofs to {out}");
+            Ok(true)
+        }
+        _ => Err(usage()),
+    }
+}
+
+// ---------------------------------------------------------------- the objects
+
+fn read(dir: &Path, rel: &str) -> Result<Vec<u8>, String> {
+    std::fs::read(dir.join(rel)).map_err(|e| format!("{}: {e}", dir.join(rel).display()))
+}
+
+fn pattern(len: usize, a: usize, b: usize) -> Vec<u8> {
+    (0..len).map(|i| ((a * i + b) % 256) as u8).collect()
+}
+
+/// A start-code-delimited byte stream of synthetic NAL units: transport only, it
+/// decodes to nothing.
+fn annex_b(len: usize, nal_header: u8, a: usize, b: usize) -> Vec<u8> {
+    let mut out = vec![0, 0, 0, 1, nal_header];
+    // No 0x000001 or 0x000000 inside: every third byte is at least 0x80.
+    out.extend((0..len - 5).map(|i| (((a * i + b) % 256) as u8) | if i % 3 == 2 { 0x80 } else { 0 }));
+    out
+}
+
+fn sha(b: &[u8]) -> String {
+    wai::pin::sha256_hex(b)
+}
+
+/// The corpus's objects, by id: `(id, bytes, what it covers)`.
+fn objects(dir: &Path) -> Result<Vec<(&'static str, Vec<u8>, &'static str)>, String> {
+    let src = |name: &str| read(dir, &format!("src/{name}"));
+    let stream = Wai::from_bytes(&read(dir, STREAM_WAI)?).map_err(|e| e.to_string())?;
+    let ih = Wai::from_bytes(&read(dir, INT_HYPER_WAI)?).map_err(|e| e.to_string())?;
+    let mlicpp_prior: Prior = stream.prior().cloned().ok_or("stream.wai has a pin")?;
+    let ih_prior: Prior = ih.prior().cloned().ok_or("the int_hyper base has a pin")?;
+    let target = |w: u64, h: u64| json!({ "w": w, "h": h });
+    let w2 = |media: &str, target: Value, r: Vec<Rendition>| WaiMulti::new(media, "replicate", target, r).to_bytes().map_err(|e| e.to_string());
+    let av1 = |name: &str, id: &str| -> Result<Rendition, String> { Ok(Rendition::media("wai.video.av1", "av1", src(name)?).with_id(id)) };
+    let (low, high) = ("pattern_low.av1", "pattern_high.av1");
+
+    let o1 = read(dir, STREAM_WAI)?;
+    let o2 = w2("image", target(64, 64), vec![
+        Rendition::media("wai.neural.int_mlicpp", "int_mlicpp", stream.payload.clone()).with_prior(mlicpp_prior).with_id("int").with_payload_digest(),
+        Rendition::media("wai.image.avif", "avif", src("image64.avif")?).with_id("avif").with_payload_digest(),
+        Rendition::media("wai.image.jxl", "jxl", src("image64.jxl")?).with_id("jxl").with_payload_digest(),
+        Rendition::media("wai.image.png", "png", src("image64.png")?).with_id("png").with_payload_digest(),
+    ])?;
+    let o3 = w2("video", target(320, 180), vec![
+        av1(low, "low")?.with_payload_digest(),
+        av1(high, "high")?.with_payload_digest(),
+        Rendition::companion("wai.meta.hdr10plus", pattern(200, 31, 1), "wai.video.av1").with_id("hdr").with_payload_digest().with_companion_of_id("high"),
+    ])?;
+    let o4 = w2("video", target(320, 180), vec![av1(low, "low")?, av1("seg0.av1", "b")?.with_payload_digest()])?;
+    let o5 = Wai::new(
+        wai::container::Manifest::new("text", "replicate", wai::container::ModelRequirement::new("wai.text.zstd"), wai::container::Conditioning::new("zstd")),
+        src("small.zst")?,
+    ).to_bytes().map_err(|e| e.to_string())?;
+    let mut wrong = av1(low, "low")?.with_payload_digest();
+    wrong.meta.sha256 = Some(sha(&src("seg0.av1")?));
+    let o7 = w2("video", target(320, 180), vec![wrong, av1("seg0.av1", "b")?.with_payload_digest()])?;
+    let o8 = w2("video", target(320, 180), vec![
+        Rendition::media("wai.video.avc", "avc", annex_b(8000, 0x65, 7, 11)).with_id("base").with_payload_digest(),
+        Rendition::from_meta(RenditionMeta::new("wai.video.lcevc", "lcevc").companion_to("wai.video.avc"), annex_b(20_000, 0x79, 13, 3))
+            .with_id("enh").with_payload_digest().with_companion_of_id("base"),
+        av1("seg1.av1", "alt")?.with_payload_digest(),
+    ])?;
+    WaiMulti::from_bytes(&o8).map_err(|e| e.to_string())?.check_component_roles()
+        .map_err(|e| format!("O8 is not admissible under SPEC §7.1's companion rules: {e:?}"))?;
+    let o9a = w2("video", target(320, 180), vec![
+        av1("seg0.av1", "av1")?.with_payload_digest(),
+        Rendition::media("wai.video.int_hyper", "int_hyper", ih.payload.clone()).with_prior(ih_prior).with_id("ih").with_payload_digest(),
+    ])?;
+    let seg = |name: &str| -> Result<Vec<u8>, String> {
+        Wai::new(
+            wai::container::Manifest::new("video", "replicate", wai::container::ModelRequirement::new("wai.video.av1"), wai::container::Conditioning::new("av1"))
+                .with_target(target(320, 180)),
+            src(name)?,
+        ).to_bytes().map_err(|e| e.to_string())
+    };
+    let od = w2("video", Value::Null, vec![
+        Rendition::media("wai.video.av1", "av1", pattern(3000, 7, 3)).with_id("low").with_payload_digest(),
+        Rendition::media("wai.video.av1", "av1", pattern(50_000, 13, 5)).with_id("high").with_payload_digest(),
+        Rendition::companion("wai.meta.hdr10plus", pattern(200, 31, 1), "wai.video.av1").with_id("hdr").with_payload_digest().with_companion_of_id("high"),
+    ])?;
+    let oh = w2("video", json!({ "w": 320, "h": 180, "note": "a manifest long enough that the head spans several chunks: ".to_string() + &"x".repeat(5000) }),
+        vec![av1("seg2.av1", "v")?.with_payload_digest()])?;
+    // Layers (§10.4): a staged-delivery base and its two layers, as committed.
+    let o10 = read(dir, &format!("{LADDER}/base.wai"))?;
+    let o10l1 = read(dir, &format!("{LADDER}/L1.wai"))?;
+    let o10l2 = read(dir, &format!("{LADDER}/L2.wai"))?;
+    // A base and an enhancement most of the object's size, the enhancement with a right,
+    // an absent and a wrong digest.
+    let enh = |digest: Option<bool>| -> Result<Vec<u8>, String> {
+        let mut e = Rendition::from_meta(RenditionMeta::new("wai.video.lcevc", "lcevc").companion_to("wai.video.avc"), annex_b(30_000, 0x79, 13, 3))
+            .with_id("enh").with_companion_of_id("base");
+        match digest {
+            Some(true) => e = e.with_payload_digest(),
+            Some(false) => e.meta.sha256 = Some(sha(b"not the enhancement")),
+            None => {}
+        }
+        w2("video", target(320, 180), vec![
+            Rendition::media("wai.video.avc", "avc", annex_b(8000, 0x65, 7, 11)).with_id("base").with_payload_digest(),
+            e,
+        ])
+    };
+    // Two small renditions the first request holds whole.
+    let ot = w2("video", Value::Null, vec![
+        Rendition::media("wai.video.av1", "av1", pattern(3000, 7, 3)).with_id("low").with_payload_digest(),
+        Rendition::media("wai.video.av1", "av1", pattern(9000, 13, 5)).with_id("high").with_payload_digest(),
+    ])?;
+    // A record capability with a payload fallback (SPEC §4 dispatches only the fallback).
+    let of = Wai::new(
+        wai::container::Manifest::new("text", "replicate",
+            wai::container::ModelRequirement::new("wai.video.manifest").with_fallback("wai.text.zstd"), wai::container::Conditioning::new("zstd")),
+        src("small.zst")?,
+    ).to_bytes().map_err(|e| e.to_string())?;
+    // SPEC §6.4: an encrypted WAI1, and two WAI2s whose `security` is not an object.
+    let oe1 = Wai::new(
+        wai::container::Manifest::new("text", "replicate", wai::container::ModelRequirement::new("wai.text.zstd"), wai::container::Conditioning::new("zstd"))
+            .with_security(wai::container::Security::new("aes-256-gcm", 1)),
+        src("small.zst")?,
+    ).to_bytes().map_err(|e| e.to_string())?;
+    let sec = |v: Value| -> Result<Vec<u8>, String> {
+        let mut m = wai::container::ManifestV2::new("text", "replicate", vec![RenditionMeta::new("wai.text.zstd", "zstd").with_id("a").with_sha256(sha(&pattern(5000, 7, 3)))]);
+        m.extra.insert("security".into(), v);
+        WaiMulti::from_parts(m, vec![pattern(5000, 7, 3)]).map_err(|e| e.to_string())?.to_bytes().map_err(|e| e.to_string())
+    };
+    // A refinement component whose `refines` is malformed: no refinement of its base.
+    let (b6, r3) = (pattern(6000, 7, 3), pattern(3000, 5, 1));
+    let mut rm = RenditionMeta::new("wai.video.int_refine", "int_refine").with_role("refinement").with_id("r").with_sha256(sha(&r3));
+    rm.refines = Some(json!({ "base": "b" }));
+    let or = WaiMulti::from_parts(
+        wai::container::ManifestV2::new("video", "replicate", vec![RenditionMeta::new("wai.video.int_motion", "int_motion").with_id("b").with_sha256(sha(&b6)), rm]),
+        vec![b6, r3],
+    ).map_err(|e| e.to_string())?.to_bytes().map_err(|e| e.to_string())?;
+    // A payload capability carrying `refines` is an ordinary object (staged delivery §3,
+    // §4.2, §10.4): `refines` false, `{}`, and well formed, naming O5.
+    let o5_cid = hex(&content_hash(&o5));
+    let with_refines = |r: Value| -> Result<Vec<u8>, String> {
+        let mut m = wai::container::Manifest::new("text", "replicate", wai::container::ModelRequirement::new("wai.text.zstd"), wai::container::Conditioning::new("zstd"));
+        m.refines = Some(r);
+        Wai::new(m, src("small.zst")?).to_bytes().map_err(|e| e.to_string())
+    };
+    // A refinement stating no sha256 over a base most of the object: dropped on the range
+    // path and on the whole path alike (§7 step 5, §10.3).
+    let (bn, rn) = (pattern(30_000, 7, 3), pattern(2300, 5, 1));
+    let mut rnm = RenditionMeta::new("wai.video.int_refine", "wir1").with_role("refinement").with_id("r");
+    rnm.refines = Some(json!({ "base": "b", "prev": "b", "layer": 1 }));
+    let orn = WaiMulti::from_parts(
+        wai::container::ManifestV2::new("video", "replicate", vec![RenditionMeta::new("wai.video.av1", "av1").with_id("b").with_sha256(sha(&bn)), rnm]),
+        vec![bn, rn],
+    ).map_err(|e| e.to_string())?.to_bytes().map_err(|e| e.to_string())?;
+    Ok(vec![
+        ("O1", o1, "WAI1, pinned, below one chunk is not reached: the head proof covers it whole"),
+        ("O2", o2, "WAI2 image: a pinned integer learned rendition, AVIF, JPEG XL and PNG of one picture"),
+        ("O3", o3, "WAI2 video: AV1 at two rates, HDR10+ metadata bound to the higher by id"),
+        ("O4", o4, "WAI2 whose first selectable entry states no sha256"),
+        ("O5", o5, "a small WAI1, fetched whole"),
+        ("O7", o7, "WAI2 whose first entry states a wrong sha256"),
+        ("O8", o8, "WAI2: an AVC base, an LCEVC enhancement bound to it, and an AV1 alternative"),
+        ("O9a", o9a, "segment 1 of 3: AV1 and an integer learned video rendition"),
+        ("O9b", seg("seg1.av1")?, "segment 2 of 3: AV1 only (WAI1)"),
+        ("O9c", seg("seg2.av1")?, "segment 3 of 3: AV1 only (WAI1)"),
+        ("OD", od, "Appendix D's synthetic envelope"),
+        ("OH", oh, "a WAI2 whose head spans several chunks"),
+        ("O10", o10, "a staged-delivery base: WAI1 FLAC"),
+        ("O10L1", o10l1, "layer 1 over O10: WAI1 audio refinement"),
+        ("O10L2", o10l2, "layer 2 over O10, after layer 1"),
+        ("OS", enh(Some(true))?, "WAI2: an AVC base and an LCEVC enhancement nearly four times its size"),
+        ("ON", enh(None)?, "OS with the enhancement stating no sha256"),
+        ("OW", enh(Some(false))?, "OS with the enhancement stating a wrong sha256"),
+        ("OT", ot, "WAI2 small enough for the first request to hold whole"),
+        ("OF", of, "WAI1 naming a record capability with a payload fallback"),
+        ("OE1", oe1, "WAI1 whose payload is encrypted"),
+        ("OE2s", sec(json!("aes-256-gcm"))?, "WAI2 whose security member is a string"),
+        ("OE2t", sec(json!(true))?, "WAI2 whose security member is true"),
+        ("OR", or, "WAI2 with a refinement component whose refines is malformed"),
+        ("OPf", with_refines(json!(false))?, "WAI1 text whose refines is false: an ordinary object"),
+        ("OPe", with_refines(json!({}))?, "WAI1 text whose refines is {}: an ordinary object"),
+        ("OPw", with_refines(json!({ "base": o5_cid, "prev": o5_cid, "layer": 1 }))?, "WAI1 text with a well-formed refines: an ordinary object"),
+        ("ORN", orn, "WAI2: an AV1 base and a refinement stating no sha256"),
+    ])
+}
+
+// ------------------------------------------------------------- case evaluation
+
+/// The corpus as one case sees it.
+struct Corpus {
+    dir: PathBuf,
+    objects: BTreeMap<String, Vec<u8>>,
+    /// Files written for cases (proofs), by path.
+    extra: BTreeMap<String, Vec<u8>>,
+}
+
+impl Corpus {
+    /// The bytes a case names, before any patch: an object id, a file, or an envelope
+    /// written inline (`envelope_hex`).
+    fn original(&self, input: &Value) -> Result<Vec<u8>, String> {
+        if let Some(h) = input["envelope_hex"].as_str() {
+            unhex(h)
+        } else if let Some(id) = input["object"].as_str() {
+            self.objects.get(id).cloned().ok_or(format!("no object {id}"))
+        } else if let Some(f) = input["file"].as_str() {
+            self.file(f)
+        } else {
+            Err("a case names an object, a file or an inline envelope".into())
+        }
+    }
+    fn object(&self, input: &Value) -> Result<Vec<u8>, String> {
+        let mut b = self.original(input)?;
+        patch(&mut b, &input["patch_object"])?;
+        Ok(b)
+    }
+    fn file(&self, rel: &str) -> Result<Vec<u8>, String> {
+        match self.extra.get(rel) {
+            Some(b) => Ok(b.clone()),
+            None => read(&self.dir, rel),
+        }
+    }
+}
+
+fn patch(b: &mut [u8], p: &Value) -> Result<(), String> {
+    for e in p.as_array().into_iter().flatten() {
+        let off = e[0].as_u64().ok_or("patch offset")? as usize;
+        let bytes = unhex(e[1].as_str().ok_or("patch bytes")?)?;
+        for (i, x) in bytes.iter().enumerate() {
+            *b.get_mut(off + i).ok_or("patch past the end")? = *x;
+        }
+    }
+    Ok(())
+}
+
+fn unhex(s: &str) -> Result<Vec<u8>, String> {
+    (0..s.len()).step_by(2).map(|i| u8::from_str_radix(&s[i..i + 2], 16).map_err(|e| e.to_string())).collect()
+}
+
+fn range_json(r: ByteRange) -> Value {
+    json!([r.first, r.last])
+}
+
+fn err(e: &RangeRefusal) -> Value {
+    match e {
+        RangeRefusal::Selection(s) => json!({ "error": e.code(), "skipped": skips(s) }),
+        _ => json!({ "error": e.code() }),
+    }
+}
+
+fn skips(s: &[(usize, Skip)]) -> Value {
+    Value::Array(s.iter().map(|(i, k)| json!([i, k.code()])).collect())
+}
+
+fn strs(v: &Value) -> Vec<String> {
+    v.as_array().into_iter().flatten().filter_map(|x| x.as_str().map(String::from)).collect()
+}
+
+/// Why a case stops before its outcome: a refusal, which is its outcome (the code an
+/// independent reader must give too), or a fault in the case itself, which is no
+/// outcome at all.
+enum Stop {
+    Refused(Value),
+    Fault(String),
+}
+
+impl From<String> for Stop {
+    fn from(s: String) -> Stop {
+        Stop::Fault(s)
+    }
+}
+
+impl From<&str> for Stop {
+    fn from(s: &str) -> Stop {
+        Stop::Fault(s.into())
+    }
+}
+
+fn refusal_of(e: &RangeRefusal) -> Stop {
+    Stop::Refused(err(e))
+}
+
+/// A whole envelope's head, refused as the session refuses it.
+fn whole_head(b: &[u8]) -> Result<Head, Stop> {
+    match parse_head(b, b.len() as u64) {
+        Ok(HeadParse::Head(h)) => Ok(h),
+        Ok(HeadParse::Need(n)) => Err(refusal_of(&RangeRefusal::HeadMalformed(format!("the head needs {n} bytes")))),
+        Err(e) => Err(refusal_of(&e)),
+    }
+}
+
+/// The sink a case describes: what it advertises, the parameter sets it holds (one
+/// file each), what it applies with a rendition, its order, a declared union and the
+/// base a layer is declared against. A declared union that does not parse, or a base
+/// that is not an object, refuses the case with its code.
+fn selector(c: &Corpus, input: &Value) -> Result<Selector, Stop> {
+    let adv = strs(&input["advertises"]);
+    let applies = strs(&input["applies"]);
+    let held: Vec<Vec<u8>> = strs(&input["held"]).iter().map(|p| c.file(p)).collect::<Result<_, String>>()?;
+    let mut s = Selector::new(move |cap| adv.iter().any(|a| a == cap));
+    s.applies = Box::new(move |e: &RenditionMeta| applies.iter().any(|a| *a == e.capability));
+    s.verify_pin = Box::new(move |cap, prior| {
+        let files: Vec<HeldBytes<'_>> = held.iter().map(|b| HeldBytes::File(b)).collect();
+        wai::pin::verify_bytes(cap, prior, &files, READABLE).map(|_| ())
+    });
+    if let Some(order) = input["order"].as_array() {
+        let order: Vec<usize> = order.iter().filter_map(|v| v.as_u64().map(|x| x as usize)).collect();
+        s.order = Some(Box::new(move |_| order.clone()));
+    }
+    if let Some(d) = input["declared"].as_str() {
+        s.declared = Some(codecs::parse_element(d).map_err(|e| Stop::Refused(json!({ "error": e.code() })))?);
+    }
+    if !input["layer_base"].is_null() || !input["layer_base_hex"].is_null() {
+        let b = match input["layer_base_hex"].as_str() {
+            Some(h) => unhex(h)?,
+            None => c.objects.get(input["layer_base"].as_str().unwrap_or("")).cloned().ok_or("no layer_base object")?,
+        };
+        s.layer_base = Some(SeqObject::from_envelope(&b).map_err(|e| refusal_of(&e))?);
+    }
+    Ok(s)
+}
+
+fn head(b: &[u8]) -> Result<Head, String> {
+    match parse_head(b, b.len() as u64).map_err(|e| e.to_string())? {
+        HeadParse::Head(h) => Ok(h),
+        HeadParse::Need(n) => Err(format!("needs {n}")),
+    }
+}
+
+fn select(c: &Corpus, input: &Value) -> Result<Value, Stop> {
+    let env = c.object(input)?;
+    whole_head(&env)?;
+    let mut sel = selector(c, input)?;
+    let w = WaiMulti::from_bytes(&env).map_err(|e| refusal_of(&RangeRefusal::HeadMalformed(e.to_string())))?;
+    let order: Vec<usize> = match &sel.order {
+        Some(f) => f(&w.manifest),
+        None => (0..w.manifest.renditions.len()).collect(),
+    };
+    let advertises = &sel.advertises;
+    let verify = &mut sel.verify_pin;
+    let eligible = |_: usize, e: &RenditionMeta| if advertises(&e.capability) { Ok(()) } else { Err(Skip::NotEligible) };
+    let digest_ok = |i: usize, e: &RenditionMeta| e.payload_digest_matches(&w.renditions[i]);
+    Ok(match wai::container::select_entries(&w.manifest, &order, eligible, digest_ok, |cap: &str, p: &Prior| verify(cap, p)) {
+        Ok((i, _, s)) => json!({ "pick": i, "skipped": skips(&s) }),
+        Err(s) => json!({ "inert": skips(&s) }),
+    })
+}
+
+/// An origin for one case: serves the object (after a tamper) and its proof. Tampers:
+/// `patch_object` changes the bytes served; `kind` is `gzip` (every object response
+/// labelled gzip), `no_refinement` (no refinement-class request is answered) or
+/// `no_proof` (the head proof's request is not answered); `first_range_flip` changes the
+/// byte at that object offset in the first range response only; `refinement` breaks
+/// every refinement-class range response one way (`gzip`, `bad_range`, `416`,
+/// `complete_length`, `plus_sign`, `short_200`). `listed_as_layer` fetches the object as
+/// a playlist's layer. The sink is read before the producer writes the proof, so a case
+/// refused for both is refused for its sink.
+fn fetch(c: &Corpus, input: &Value) -> Result<Value, Stop> {
+    let env = c.original(input)?;
+    let mut served = env.clone();
+    let tamper = &input["tamper"];
+    patch(&mut served, &tamper["patch_object"])?;
+    let kind = tamper["kind"].as_str();
+    let refinement = tamper["refinement"].as_str();
+    let first_flip = tamper["first_range_flip"].as_u64();
+    let layer = input["listed_as_layer"].as_bool() == Some(true);
+    let sel = selector(c, input)?;
+    let proof = if layer { Vec::new() } else { HeadProof::build(&env).map_err(|e| refusal_of(&e))?.to_bytes() };
+    let (_, frag) = parse_fragment(input["fragment"].as_str().unwrap_or(""));
+    let mut policy = FetchPolicy::default();
+    if let Some(t) = input["threshold_permille"].as_u64() {
+        policy.full_threshold_permille = t as u16;
+    }
+    let n = served.len() as u64;
+    let mut first = true;
+    let mut s = if layer {
+        FetchSession::new_layer(content_hash(&env), frag, policy, sel)
+    } else {
+        FetchSession::new(content_hash(&env), frag, policy, sel)
+    };
+    let r = drive(&mut s, |w| {
+        if kind == Some("no_refinement") && w.class() == Class::Refinement {
+            return None;
+        }
+        let range = match w {
+            Want::HeadProof if kind == Some("no_proof") => return None,
+            Want::HeadProof => return Some((ResponseMeta { status: 200, ..Default::default() }, proof.clone())),
+            Want::Whole(_) => None,
+            Want::Range(r, _) => Some(r.header()),
+            Want::Rest(r, _) => Some(format!("bytes={}-", r.first)),
+        };
+        let a = origin::serve(n, range.as_deref());
+        let mut meta = ResponseMeta { status: a.status, content_range: a.content_range, content_encoding: (kind == Some("gzip")).then(|| "gzip".into()) };
+        let mut body = served[a.body.start as usize..a.body.end as usize].to_vec();
+        if let (Some(at), Want::Range(..)) = (first_flip, w) {
+            if first {
+                first = false;
+                if a.body.start <= at && at < a.body.end {
+                    body[(at - a.body.start) as usize] ^= 1;
+                }
+            }
+        }
+        if let (Some(mode), Want::Range(r, Class::Refinement)) = (refinement, w) {
+            match mode {
+                "gzip" => meta.content_encoding = Some("gzip".into()),
+                "bad_range" => meta.content_range = Some(format!("bytes {}-{}/{n}", r.first + 1, r.last + 1)),
+                "416" => return Some((ResponseMeta { status: 416, content_range: Some(format!("bytes */{n}")), content_encoding: None }, Vec::new())),
+                "complete_length" => meta.content_range = Some(format!("bytes {}-{}/1", r.first, r.last)),
+                "plus_sign" => meta.content_range = meta.content_range.map(|cr| cr.replacen("bytes ", "bytes +", 1)),
+                "short_200" => return Some((ResponseMeta { status: 200, ..Default::default() }, body)),
+                _ => {}
+            }
+        }
+        Some((meta, body))
+    });
+    Ok(match r {
+        Ok(f) => fetched(&f),
+        Err(e) => err(&e),
+    })
+}
+
+/// A fetch on a clock (§10.1, §10.2), driven by a script of steps, each at a time on
+/// the caller's clock: `["base", t]` answers every base-class request, and every one
+/// that follows, at `t`; `["base_once", t]` answers the base-class requests outstanding
+/// now; `["refinement", t, "range" | "whole_200"]` answers every outstanding refinement
+/// request, with its range or with a `200` carrying the whole object (one byte, at
+/// `flip`, changed); `["tick", t]` tells the session the time. The outcome: the step
+/// after which the base was first ready and its time, the base then and at the end,
+/// what each tick abandoned, and the session's outcome (null while it has none).
+fn fetch_timed(c: &Corpus, input: &Value) -> Result<Value, Stop> {
+    let env = c.original(input)?;
+    let sel = selector(c, input)?;
+    let proof = HeadProof::build(&env).map_err(|e| refusal_of(&e))?.to_bytes();
+    let (_, frag) = parse_fragment(input["fragment"].as_str().unwrap_or(""));
+    let mut policy = FetchPolicy::default();
+    if let Some(t) = input["threshold_permille"].as_u64() {
+        policy.full_threshold_permille = t as u16;
+    }
+    policy.refinement_deadline_ms = input["deadline_ms"].as_u64().map(|d| d as u32);
+    let n = env.len() as u64;
+    let answer = |w: &Want| -> (ResponseMeta, Vec<u8>) {
+        let range = match w {
+            Want::HeadProof => return (ResponseMeta { status: 200, ..Default::default() }, proof.clone()),
+            Want::Whole(_) => None,
+            Want::Range(r, _) => Some(r.header()),
+            Want::Rest(r, _) => Some(format!("bytes={}-", r.first)),
+        };
+        let a = origin::serve(n, range.as_deref());
+        (ResponseMeta { status: a.status, content_range: a.content_range, content_encoding: None }, env[a.body.start as usize..a.body.end as usize].to_vec())
+    };
+    let summary = |f: &Fetched| json!({
+        "pick": f.index, "verified_by": f.verified_by.label(), "component_sha256": sha(&f.component),
+        "companions": f.companions.iter().map(|(i, _)| *i).collect::<Vec<_>>(),
+        "refinements": f.refinements.iter().map(|(i, _)| *i).collect::<Vec<_>>(),
+    });
+    let mut s = FetchSession::new(content_hash(&env), frag, policy, sel);
+    let mut pending: Vec<(u32, Want)> = Vec::new();
+    let (mut ready_step, mut first_base, mut ticks) = (Value::Null, Value::Null, Vec::new());
+    let script = input["script"].as_array().ok_or("script")?;
+    'steps: for (k, step) in script.iter().enumerate() {
+        let t = step[1].as_u64().ok_or("a step's time")?;
+        match step[0].as_str().ok_or("a step's kind")? {
+            kind @ ("base" | "base_once" | "refinement") => loop {
+                pending.extend(s.wants());
+                let class = if kind == "refinement" { Class::Refinement } else { Class::Base };
+                let now: Vec<(u32, Want)> = pending.iter().filter(|(_, w)| w.class() == class).cloned().collect();
+                if now.is_empty() {
+                    break;
+                }
+                pending.retain(|(_, w)| w.class() != class);
+                for (id, w) in now {
+                    let (meta, body) = match step[2].as_str() {
+                        Some("whole_200") => {
+                            let mut b = env.clone();
+                            if let Some(at) = input["flip"].as_u64() {
+                                b[at as usize] ^= 1;
+                            }
+                            (ResponseMeta { status: 200, ..Default::default() }, b)
+                        }
+                        _ => answer(&w),
+                    };
+                    if s.on_response(id, &meta, &body, t).is_err() {
+                        break 'steps;
+                    }
+                }
+                if kind != "base" {
+                    break;
+                }
+            },
+            "tick" => {
+                let ids = s.tick(t);
+                pending.retain(|(id, _)| !ids.contains(id));
+                ticks.push(json!([t, ids]));
+            }
+            other => return Err(format!("unknown step {other}").into()),
+        }
+        if ready_step.is_null() {
+            if let Some(f) = s.base_ready() {
+                ready_step = json!(k);
+                first_base = summary(f);
+            }
+        }
+    }
+    Ok(json!({
+        "ready_step": ready_step,
+        "ready_at": s.base_ready_at(),
+        "base": first_base,
+        "base_end": s.base_ready().map(summary),
+        "ticks": ticks,
+        "outcome": match s.result() {
+            Some(Ok(f)) => fetched(f),
+            Some(Err(e)) => err(e),
+            None => Value::Null,
+        },
+    }))
+}
+
+fn fetched(f: &Fetched) -> Value {
+    let idx = |v: &[(usize, Vec<u8>)]| Value::Array(v.iter().map(|(i, _)| json!(i)).collect());
+    json!({
+        "role": f.role.label(),
+        "pick": f.index,
+        "verified_by": f.verified_by.label(),
+        "why_whole": f.why_whole.map(WhyWhole::code),
+        "body_bytes": f.body_bytes,
+        "requests": f.requests,
+        "companions": idx(&f.companions),
+        "refinements": idx(&f.refinements),
+        "abandoned": f.abandoned,
+        "dropped": f.dropped.iter().map(|(i, w)| json!([i, w.code()])).collect::<Vec<_>>(),
+        "skipped": skips(&f.skipped),
+        "component_sha256": sha(&f.component),
+    })
+}
+
+fn class_of(s: &str) -> Result<Class, String> {
+    match s {
+        "base" => Ok(Class::Base),
+        "refinement" => Ok(Class::Refinement),
+        _ => Err(format!("unknown class {s}")),
+    }
+}
+
+fn prefix_of(v: &Value) -> Result<Vec<Prefix>, String> {
+    strs(v).iter().map(|s| match s.as_str() {
+        "WAI1" => Ok(Prefix::Wai1),
+        "WAI2" => Ok(Prefix::Wai2),
+        _ => Err(format!("unknown container {s}")),
+    }).collect()
+}
+
+/// A case's outcome under this build: a value, a refusal's code, or (`Err`) no outcome,
+/// a fault in the case.
+fn eval(c: &Corpus, op: &str, input: &Value) -> Result<Value, String> {
+    match outcome(c, op, input) {
+        Ok(v) | Err(Stop::Refused(v)) => Ok(v),
+        Err(Stop::Fault(e)) => Err(e),
+    }
+}
+
+fn outcome(c: &Corpus, op: &str, input: &Value) -> Result<Value, Stop> {
+    Ok(match op {
+        "parse_head" => {
+            let b = c.object(input)?;
+            let n = input["envelope_len"].as_u64().unwrap_or(b.len() as u64);
+            let p = input["prefix"].as_u64().map_or(b.len(), |p| p as usize).min(b.len());
+            match parse_head(&b[..p], n) {
+                Ok(HeadParse::Need(k)) => json!({ "need": k }),
+                Ok(HeadParse::Head(h)) => json!({
+                    "version": if h.version == wai::http_binding::head::Version::Wai1 { "WAI1" } else { "WAI2" },
+                    "head_len": h.head_len,
+                    "envelope_len": h.envelope_len,
+                    "covered_len": h.covered_len(),
+                    "components": h.components.iter().map(|x| json!([x.start, x.len])).collect::<Vec<_>>(),
+                }),
+                Err(e) => err(&e),
+            }
+        }
+        "head_proof" => {
+            let b = c.object(input)?;
+            let original = c.original(input)?;
+            let cid = match input["cid"].as_str() {
+                Some(h) => wai::http_binding::unhex32(h).ok_or("cid")?,
+                None => content_hash(&original),
+            };
+            let proof = match input["proof"].as_str() {
+                Some(p) => c.file(p)?,
+                None => HeadProof::build(&original).map_err(|e| e.to_string())?.to_bytes(),
+            };
+            match HeadProof::from_bytes(&proof).and_then(|p| p.verify(&cid, &b).map(|()| p)) {
+                Ok(p) => json!({ "covered_len": p.covered_len, "n_cv": p.cvs.len(), "envelope_len": p.envelope_len }),
+                Err(e) => err(&e),
+            }
+        }
+        "plan" => {
+            let b = c.object(input)?;
+            let h = head(&b)?;
+            let m = h.manifest_v2().map_err(|e| e.to_string())?;
+            let present: Vec<bool> = m.renditions.iter().map(|e| e.sha256.is_some()).collect();
+            let wanted: Vec<(usize, Class)> = input["wanted"].as_array().ok_or("wanted")?.iter()
+                .map(|w| Ok((w[0].as_u64().ok_or("index")? as usize, class_of(w[1].as_str().ok_or("class")?)?)))
+                .collect::<Result<_, String>>()?;
+            let held: Vec<ByteRange> = input["held"].as_array().into_iter().flatten()
+                .filter_map(|r| Some(ByteRange { first: r[0].as_u64()?, last: r[1].as_u64()? })).collect();
+            let policy = FetchPolicy { full_threshold_permille: input["threshold_permille"].as_u64().unwrap_or(900) as u16, ..Default::default() };
+            let p = plan_components(&h, &wanted, &present, &held, &policy);
+            match p.whole_rest {
+                Some((r, why)) => json!({ "whole_rest": range_json(r), "why": why.code() }),
+                None => json!({
+                    "requests": p.requests.iter().map(|(r, cl)| json!([r.first, r.last, cl.label()])).collect::<Vec<_>>(),
+                    "dropped": p.dropped.iter().map(|(i, w)| json!([i, w.code()])).collect::<Vec<_>>(),
+                }),
+            }
+        }
+        "response" => {
+            let req = input["request"].as_array().map(|r| ByteRange { first: r[0].as_u64().unwrap_or(0), last: r[1].as_u64().unwrap_or(0) });
+            let meta = ResponseMeta {
+                status: input["status"].as_u64().ok_or("status")? as u16,
+                content_range: input["content_range"].as_str().map(String::from),
+                content_encoding: input["content_encoding"].as_str().map(String::from),
+            };
+            match check_response(req, &meta, input["body_len"].as_u64().ok_or("body_len")?, input["envelope_len"].as_u64().ok_or("envelope_len")?) {
+                Ok(r) => json!({ "ok": range_json(r) }),
+                Err(e) => err(&e),
+            }
+        }
+        "select" => select(c, input)?,
+        "fetch" => fetch(c, input)?,
+        "fetch_timed" => fetch_timed(c, input)?,
+        "same_pick" => {
+            let range = fetch(c, input)?;
+            let whole = select(c, input)?;
+            let want = match whole.get("pick") {
+                Some(p) => json!({ "pick": p }),
+                None => json!({ "inert": true }),
+            };
+            let got = match range.get("pick") {
+                Some(p) => json!({ "pick": p }),
+                None if range["error"] == "inert" => json!({ "inert": true }),
+                None => range.clone(),
+            };
+            if want != got {
+                return Err(format!("paths differ: whole {whole}, range {range}").into());
+            }
+            want
+        }
+        "codecs" => match codecs::parse(input["value"].as_str().ok_or("value")?) {
+            Ok(v) => json!({ "elements": v.iter().map(|e| e.as_ref().map(codecs::render)).collect::<Vec<_>>() }),
+            Err(e) => json!({ "error": e.code() }),
+        },
+        "union_floor" => {
+            let envs: Vec<Vec<u8>> = match input["envelopes_hex"].as_array() {
+                Some(a) => a.iter().map(|h| unhex(h.as_str().unwrap_or(""))).collect::<Result<_, String>>()?,
+                None => strs(&input["objects"]).iter().map(|id| c.objects.get(id).cloned().ok_or(format!("no object {id}"))).collect::<Result<_, String>>()?,
+            };
+            let objs: Vec<SeqObject> = envs.iter()
+                .map(|e| SeqObject::from_envelope(e).map_err(|e| refusal_of(&e))).collect::<Result<_, _>>()?;
+            match (codecs::union_of(&objs), codecs::floor_of(&objs)) {
+                (Ok(u), Ok(f)) => json!({ "union": codecs::render(&u), "floor": codecs::render(&f) }),
+                (Err(e), _) | (_, Err(e)) => json!({ "error": e.code() }),
+            }
+        }
+        "supports" => {
+            let floor = codecs::parse_element(input["floor"].as_str().ok_or("floor")?).map_err(|e| e.to_string())?;
+            let caps = strs(&input["caps"]);
+            json!({ "supports": codecs::supports(&floor, &prefix_of(&input["containers"])?, |c| caps.iter().any(|x| x == c)) })
+        }
+        "layer_tag" => match wai::http_binding::playlist::parse_layer_tag(input["line"].as_str().ok_or("line")?) {
+            Ok(t) => json!({ "n": t.n, "uri": t.uri }),
+            Err(e) => err(&e),
+        },
+        other => return Err(format!("unknown op {other}").into()),
+    })
+}
+
+// ------------------------------------------------------------------ the cases
+
+struct Case {
+    name: String,
+    op: &'static str,
+    input: Value,
+    /// The reason a negative case exists for, held at generation.
+    intends: Option<&'static str>,
+}
+
+fn case(name: impl Into<String>, op: &'static str, input: Value) -> Case {
+    Case { name: name.into(), op, input, intends: None }
+}
+
+fn refused(name: impl Into<String>, op: &'static str, input: Value, code: &'static str) -> Case {
+    Case { name: name.into(), op, input, intends: Some(code) }
+}
+
+/// Store a case's file under `cases/<name>.hp` and return its path.
+fn put_extra(extra: &mut BTreeMap<String, Vec<u8>>, name: &str, bytes: Vec<u8>) -> String {
+    let rel = format!("cases/{name}.hp");
+    extra.insert(rel.clone(), bytes);
+    rel
+}
+
+/// A proof file for a case, under `cases/`, built from `p` after `f` changes it.
+fn proof_variant(p: &HeadProof, f: impl FnOnce(&mut HeadProof)) -> Vec<u8> {
+    let mut q = p.clone();
+    f(&mut q);
+    q.to_bytes()
+}
+
+fn cases(objs: &BTreeMap<String, Vec<u8>>, extra: &mut BTreeMap<String, Vec<u8>>) -> Result<Vec<Case>, String> {
+    let mut v = Vec::new();
+    let o = |id: &str| json!({ "object": id });
+    let n = |id: &str| objs[id].len() as u64;
+
+    // parse_head.
+    for id in ["O1", "O3", "O5", "O9b", "OD", "OH"] {
+        v.push(case(format!("parse_head_{id}"), "parse_head", o(id)));
+    }
+    v.push(case("parse_head_need_OD_300", "parse_head", json!({ "object": "OD", "prefix": 300 })));
+    v.push(case("parse_head_need_OD_580", "parse_head", json!({ "object": "OD", "prefix": 580 })));
+    v.push(case("parse_head_need_O1_6", "parse_head", json!({ "object": "O1", "prefix": 6 })));
+    v.push(refused("object_length_trailing", "parse_head", json!({ "file": "bad/O6.wai" }), "object_length_mismatch"));
+    v.push(refused("object_length_short", "parse_head", json!({ "object": "O3", "envelope_len": n("O3") + 1 }), "object_length_mismatch"));
+    v.push(refused("head_malformed_magic", "parse_head", json!({ "object": "O5", "patch_object": [[3, "33"]] }), "head_malformed"));
+    v.push(refused("head_malformed_offset", "parse_head", json!({ "object": "OD", "patch_object": [[574, "01"]] }), "head_malformed"));
+
+    // head_proof: every object, and every way a proof can be wrong.
+    for id in objs.keys() {
+        v.push(case(format!("head_proof_ok_{id}"), "head_proof", o(id)));
+    }
+    let p3 = HeadProof::build(&objs["O3"]).map_err(|e| e.to_string())?;
+    let covered = p3.covered_len as usize;
+    v.push(refused("head_proof_flip_prefix_O3", "head_proof", json!({ "object": "O3", "patch_object": [[covered - 1, format!("{:02x}", objs["O3"][covered - 1] ^ 1)]] }), "head_proof_mismatch"));
+    let mut put = |name: &str, bytes: Vec<u8>| put_extra(extra, name, bytes);
+    let f = put("head_proof_flip_cv_O3", proof_variant(&p3, |q| q.cvs[0][0] ^= 1));
+    v.push(refused("head_proof_flip_cv_O3", "head_proof", json!({ "object": "O3", "proof": f }), "head_proof_mismatch"));
+    let f = put("head_proof_drop_cv_O3", proof_variant(&p3, |q| { q.cvs.pop(); }));
+    v.push(refused("head_proof_drop_cv_O3", "head_proof", json!({ "object": "O3", "proof": f }), "head_proof_mismatch"));
+    let f = put("head_proof_extra_cv_O3", proof_variant(&p3, |q| q.cvs.push([0x5a; 32])));
+    v.push(refused("head_proof_extra_cv_O3", "head_proof", json!({ "object": "O3", "proof": f }), "head_proof_mismatch"));
+    let f = put("head_proof_unaligned_O3", proof_variant(&p3, |q| q.covered_len += 1));
+    v.push(refused("head_proof_unaligned_O3", "head_proof", json!({ "object": "O3", "proof": f }), "head_proof_malformed"));
+    let f = put("head_proof_envelope_len_O3", proof_variant(&p3, |q| q.envelope_len += 3));
+    v.push(case("head_proof_envelope_len_O3", "head_proof", json!({ "object": "O3", "proof": f })));
+    let mut bad_magic = p3.to_bytes();
+    bad_magic[3] = b'2';
+    let f = put("head_proof_magic", bad_magic);
+    v.push(refused("head_proof_magic", "head_proof", json!({ "object": "O3", "proof": f }), "head_proof_malformed"));
+    let f = put("head_proof_of_O4", HeadProof::build(&objs["O4"]).map_err(|e| e.to_string())?.to_bytes());
+    v.push(refused("head_proof_other_object", "head_proof", json!({ "object": "O3", "proof": f }), "head_proof_malformed"));
+    // A covered_len one chunk longer than the formula's, with the chaining values that make
+    // its root match: refused by check 3.
+    let ph = HeadProof::build(&objs["OH"]).map_err(|e| e.to_string())?;
+    let wider = covered_proof(&objs["OH"], ph.covered_len + 1024);
+    let f = put("head_proof_not_formula_OH", wider);
+    v.push(refused("head_proof_not_formula_OH", "head_proof", json!({ "object": "OH", "proof": f }), "head_proof_malformed"));
+
+    // plan: Appendix D, classes, and a missing digest.
+    let held = json!([[0, 1008]]);
+    v.push(case("plan_OD_1", "plan", json!({ "object": "OD", "wanted": [[0, "base"]], "held": held })));
+    v.push(case("plan_OD_2", "plan", json!({ "object": "OD", "wanted": [[1, "base"], [2, "base"]], "held": held })));
+    let h8 = head(&objs["O8"])?;
+    let held8 = json!([[0, h8.covered_len() - 1]]);
+    v.push(case("plan_classes_O8", "plan", json!({ "object": "O8", "wanted": [[0, "base"], [1, "refinement"]], "held": held8 })));
+    v.push(case("plan_one_class_O8", "plan", json!({ "object": "O8", "wanted": [[0, "base"], [1, "base"]], "held": held8 })));
+    v.push(case("plan_no_digest_O4", "plan", json!({ "object": "O4", "wanted": [[0, "base"]], "held": [[0, 1008]] })));
+    v.push(case("plan_O3_high", "plan", json!({ "object": "O3", "wanted": [[1, "base"], [2, "base"]], "held": [[0, 1008]] })));
+    v.push(case("plan_held_O3", "plan", json!({ "object": "O3", "wanted": [[0, "base"]], "held": [[0, 1008], [2000, 2999]] })));
+
+    // response: §7.1.
+    let req = json!([1009, 3593]);
+    let r206 = |cr: &str, enc: Value, body: u64| json!({ "request": req, "status": 206, "content_range": cr, "content_encoding": enc, "body_len": body, "envelope_len": 53794 });
+    v.push(case("response_ok", "response", r206("bytes 1009-3593/53794", Value::Null, 2585)));
+    v.push(refused("response_wrong_range", "response", r206("bytes 1009-3592/53794", Value::Null, 2584), "content_range_mismatch"));
+    v.push(refused("response_short_body", "response", r206("bytes 1009-3593/53794", Value::Null, 2000), "content_range_mismatch"));
+    v.push(refused("response_gzip", "response", r206("bytes 1009-3593/53794", json!("gzip"), 2585), "content_coding_present"));
+    v.push(refused("response_complete_length", "response", r206("bytes 1009-3593/53795", Value::Null, 2585), "complete_length_mismatch"));
+    v.push(refused("response_complete_unknown", "response", r206("bytes 1009-3593/*", Value::Null, 2585), "complete_length_mismatch"));
+    v.push(case("response_identity", "response", r206("bytes 1009-3593/53794", json!("identity"), 2585)));
+    v.push(refused("response_304", "response", json!({ "request": req, "status": 304, "body_len": 0, "envelope_len": 53794 }), "http_status_unexpected"));
+    v.push(refused("response_200_short", "response", json!({ "request": req, "status": 200, "body_len": 1000, "envelope_len": 53794 }), "complete_length_mismatch"));
+    v.push(case("response_200_whole", "response", json!({ "request": req, "status": 200, "body_len": 53794, "envelope_len": 53794 })));
+    v.push(case("response_past_end", "response", json!({ "request": [0, 16368], "status": 206, "content_range": "bytes 0-899/900", "body_len": 900, "envelope_len": 900 })));
+    v.push(refused("response_206_unasked", "response", json!({ "request": null, "status": 206, "content_range": "bytes 0-9/900", "body_len": 10, "envelope_len": 900 }), "http_status_unexpected"));
+
+    // select: SPEC §7.1 on the whole envelope.
+    let video = json!(["wai.video.av1"]);
+    let images = json!(["wai.neural.int_mlicpp", "wai.image.avif", "wai.image.jxl", "wai.image.png"]);
+    v.push(case("select_O2_held", "select", json!({ "object": "O2", "advertises": images, "held": [MLICPP_SET] })));
+    v.push(case("select_O2_not_held", "select", json!({ "object": "O2", "advertises": images, "held": [] })));
+    v.push(case("select_O2_png_only", "select", json!({ "object": "O2", "advertises": ["wai.image.png"], "held": [] })));
+    v.push(case("select_O3", "select", json!({ "object": "O3", "advertises": video })));
+    v.push(case("select_O7", "select", json!({ "object": "O7", "advertises": video })));
+    v.push(case("select_O3_nothing", "select", json!({ "object": "O3", "advertises": [] })));
+    v.push(case("select_O9a_int_hyper", "select", json!({ "object": "O9a", "advertises": ["wai.video.int_hyper"], "held": [] })));
+
+    // fetch: the session against an origin, every path.
+    let frag = |id: &str, h: Option<u64>| -> String {
+        let mut s = format!("#n={}", n(id));
+        if let Some(h) = h {
+            s.push_str(&format!("&h={h}"));
+        }
+        s
+    };
+    let cov = |id: &str| -> Result<u64, String> { Ok(head(&objs[id])?.covered_len()) };
+    let hdr = json!(["wai.meta.hdr10plus"]);
+    v.push(case("fetch_O3_low", "fetch", json!({ "object": "O3", "fragment": frag("O3", Some(cov("O3")?)), "advertises": video, "applies": hdr })));
+    v.push(case("fetch_O3_low_default_head", "fetch", json!({ "object": "O3", "advertises": video, "applies": hdr })));
+    v.push(case("fetch_O3_high", "fetch", json!({ "object": "O3", "fragment": frag("O3", Some(cov("O3")?)), "advertises": video, "applies": hdr, "order": [1, 0, 2] })));
+    v.push(case("fetch_OD_1", "fetch", json!({ "object": "OD", "fragment": frag("OD", Some(1009)), "advertises": video, "applies": hdr })));
+    v.push(case("fetch_OD_2", "fetch", json!({ "object": "OD", "fragment": frag("OD", Some(1009)), "advertises": video, "applies": hdr, "order": [1, 0, 2] })));
+    v.push(case("fetch_OD_1_no_h", "fetch", json!({ "object": "OD", "advertises": video, "applies": hdr })));
+    v.push(case("fetch_OD_2_no_h", "fetch", json!({ "object": "OD", "advertises": video, "applies": hdr, "order": [1, 0, 2] })));
+    v.push(case("fetch_OD_2_no_threshold", "fetch", json!({ "object": "OD", "fragment": frag("OD", Some(1009)), "advertises": video, "applies": hdr, "order": [1, 0, 2], "threshold_permille": 1001 })));
+    v.push(case("fetch_O4", "fetch", json!({ "object": "O4", "fragment": frag("O4", Some(1009)), "advertises": video })));
+    v.push(case("fetch_O7", "fetch", json!({ "object": "O7", "fragment": frag("O7", Some(1009)), "advertises": video })));
+    // A byte of `low` after the covered head, changed under the same name.
+    let at = cov("O3")? + 500;
+    assert!(head(&objs["O3"])?.components[0].start + head(&objs["O3"])?.components[0].len > at);
+    v.push(refused("component_tamper_O3", "fetch", json!({ "object": "O3", "fragment": frag("O3", Some(1009)), "advertises": video,
+        "tamper": { "patch_object": [[at, format!("{:02x}", objs["O3"][at as usize] ^ 1)]] } }), "object_digest_mismatch"));
+    v.push(refused("head_tamper_O3", "fetch", json!({ "object": "O3", "advertises": video,
+        "tamper": { "patch_object": [[40, format!("{:02x}", objs["O3"][40] ^ 1)]] } }), "head_proof_mismatch"));
+    v.push(refused("fetch_gzip_O3", "fetch", json!({ "object": "O3", "advertises": video, "tamper": { "kind": "gzip" } }), "content_coding_present"));
+    let avc = json!(["wai.video.avc"]);
+    let lcevc = json!(["wai.video.lcevc"]);
+    v.push(case("fetch_O8_deadline", "fetch", json!({ "object": "O8", "fragment": frag("O8", Some(cov("O8")?)), "advertises": avc, "applies": lcevc, "tamper": { "kind": "no_refinement" } })));
+    v.push(case("fetch_O8_full", "fetch", json!({ "object": "O8", "fragment": frag("O8", Some(cov("O8")?)), "advertises": avc, "applies": lcevc })));
+    v.push(case("fetch_O8_no_enhancement", "fetch", json!({ "object": "O8", "fragment": frag("O8", Some(cov("O8")?)), "advertises": avc, "applies": [] })));
+    v.push(case("fetch_O2_held", "fetch", json!({ "object": "O2", "advertises": images, "held": [MLICPP_SET] })));
+    v.push(case("fetch_O2_not_held", "fetch", json!({ "object": "O2", "advertises": images, "held": [] })));
+    v.push(case("fetch_O1", "fetch", json!({ "object": "O1", "advertises": ["wai.neural.int_mlicpp"], "held": [MLICPP_SET] })));
+    v.push(case("fetch_O1_not_held", "fetch", json!({ "object": "O1", "advertises": ["wai.neural.int_mlicpp"], "held": [] })));
+    v.push(case("fetch_O5_small", "fetch", json!({ "object": "O5", "fragment": frag("O5", None), "advertises": ["wai.text.zstd"] })));
+    v.push(case("fetch_O9b_wai1", "fetch", json!({ "object": "O9b", "fragment": frag("O9b", Some(cov("O9b")?)), "advertises": video })));
+    v.push(case("fetch_OH", "fetch", json!({ "object": "OH", "advertises": video })));
+    v.push(case("fetch_OH_short_head", "fetch", json!({ "object": "OH", "fragment": frag("OH", Some(1009)), "advertises": video })));
+    v.push(refused("fetch_O9a_undeclared", "fetch", json!({ "object": "O9a", "advertises": video, "declared": "wai2.video.av1" }), "codecs_undeclared"));
+    v.push(case("fetch_O9a_declared", "fetch", json!({ "object": "O9a", "advertises": video, "declared": "wai2.video.av1|video.int_hyper" })));
+
+    // same_pick: §7.2 over every WAI2 object, four sinks and three orders.
+    let sinks: [(&str, Value, Value); 4] = [
+        ("video", json!(["wai.video.av1", "wai.video.avc"]), json!(["wai.meta.hdr10plus", "wai.video.lcevc"])),
+        ("image", images.clone(), json!([])),
+        ("other", json!(["wai.video.int_hyper", "wai.image.png", "wai.text.zstd"]), json!([])),
+        ("none", json!([]), json!([])),
+    ];
+    for id in ["O2", "O3", "O4", "O7", "O8", "O9a", "OD", "OH"] {
+        let k = WaiMulti::from_bytes(&objs[id]).map_err(|e| e.to_string())?.manifest.renditions.len();
+        let orders: [Vec<usize>; 3] = [(0..k).collect(), (0..k).rev().collect(), (1..k).chain([0]).collect()];
+        for (sname, adv, applies) in &sinks {
+            for (oi, order) in orders.iter().enumerate() {
+                v.push(case(format!("same_pick_{id}_{sname}_{oi}"), "same_pick",
+                    json!({ "object": id, "advertises": adv, "applies": applies, "held": [MLICPP_SET], "order": order, "fragment": frag(id, Some(1009)) })));
+            }
+        }
+    }
+
+    // codecs: §4.1.
+    for (i, ok) in ["wai2.video.av1+meta.hdr10plus|video.int_hyper", "wai1.video.av1", "mp4a.40.2,wai1.video.av1, avc1.42E01E",
+                    "wai2.video.avc+video.lcevc", "wai2.video.int_motion+video.int_refine", "wai2.neural.int_mlicpp|image.avif"].iter().enumerate() {
+        v.push(case(format!("codecs_ok_{i}"), "codecs", json!({ "value": ok })));
+    }
+    for (name, bad, code) in [
+        ("codecs_uppercase", "wai1.Video.av1", "codecs_malformed"), ("codecs_empty_segment", "wai1.video..av1", "codecs_malformed"),
+        ("codecs_wai3", "wai3.video.av1", "codecs_malformed"), ("codecs_plus_standalone", "wai1.video.av1+video.vp9", "codecs_malformed"),
+        ("codecs_companion_first", "wai1.meta.hdr10plus", "codecs_malformed"), ("codecs_refinement_first", "wai2.video.int_refine", "codecs_malformed"),
+        ("codecs_derivation", "wai1.derive.crop", "codecs_not_media"), ("codecs_record", "wai1.video.manifest", "codecs_not_media"),
+        ("codecs_candidate", "wai1.splat.sog", "codecs_candidate"), ("codecs_one_segment", "wai1.video", "codecs_malformed"),
+    ] {
+        v.push(refused(name, "codecs", json!({ "value": bad }), code));
+    }
+
+    // union and floor: §4.2.
+    v.push(case("union_O9", "union_floor", json!({ "objects": ["O9a", "O9b", "O9c"] })));
+    v.push(case("union_O3", "union_floor", json!({ "objects": ["O3"] })));
+    v.push(case("union_O8", "union_floor", json!({ "objects": ["O8"] })));
+    v.push(case("union_O2", "union_floor", json!({ "objects": ["O2"] })));
+    v.push(case("union_wai1_only", "union_floor", json!({ "objects": ["O9b", "O9c"] })));
+    v.push(refused("floor_none", "union_floor", json!({ "objects": ["O9b", "O2"] }), "codecs_no_common_capability"));
+
+    // ---- fix round.
+    // Item 1: non-ASCII text is refused or classical, never a panic.
+    for (name, value, code) in [("codecs_non_ascii_prefix", "waié.video.av1", Some("codecs_malformed")), ("codecs_non_ascii_digit", "wai١.video.av1", Some("codecs_malformed")),
+                                ("codecs_non_ascii_cap", "wai2.videó.av1", Some("codecs_malformed")), ("codecs_non_ascii_classical", "vidéo.av1", None)] {
+        match code {
+            Some(c) => v.push(refused(name, "codecs", json!({ "value": value }), c)),
+            None => v.push(case(name, "codecs", json!({ "value": value }))),
+        }
+    }
+    // Items 6 and 9: the `wai` prefix in any ASCII case, duplicates and empty elements.
+    for (name, bad) in [("codecs_upper_prefix", "WAI2.video.av1"), ("codecs_mixed_prefix", "Wai1.video.av1"), ("codecs_wai_word", "waiting.for.godot"),
+                        ("codecs_dup_alt", "wai2.video.av1|video.av1"), ("codecs_dup_plus", "wai2.video.av1+meta.hdr10plus+meta.hdr10plus"),
+                        ("codecs_plus_is_alt", "wai2.video.av1+video.av1"), ("codecs_empty_element", "wai2.video.av1,,mp4a.40.2"),
+                        ("codecs_trailing_comma", "wai2.video.av1,"), ("codecs_empty_value", "")] {
+        v.push(refused(name, "codecs", json!({ "value": bad }), "codecs_malformed"));
+    }
+    v.push(case("codecs_companion_in_two_alts", "codecs", json!({ "value": "wai2.video.av1+meta.hdr10plus|video.vp9+meta.hdr10plus" })));
+    // Item 6: Content-Range numbers are ASCII digits.
+    for (name, cr) in [("response_plus_first", "bytes +1009-3593/53794"), ("response_plus_last", "bytes 1009-+3593/53794"), ("response_underscore", "bytes 1009-3_593/53794"),
+                       ("response_inner_space", "bytes 1009- 3593/53794"), ("response_non_ascii_digit", "bytes ١٠٠٩-3593/53794")] {
+        v.push(refused(name, "response", r206(cr, Value::Null, 2585), "content_range_mismatch"));
+    }
+    v.push(refused("response_plus_complete", "response", r206("bytes 1009-3593/+53794", Value::Null, 2585), "complete_length_mismatch"));
+    v.push(case("response_outer_whitespace", "response", r206(" bytes 1009-3593/53794\t", Value::Null, 2585)));
+    // Item 6: SPEC §6.4 on both containers, refines as staged delivery reads it, and the
+    // manifest's member types.
+    v.push(case("fetch_OE1_encrypted", "fetch", json!({ "object": "OE1", "fragment": frag("OE1", None), "advertises": ["wai.text.zstd"] })));
+    v.push(case("select_OE2s_security_string", "select", json!({ "object": "OE2s", "advertises": ["wai.text.zstd"] })));
+    v.push(case("select_OE2t_security_true", "select", json!({ "object": "OE2t", "advertises": ["wai.text.zstd"] })));
+    v.push(case("fetch_OE2s_security_string", "fetch", json!({ "object": "OE2s", "advertises": ["wai.text.zstd"] })));
+    v.push(case("fetch_OR_malformed_refines", "fetch", json!({ "object": "OR", "advertises": ["wai.video.int_motion"], "applies": ["wai.video.int_refine"] })));
+    v.push(case("union_OR_malformed_refines", "union_floor", json!({ "objects": ["OR"] })));
+    v.push(refused("parse_head_kid_string", "parse_head", json!({ "file": "bad/OK.wai" }), "head_malformed"));
+    v.push(refused("parse_head_kind_number", "parse_head", json!({ "file": "bad/OKN.wai" }), "head_malformed"));
+    // Item 2: layers.
+    v.push(case("union_O10_layers", "union_floor", json!({ "objects": ["O10", "O10L1", "O10L2"] })));
+    v.push(refused("union_O10_layers_unbound", "union_floor", json!({ "objects": ["O10L1", "O10L2"] }), "codecs_layer_unbound"));
+    v.push(case("fetch_O10_base", "fetch", json!({ "object": "O10", "advertises": ["wai.audio.flac"] })));
+    v.push(case("fetch_O10L1_discovered", "fetch", json!({ "object": "O10L1", "fragment": frag("O10L1", Some(1009)), "advertises": [] })));
+    v.push(case("fetch_O10L2_listed", "fetch", json!({ "object": "O10L2", "listed_as_layer": true, "advertises": [] })));
+    v.push(case("fetch_O10L2_listed_abandoned", "fetch", json!({ "object": "O10L2", "listed_as_layer": true, "advertises": [], "tamper": { "kind": "no_refinement" } })));
+    v.push(case("fetch_O10L1_listed_refused", "fetch", json!({ "object": "O10L1", "listed_as_layer": true, "advertises": [], "tamper": { "kind": "gzip" } })));
+    v.push(refused("fetch_O10_listed_not_layer", "fetch", json!({ "object": "O10", "listed_as_layer": true, "advertises": ["wai.audio.flac"] }), "not_a_layer"));
+    v.push(case("fetch_O10L1_declared", "fetch", json!({ "object": "O10L1", "advertises": [], "declared": "wai1.audio.flac+audio.int_refine", "layer_base": "O10" })));
+    v.push(refused("fetch_O10L1_undeclared", "fetch", json!({ "object": "O10L1", "advertises": [], "declared": "wai1.audio.flac", "layer_base": "O10" }), "codecs_undeclared"));
+    v.push(refused("fetch_O10L1_declared_other_alt", "fetch", json!({ "object": "O10L1", "advertises": [],
+        "declared": "wai1.audio.flac|audio.int_codec+audio.int_refine", "layer_base": "O10" }), "codecs_undeclared"));
+    v.push(refused("fetch_O10L1_declared_no_base", "fetch", json!({ "object": "O10L1", "advertises": [], "declared": "wai1.audio.flac+audio.int_refine" }), "codecs_undeclared"));
+    // A payload capability carrying refines is dispatched (SPEC §4, refines ignored);
+    // listed as a layer it is not one (§10.4); its codecs element is its capability.
+    for id in ["OPf", "OPe", "OPw"] {
+        v.push(case(format!("fetch_{id}_dispatched"), "fetch", json!({ "object": id, "advertises": ["wai.text.zstd"] })));
+        v.push(refused(format!("fetch_{id}_listed_not_layer"), "fetch", json!({ "object": id, "listed_as_layer": true, "advertises": ["wai.text.zstd"] }), "not_a_layer"));
+        v.push(case(format!("union_{id}"), "union_floor", json!({ "objects": [id] })));
+        v.push(case(format!("fetch_{id}_declared"), "fetch", json!({ "object": id, "advertises": ["wai.text.zstd"], "declared": "wai1.text.zstd" })));
+    }
+    // A refinement stating no digest is dropped whichever path fetches its base.
+    for (name, permille) in [("fetch_ORN_whole", 900), ("fetch_ORN_ranged", 1001)] {
+        v.push(case(name, "fetch", json!({ "object": "ORN", "fragment": frag("ORN", Some(1009)), "advertises": ["wai.video.av1"],
+            "applies": ["wai.video.int_refine"], "threshold_permille": permille })));
+    }
+    // Item 3: a refinement never moves its base.
+    let os_frag = frag("OS", Some(1009));
+    let lcevc_sink = |extra: Value| -> Value {
+        let mut o = json!({ "advertises": ["wai.video.avc"], "applies": ["wai.video.lcevc"], "fragment": os_frag });
+        for (k, val) in extra.as_object().unwrap() {
+            o[k] = val.clone();
+        }
+        o
+    };
+    v.push(case("fetch_OS_threshold_stall", "fetch", lcevc_sink(json!({ "object": "OS", "tamper": { "kind": "no_refinement" } }))));
+    v.push(case("fetch_OS_threshold_stall_1001", "fetch", lcevc_sink(json!({ "object": "OS", "tamper": { "kind": "no_refinement" }, "threshold_permille": 1001 }))));
+    v.push(case("fetch_OS_full", "fetch", lcevc_sink(json!({ "object": "OS" }))));
+    v.push(case("fetch_ON_refinement_no_digest", "fetch", lcevc_sink(json!({ "object": "ON" }))));
+    v.push(case("fetch_OW_refinement_wrong_digest", "fetch", lcevc_sink(json!({ "object": "OW" }))));
+    v.push(case("plan_OS_base_only_threshold", "plan", json!({ "object": "OS", "wanted": [[0, "base"], [1, "refinement"]], "held": [[0, 1008]] })));
+    v.push(case("plan_ON_refinement_dropped", "plan", json!({ "object": "ON", "wanted": [[0, "base"], [1, "refinement"]], "held": [[0, 1008]] })));
+    // §10.1, §10.2 on a clock: the base is ready before its refinement, and the
+    // deadline runs from the response that verified it, whatever the clock said before
+    // (never told, told 0, stepped back), saturating; a refinement's 200 carrying the
+    // whole object, a byte changed, never touches the base, before or after it is ready.
+    let hos = head(&objs["OS"])?;
+    let (base_at, enh_at) = (hos.components[0].start + 100, hos.components[1].start + 100);
+    let timed = |deadline: Option<u64>, script: Value, flip: Option<u64>| -> Value {
+        let mut o = lcevc_sink(json!({ "object": "OS", "script": script }));
+        if let Some(d) = deadline {
+            o["deadline_ms"] = json!(d);
+        }
+        if let Some(f) = flip {
+            o["flip"] = json!(f);
+        }
+        o
+    };
+    v.push(case("timed_OS_base_ready_first", "fetch_timed", timed(Some(50), json!([["base", 1000], ["tick", 1049], ["tick", 1050]]), None)));
+    v.push(case("timed_OS_refinement_after_base", "fetch_timed", timed(None, json!([["base", 10], ["refinement", 20, "range"]]), None)));
+    v.push(case("timed_OS_clock_never_ticked", "fetch_timed", timed(Some(2000),
+        json!([["base", 1_759_680_000_000u64], ["tick", 1_759_680_000_000u64], ["tick", 1_759_680_001_999u64], ["tick", 1_759_680_002_000u64]]), None)));
+    v.push(case("timed_OS_clock_ticked_0", "fetch_timed", timed(Some(2000), json!([["tick", 0], ["base", 5000], ["tick", 6999], ["tick", 7000]]), None)));
+    v.push(case("timed_OS_clock_stepped_back", "fetch_timed", timed(Some(2000),
+        json!([["tick", 10_000], ["tick", 5], ["base", 6], ["tick", 2005], ["tick", 2006]]), None)));
+    v.push(case("timed_OS_clock_back_after", "fetch_timed", timed(Some(2000), json!([["base", 5000], ["tick", 4000], ["tick", 0], ["tick", 6999], ["tick", 7000]]), None)));
+    v.push(case("timed_OS_clock_saturates", "fetch_timed", timed(Some(2000),
+        json!([["base", u64::MAX - 10], ["tick", u64::MAX - 1], ["tick", u64::MAX]]), None)));
+    v.push(case("timed_OS_ready_then_200_base_flipped", "fetch_timed", timed(None, json!([["base", 10], ["refinement", 20, "whole_200"]]), Some(base_at))));
+    v.push(case("timed_OS_ready_then_200_enh_flipped", "fetch_timed", timed(None, json!([["base", 10], ["refinement", 20, "whole_200"]]), Some(enh_at))));
+    v.push(case("timed_OS_200_before_base", "fetch_timed", timed(None,
+        json!([["base_once", 1], ["refinement", 2, "whole_200"], ["base", 3]]), Some(base_at))));
+    // Item 4: a refused refinement response abandons the refinement, not the base.
+    for mode in ["gzip", "bad_range", "416", "complete_length", "plus_sign", "short_200"] {
+        v.push(case(format!("fetch_O8_refinement_{mode}"), "fetch", json!({ "object": "O8", "fragment": frag("O8", Some(cov("O8")?)),
+            "advertises": avc, "applies": lcevc, "tamper": { "refinement": mode } })));
+    }
+    // Item 5: a byte changed in the first response past the head is never reused.
+    v.push(case("fetch_OD_stale", "fetch", json!({ "object": "OD", "advertises": video, "tamper": { "first_range_flip": 2000 } })));
+    v.push(case("fetch_OT_stale_small", "fetch", json!({ "object": "OT", "advertises": video, "tamper": { "first_range_flip": 2000 } })));
+    // Item 7: a proof whose lengths pass what a u64 offset names.
+    let huge = put_extra(extra, "head_proof_huge_O3", proof_variant(&p3, |q| q.envelope_len = u64::MAX));
+    v.push(refused("head_proof_huge_O3", "head_proof", json!({ "object": "O3", "proof": huge }), "head_proof_malformed"));
+    // Item 10: a record capability beside a payload fallback.
+    v.push(case("union_OF_record_fallback", "union_floor", json!({ "objects": ["OF"] })));
+    v.push(case("fetch_OF_record_fallback", "fetch", json!({ "object": "OF", "fragment": frag("OF", None), "advertises": ["wai.text.zstd"] })));
+    // Item 11: a base request never answered.
+    v.push(refused("fetch_O3_proof_unanswered", "fetch", json!({ "object": "O3", "advertises": video, "tamper": { "kind": "no_proof" } }), "base_unanswered"));
+    // The #WAI-LAYER line (§10.4).
+    v.push(case("layer_tag_ok", "layer_tag", json!({ "line": "#WAI-LAYER:N=1,URI=\"objects/a.wai#n=5,6\"" })));
+    v.push(case("layer_tag_unknown_attribute", "layer_tag", json!({ "line": "#WAI-LAYER:URI=\"x.wai\",N=255,X-FUTURE=ENUM" })));
+    for (name, line) in [("layer_tag_zero", "#WAI-LAYER:N=0,URI=\"x\""), ("layer_tag_256", "#WAI-LAYER:N=256,URI=\"x\""), ("layer_tag_no_uri", "#WAI-LAYER:N=1"),
+                         ("layer_tag_unquoted_uri", "#WAI-LAYER:N=1,URI=x"), ("layer_tag_twice", "#WAI-LAYER:N=1,N=2,URI=\"x\""),
+                         ("layer_tag_plus", "#WAI-LAYER:N=+1,URI=\"x\""), ("layer_tag_non_ascii_digit", "#WAI-LAYER:N=١,URI=\"x\""),
+                         ("layer_tag_lower_name", "#WAI-LAYER:n=1,URI=\"x\""), ("layer_tag_unterminated", "#WAI-LAYER:N=1,URI=\"x")] {
+        v.push(refused(name, "layer_tag", json!({ "line": line }), "layer_tag_malformed"));
+    }
+
+    // supports: §4.2, §12.3.
+    let both = json!(["WAI1", "WAI2"]);
+    v.push(case("supports_floor", "supports", json!({ "floor": "wai2.video.av1", "containers": both, "caps": ["wai.video.av1"] })));
+    v.push(case("supports_union_only", "supports", json!({ "floor": "wai2.video.av1", "containers": both, "caps": ["wai.video.int_hyper"] })));
+    v.push(case("supports_container_gate", "supports", json!({ "floor": "wai2.video.av1", "containers": ["WAI1"], "caps": ["wai.video.av1"] })));
+    v.push(case("supports_wai1", "supports", json!({ "floor": "wai1.video.av1", "containers": ["WAI1"], "caps": ["wai.video.av1"] })));
+    v.push(case("supports_companion_ignored", "supports", json!({ "floor": "wai2.video.av1+meta.hdr10plus", "containers": both, "caps": ["wai.video.av1"] })));
+    Ok(v)
+}
+
+/// A head proof of `env` claiming `covered` (aligned) with the chaining values that
+/// make its root match: what a producer that rounds `covered_len` wrongly writes.
+fn covered_proof(env: &[u8], covered: u64) -> Vec<u8> {
+    use blake3::hazmat::{left_subtree_len, HasherExt};
+    let mut x = wai::jwp_hash::DOMAIN_OBJECT.to_vec();
+    x.extend_from_slice(env);
+    fn walk(x: &[u8], start: u64, len: u64, c: u64, out: &mut Vec<[u8; 32]>) {
+        if start >= c {
+            let mut h = blake3::Hasher::new();
+            h.set_input_offset(start);
+            h.update(&x[start as usize..(start + len) as usize]);
+            out.push(h.finalize_non_root());
+        } else if start + len > c {
+            let l = left_subtree_len(len);
+            walk(x, start, l, c, out);
+            walk(x, start + l, len - l, c, out);
+        }
+    }
+    let (n, c) = (x.len() as u64, 15 + covered);
+    let l = left_subtree_len(n);
+    let mut cvs = Vec::new();
+    walk(&x, 0, l, c, &mut cvs);
+    walk(&x, l, n - l, c, &mut cvs);
+    HeadProof { cid: content_hash(env), envelope_len: env.len() as u64, covered_len: covered, cvs }.to_bytes()
+}
+
+// ------------------------------------------------------------- generate / verify
+
+fn json_lines(cases: &[(String, &str, Value, Value)]) -> Vec<u8> {
+    let mut out = String::from("[\n");
+    for (i, (name, op, input, expect)) in cases.iter().enumerate() {
+        let line = json!({ "name": name, "op": op, "input": input, "expect": expect });
+        out.push_str(&serde_json::to_string(&line).expect("json"));
+        out.push_str(if i + 1 < cases.len() { ",\n" } else { "\n" });
+    }
+    out.push_str("]\n");
+    out.into_bytes()
+}
+
+/// Every generated file, by path relative to the corpus.
+fn generate(dir: &Path) -> Result<BTreeMap<String, Vec<u8>>, String> {
+    check_sources(dir)?;
+    let mut files = BTreeMap::new();
+    let mut objs = BTreeMap::new();
+    let mut listing = serde_json::Map::new();
+    for (id, bytes, what) in objects(dir)? {
+        let cid = content_hash(&bytes);
+        let h = head(&bytes)?;
+        let union = codecs::union_of(&[SeqObject::from_envelope(&bytes).map_err(|e| e.to_string())?]).map(|e| codecs::render(&e)).ok();
+        let name = format!("objects/{}", wai::http_binding::object_name(&cid));
+        listing.insert(id.to_string(), json!({
+            "cid": hex(&cid), "path": name, "n": bytes.len(), "h": h.covered_len(), "codecs": union, "what": what,
+        }));
+        files.insert(format!("{name}.hp"), HeadProof::build(&bytes).map_err(|e| e.to_string())?.to_bytes());
+        files.insert(format!("{name}.etag"), format!("\"{}\"\n", hex(&cid)).into_bytes());
+        files.insert(name, bytes.clone());
+        objs.insert(id.to_string(), bytes);
+    }
+    let mut trailing = objs["O5"].clone();
+    trailing.push(0);
+    files.insert("bad/O6.wai".into(), trailing);
+    // Manifests whose members have the wrong type: a string key id, a numeric kind.
+    let raw_wai1 = |manifest: &str, payload: &[u8]| -> Vec<u8> {
+        let mut b = b"WAI1".to_vec();
+        b.extend_from_slice(&(manifest.len() as u32).to_le_bytes());
+        b.extend_from_slice(manifest.as_bytes());
+        b.extend_from_slice(&(payload.len() as u32).to_le_bytes());
+        b.extend_from_slice(payload);
+        b
+    };
+    files.insert("bad/OK.wai".into(), raw_wai1(r#"{"wai":"1.0","media":"text","intent":"replicate","model_requirement":{"capability":"wai.text.zstd"},"conditioning":{"kind":"zstd"},"security":{"encryption":"none","kid":"1"},"target":null}"#, &pattern(2000, 3, 1)));
+    files.insert("bad/OKN.wai".into(), raw_wai1(r#"{"wai":"1.0","media":"text","intent":"replicate","model_requirement":{"capability":"wai.text.zstd"},"conditioning":{"kind":7},"target":null}"#, &pattern(2000, 3, 1)));
+    files.insert("objects.json".into(), {
+        let mut s = serde_json::to_string_pretty(&Value::Object(listing)).expect("json");
+        s.push('\n');
+        s.into_bytes()
+    });
+    let mut extra = BTreeMap::new();
+    for bad in ["bad/O6.wai", "bad/OK.wai", "bad/OKN.wai"] {
+        extra.insert(bad.to_string(), files[bad].clone());
+    }
+    let list = cases(&objs, &mut extra)?;
+    let corpus = Corpus { dir: dir.to_path_buf(), objects: objs, extra: extra.clone() };
+    let mut out = Vec::new();
+    for c in &list {
+        let expect = eval(&corpus, c.op, &c.input).map_err(|e| format!("{}: {e}", c.name))?;
+        if let Some(code) = c.intends {
+            if expect["error"] != code {
+                return Err(format!("{} exists for {code}, and this build gives {expect}", c.name));
+            }
+        }
+        out.push((c.name.clone(), c.op, c.input.clone(), expect));
+    }
+    // Appendix D's numbers, as the extension states them.
+    let od = &corpus.objects["OD"];
+    let pd = HeadProof::build(od).map_err(|e| e.to_string())?;
+    if hex(&content_hash(od)) != "eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228" || pd.to_bytes().len() != 245 || od.len() != 53_794 {
+        return Err("OD no longer has Appendix D's cid, length and proof size".into());
+    }
+    // Appendix D's plans, with h and without it, as the extension states them.
+    let plans = [("fetch_OD_1", 3839, 3, "head-proof"), ("fetch_OD_2", 53_794 + 245, 3, "whole-object"),
+                 ("fetch_OD_1_no_h", 16_614, 2, "head-proof"), ("fetch_OD_2_no_h", 54_039, 3, "head-proof")];
+    for (name, bytes, requests, by) in plans {
+        let (_, _, _, e) = out.iter().find(|(n, ..)| n == name).ok_or(format!("no case {name}"))?;
+        if e["body_bytes"] != bytes || e["requests"] != requests || e["verified_by"] != by {
+            return Err(format!("{name} is not Appendix D's plan: {e}"));
+        }
+    }
+    // A payload capability with refines is an ordinary object, and a refinement with no
+    // digest is dropped on both paths, as §4.2, §7 step 5 and §10.4 state.
+    let outcome_of = |name: &str| out.iter().find(|(n, ..)| n == name).map(|(.., e)| e.clone()).ok_or(format!("no case {name}"));
+    // §10.1, §10.2: the base ready at the first step, before its refinement; each deadline
+    // passed exactly at its start plus 2000 (50) ms and not a millisecond before; the
+    // base unchanged by a refinement's whole-object 200, and the fetch on the head-proof
+    // path.
+    let r = outcome_of("timed_OS_base_ready_first")?;
+    if r["ready_step"] != 0 || r["ready_at"] != 1000 || r["ticks"][0][1] != json!([]) || r["ticks"][1][1].as_array().is_none_or(Vec::is_empty)
+        || r["outcome"]["abandoned"] != json!([1]) {
+        return Err(format!("timed_OS_base_ready_first: the base is not ready before its refinement, or the deadline did not abandon it: {r}"));
+    }
+    for (name, at) in [("timed_OS_clock_never_ticked", 1_759_680_000_000u64), ("timed_OS_clock_ticked_0", 5000), ("timed_OS_clock_stepped_back", 6),
+                       ("timed_OS_clock_back_after", 5000), ("timed_OS_clock_saturates", u64::MAX - 10)] {
+        let r = outcome_of(name)?;
+        let ticks = r["ticks"].as_array().cloned().unwrap_or_default();
+        let fired: Vec<u64> = ticks.iter().filter(|t| t[1].as_array().is_some_and(|a| !a.is_empty())).filter_map(|t| t[0].as_u64()).collect();
+        if r["ready_at"] != at || fired != vec![at.saturating_add(2000)] || r["outcome"]["abandoned"] != json!([1]) {
+            return Err(format!("{name}: the deadline does not run from the verifying response: {r}"));
+        }
+    }
+    for (name, companions, dropped) in [("timed_OS_ready_then_200_base_flipped", json!([1]), json!([])),
+                                        ("timed_OS_ready_then_200_enh_flipped", json!([]), json!([[1, "component_digest_mismatch"]])),
+                                        ("timed_OS_200_before_base", json!([1]), json!([]))] {
+        let r = outcome_of(name)?;
+        let o = &r["outcome"];
+        if o["verified_by"] != "head-proof" || !o["why_whole"].is_null() || o["companions"] != companions || o["dropped"] != dropped
+            || r["base_end"]["component_sha256"] != r["base"]["component_sha256"] {
+            return Err(format!("{name}: a refinement's 200 reached the base: {r}"));
+        }
+    }
+    for id in ["OPf", "OPe", "OPw"] {
+        let (f, u, d) = (outcome_of(&format!("fetch_{id}_dispatched"))?, outcome_of(&format!("union_{id}"))?, outcome_of(&format!("fetch_{id}_declared"))?);
+        if f["role"] != "base" || u["union"] != "wai1.text.zstd" || d["role"] != "base" {
+            return Err(format!("{id} is not an ordinary object: {f}, {u}, {d}"));
+        }
+    }
+    for (name, why) in [("fetch_ORN_whole", json!("range_threshold")), ("fetch_ORN_ranged", Value::Null)] {
+        let f = outcome_of(name)?;
+        if f["dropped"] != json!([[1, "component_digest_absent"]]) || f["why_whole"] != why || f["refinements"] != json!([]) {
+            return Err(format!("{name} does not drop the refinement with no digest: {f}"));
+        }
+    }
+    for (k, b) in extra {
+        if k.starts_with("cases/") {
+            files.insert(k, b);
+        }
+    }
+    files.insert("cases.json".into(), json_lines(&out));
+    Ok(files)
+}
+
+/// The frozen sources have the SHA-256 values `src/SOURCES.json` states.
+fn check_sources(dir: &Path) -> Result<(), String> {
+    let listing: Value = serde_json::from_slice(&read(dir, "src/SOURCES.json")?).map_err(|e| e.to_string())?;
+    for (name, v) in listing["files"].as_object().ok_or("SOURCES.json has files")? {
+        let got = sha(&read(dir, &format!("src/{name}"))?);
+        if v["sha256"].as_str() != Some(got.as_str()) {
+            return Err(format!("src/{name} has SHA-256 {got}, and SOURCES.json states {}", v["sha256"]));
+        }
+    }
+    Ok(())
+}
+
+fn verify(dir: &Path) -> Result<bool, String> {
+    let mut ok = true;
+    // Every committed case, evaluated by this build.
+    let committed: Vec<Value> = serde_json::from_slice(&read(dir, "cases.json")?).map_err(|e| e.to_string())?;
+    let listing: Value = serde_json::from_slice(&read(dir, "objects.json")?).map_err(|e| e.to_string())?;
+    let mut objs = BTreeMap::new();
+    for (id, o) in listing.as_object().ok_or("objects.json is an object")? {
+        let b = read(dir, o["path"].as_str().ok_or("path")?)?;
+        if hex(&content_hash(&b)) != o["cid"].as_str().unwrap_or("") {
+            println!("FAIL object {id}: its bytes do not hash to its cid");
+            ok = false;
+        }
+        objs.insert(id.clone(), b);
+    }
+    let corpus = Corpus { dir: dir.to_path_buf(), objects: objs, extra: BTreeMap::new() };
+    let mut pass = 0;
+    // A defect that panics fails the case it panics in, and the rest still run.
+    std::panic::set_hook(Box::new(|_| {}));
+    for c in &committed {
+        let name = c["name"].as_str().unwrap_or("?");
+        let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| eval(&corpus, c["op"].as_str().unwrap_or(""), &c["input"])));
+        match r {
+            Ok(Ok(got)) if got == c["expect"] => pass += 1,
+            Ok(Ok(got)) => {
+                println!("FAIL {name}: expected {}, got {got}", c["expect"]);
+                ok = false;
+            }
+            Ok(Err(e)) => {
+                println!("FAIL {name}: {e}");
+                ok = false;
+            }
+            Err(_) => {
+                println!("FAIL {name}: the evaluation panicked");
+                ok = false;
+            }
+        }
+    }
+    println!("{pass}/{} cases give their outcome", committed.len());
+    // Every file regenerates to the committed bytes.
+    let regenerated = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| generate(dir)))
+        .unwrap_or_else(|_| Err("the generator panicked".into()));
+    let _ = std::panic::take_hook();
+    match regenerated {
+        Ok(files) => {
+            for (rel, want) in &files {
+                match std::fs::read(dir.join(rel)) {
+                    Ok(have) if &have == want => {}
+                    _ => {
+                        println!("DIFF {rel}: regeneration does not give the committed bytes");
+                        ok = false;
+                    }
+                }
+            }
+            println!("{} generated files compared", files.len());
+        }
+        Err(e) => {
+            println!("FAIL regeneration: {e}");
+            ok = false;
+        }
+    }
+    Ok(ok)
+}
+
+// ---------------------------------------------------------------- differential
+
+/// splitmix64.
+fn next(s: &mut u64) -> u64 {
+    *s = s.wrapping_add(0x9E37_79B9_7F4A_7C15);
+    let mut z = *s;
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+    z ^ (z >> 31)
+}
+
+/// `count` random `WAI2` envelopes, sizes spread across chunk boundaries from 1 KiB
+/// to 8 MiB, each as a JSON line with its cid, length, covered prefix and proof.
+fn differential(seed: u64, count: usize) -> Result<Vec<u8>, String> {
+    let mut s = seed;
+    let mut out = String::new();
+    for i in 0..count {
+        let exp = 10 + (next(&mut s) % 14);
+        let jitter = next(&mut s) % 2048;
+        let total = ((1u64 << exp) + jitter - 1024).clamp(1100, 8 << 20) as usize;
+        let k = 1 + (next(&mut s) % 4) as usize;
+        let note = "n".repeat((next(&mut s) % 3000) as usize);
+        let probe = WaiMulti::new("binary", "replicate", json!({ "i": i, "note": note }),
+            (0..k).map(|_| Rendition::media("wai.text.zstd", "zstd", Vec::new())).collect()).to_bytes().map_err(|e| e.to_string())?;
+        if probe.len() >= total {
+            continue;
+        }
+        let mut left = total - probe.len();
+        let mut rends = Vec::new();
+        for j in 0..k {
+            let len = if j + 1 == k { left } else { (next(&mut s) as usize) % (left + 1) };
+            left -= len;
+            let a = (next(&mut s) % 251) as usize + 1;
+            rends.push(Rendition::media("wai.text.zstd", "zstd", pattern(len, a, j)).with_payload_digest());
+        }
+        let env = WaiMulti::new("binary", "replicate", json!({ "i": i, "note": note }), rends).to_bytes().map_err(|e| e.to_string())?;
+        let p = HeadProof::build(&env).map_err(|e| e.to_string())?;
+        let line = json!({
+            "cid": hex(&content_hash(&env)), "envelope_len": env.len(),
+            "prefix": hex(&env[..p.covered_len as usize]), "proof": hex(&p.to_bytes()),
+        });
+        out.push_str(&serde_json::to_string(&line).expect("json"));
+        out.push('\n');
+    }
+    Ok(out.into_bytes())
+}
+
+// ---------------------------------------------------------------- the fuzz families
+
+fn pick<'a>(s: &mut u64, xs: &[&'a str]) -> &'a str {
+    xs[(next(s) % xs.len() as u64) as usize]
+}
+
+fn joined(s: &mut u64, pieces: &[&str], most: u64) -> String {
+    (0..next(s) % most).map(|_| pick(s, pieces)).collect()
+}
+
+/// A WAI1 or WAI2 envelope around manifest text, payloads of `sizes`.
+fn raw_envelope(v2: bool, manifest: &str, sizes: &[usize]) -> Vec<u8> {
+    let mut b = if v2 { b"WAI2".to_vec() } else { b"WAI1".to_vec() };
+    b.extend_from_slice(&(manifest.len() as u32).to_le_bytes());
+    b.extend_from_slice(manifest.as_bytes());
+    let payloads: Vec<Vec<u8>> = sizes.iter().enumerate().map(|(i, &n)| pattern(n, 7 + 2 * i, i)).collect();
+    if v2 {
+        b.extend_from_slice(&(payloads.len() as u16).to_le_bytes());
+        let mut off = 0u32;
+        for p in &payloads {
+            b.extend_from_slice(&off.to_le_bytes());
+            b.extend_from_slice(&(p.len() as u32).to_le_bytes());
+            off += p.len() as u32;
+        }
+    } else {
+        b.extend_from_slice(&(payloads[0].len() as u32).to_le_bytes());
+    }
+    for p in payloads {
+        b.extend_from_slice(&p);
+    }
+    b
+}
+
+/// One of the manifest member values the review found read differently.
+fn security(s: &mut u64) -> Option<&'static str> {
+    let v = [None, Some("null"), Some(r#"{"encryption":"none"}"#), Some(r#"{"encryption":"aes-256-gcm","kid":1}"#), Some(r#"{"encryption":"none","kid":"1"}"#),
+             Some(r#"{"encryption":7}"#), Some(r#"{"kid":-1}"#), Some(r#"{"kid":1.5}"#), Some(r#""aes-256-gcm""#), Some("true"), Some("[]"), Some(r#"{}"#)];
+    v[(next(s) % v.len() as u64) as usize]
+}
+
+/// Seeded cases of every family, with this build's outcomes, and per family the cases
+/// generated and how many of them this build refuses. A case this build gives no outcome
+/// for (a fault, not a refusal) stops the run: every case reaches the comparison.
+#[allow(clippy::type_complexity)]
+fn fuzz(dir: &Path, seed: u64, count: usize) -> Result<(Vec<u8>, usize, BTreeMap<String, (usize, usize)>), String> {
+    let mut s = seed;
+    let corpus = Corpus { dir: dir.to_path_buf(), objects: BTreeMap::new(), extra: BTreeMap::new() };
+    let mut out: Vec<(String, &str, Value, Value)> = Vec::new();
+    let mut stats: BTreeMap<String, (usize, usize)> = BTreeMap::new();
+    let mut push = |name: String, op: &'static str, input: Value| -> Result<(), String> {
+        let r = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| eval(&corpus, op, &input)));
+        let expect = match r {
+            Ok(Ok(expect)) => expect,
+            Ok(Err(e)) => return Err(format!("{name}: this build gives no outcome ({e}) for {input}")),
+            Err(_) => return Err(format!("{name}: this build panicked on {input}")),
+        };
+        let family = name.rsplit_once('_').map_or(name.as_str(), |(f, _)| f).to_string();
+        let tally = stats.entry(family).or_default();
+        tally.0 += 1;
+        if expect.get("error").is_some() || expect.get("inert").is_some() {
+            tally.1 += 1;
+        }
+        out.push((name, op, input, expect));
+        Ok(())
+    };
+    const CAPS: &[&str] = &["video.av1", "video.vp9", "meta.hdr10plus", "video.lcevc", "video.int_refine", "audio.int_refine", "video.manifest", "derive.crop",
+                            "splat.sog", "image.png", "text.zstd", "x.y", "video.int_motion", "audio.flac", "neural.int_mlicpp", "prior.set"];
+    for i in 0..count {
+        // Content-Range values: half built from the request with at most one number
+        // perturbed (a sign, a separator, a space, another script's digit), so a reader
+        // that admits any of them accepts a case it must refuse; half random.
+        if next(&mut s) % 2 == 0 {
+            let (a0, b0) = [(1009u64, 3593u64), (0, 16368), (0, 53793)][(next(&mut s) % 3) as usize];
+            let mut nums = [a0.to_string(), b0.min(53793).to_string(), "53794".to_string()];
+            let which = (next(&mut s) % 4) as usize;
+            if which < 3 {
+                let v = nums[which].clone();
+                nums[which] = match next(&mut s) % 5 { 0 => format!("+{v}"), 1 => format!("{}_{}", &v[..1], &v[1..]), 2 => format!(" {v}"), 3 => v.replace('0', "٠").replace('1', "١"), _ => format!("{v} ") };
+            }
+            let cr = format!("bytes {}-{}/{}", nums[0], nums[1], nums[2]);
+            let body = b0.min(53793) - a0 + 1;
+            push(format!("fuzz_response_{i}"), "response", json!({ "request": [a0, b0], "status": 206, "content_range": cr, "content_encoding": null, "body_len": body, "envelope_len": 53794 }))?;
+        } else {
+            let cr = joined(&mut s, &["bytes ", "bytes", " ", "\t", "0", "1009", "3593", "-", "/", "53794", "+", "_", "*", "١", "٠", "9", "Bytes "], 9);
+            let req = [json!([1009, 3593]), json!([0, 16368]), Value::Null][(next(&mut s) % 3) as usize].clone();
+            let status = [206, 200, 206, 304][(next(&mut s) % 4) as usize];
+            let enc = [Value::Null, json!("gzip"), json!("identity"), json!(" IDENTITY ")][(next(&mut s) % 4) as usize].clone();
+            let body = [2585u64, 53_794, 16_369, 0, (next(&mut s) % 60_000)][(next(&mut s) % 5) as usize];
+            push(format!("fuzz_response_{i}"), "response", json!({ "request": req, "status": status, "content_range": cr, "content_encoding": enc, "body_len": body, "envelope_len": 53794 }))?;
+        }
+        // codecs values.
+        let mut v = String::new();
+        for k in 0..1 + next(&mut s) % 3 {
+            if k > 0 {
+                v.push_str(pick(&mut s, &[",", ", ", ",,", " ,\t"]));
+            }
+            match next(&mut s) % 4 {
+                0 => v.push_str(&joined(&mut s, &["mp4a.40.2", "avc1", "é", "waiting", "x"], 3)),
+                _ => {
+                    v.push_str(pick(&mut s, &["wai1.", "wai2.", "WAI2.", "Wai1.", "wai3.", "wai١.", "wai2"]));
+                    for a in 0..1 + next(&mut s) % 3 {
+                        if a > 0 {
+                            v.push_str(pick(&mut s, &["|", "+", "||", "|"]));
+                        }
+                        v.push_str(pick(&mut s, CAPS));
+                        if next(&mut s) % 3 == 0 {
+                            v.push('+');
+                            v.push_str(pick(&mut s, CAPS));
+                        }
+                    }
+                }
+            }
+        }
+        push(format!("fuzz_codecs_{i}"), "codecs", json!({ "value": v }))?;
+        // #WAI-LAYER lines.
+        let line = if next(&mut s) % 2 == 0 {
+            let n = pick(&mut s, &["1", "2", "255", "256", "0", "01", "+1", "١", "\"1\""]);
+            let uri = pick(&mut s, &["\"a.wai#n=5\"", "\"é.wai\"", "a.wai", "\"a,b.wai\"", "\"\""]);
+            let extra = pick(&mut s, &["", "", ",X-FUTURE=ENUM", ",X-Y=\"q\"", ",N=3", ",x=1", ", URI=\"b\""]);
+            if next(&mut s) % 2 == 0 { format!("#WAI-LAYER:N={n},URI={uri}{extra}") } else { format!("#WAI-LAYER:URI={uri},N={n}{extra}") }
+        } else {
+            format!("{}{}", pick(&mut s, &["#WAI-LAYER:", "#WAI-LAYER:", "#WAI-LAYER", "#wai-layer:"]),
+                joined(&mut s, &["N=", "1", "2", "255", "256", "0", ",", "URI=", "\"", "a.wai", "X-Y=", "Z", "١", "é", "+", " "], 10))
+        };
+        push(format!("fuzz_layer_tag_{i}"), "layer_tag", json!({ "line": line }))?;
+        // WAI1 manifests: member types, encryption, refines.
+        let cap = format!("wai.{}", pick(&mut s, CAPS));
+        let fbs = [String::new(), String::new(), r#","fallback":null"#.to_string(), format!(r#","fallback":"wai.{}""#, pick(&mut s, CAPS)), format!(r#","fallback":"wai.{}""#, pick(&mut s, CAPS)), r#","fallback":3"#.to_string()];
+        let fb = fbs[(next(&mut s) % fbs.len() as u64) as usize].clone();
+        let kind = pick(&mut s, &[r#""zstd""#, r#""zstd""#, r#""flac""#, r#""flac""#, r#""wir1""#, "7", "null"]);
+        let sec = security(&mut s).map(|v| format!(r#","security":{v}"#)).unwrap_or_default();
+        let refines = pick(&mut s, &["", r#","refines":null"#, r#","refines":{"base":"b"}"#, r#","refines":"x""#, r#","refines":false"#, r#","refines":{}"#,
+            r#","refines":{"base":"1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8","prev":"1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8","layer":1}"#]);
+        let dup = if next(&mut s) % 9 == 0 { r#","media":"text""# } else { "" };
+        let m1 = format!(r#"{{"wai":"1.0","media":"text","intent":"replicate","model_requirement":{{"capability":"{cap}"{fb}}},"conditioning":{{"kind":{kind}}}{sec}{refines}{dup},"target":null}}"#);
+        let env = raw_envelope(false, &m1, &[1200 + (next(&mut s) % 400) as usize]);
+        let hexed = hex(&env);
+        push(format!("fuzz_wai1_head_{i}"), "parse_head", json!({ "envelope_hex": hexed }))?;
+        let adv = json!([cap.clone(), "wai.text.zstd", "wai.audio.flac"]);
+        if i % 2 == 0 {
+            push(format!("fuzz_wai1_fetch_{i}"), "fetch", json!({ "envelope_hex": hexed, "advertises": adv, "listed_as_layer": next(&mut s) % 4 == 0 }))?;
+        }
+        // WAI1 objects whose other members are well formed: refines on a payload capability
+        // is not read, and only a refinement-only capability makes a layer (§10.4).
+        let rcap = pick(&mut s, &["wai.text.zstd", "wai.audio.flac", "wai.video.av1", "wai.audio.int_refine", "wai.video.int_refine", "wai.video.manifest"]);
+        let rref = pick(&mut s, &["", r#","refines":null"#, r#","refines":false"#, r#","refines":{}"#, r#","refines":"x""#, r#","refines":{"base":"b"}"#,
+            r#","refines":{"base":"1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8","prev":"1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8","layer":1}"#]);
+        let rm = format!(r#"{{"wai":"1.0","media":"text","intent":"replicate","model_requirement":{{"capability":"{rcap}"}},"conditioning":{{"kind":"k"}}{rref},"target":null}}"#);
+        let rx = hex(&raw_envelope(false, &rm, &[1100 + (next(&mut s) % 300) as usize]));
+        let listed = next(&mut s) % 3 == 0;
+        push(format!("fuzz_wai1_refines_fetch_{i}"), "fetch", json!({ "envelope_hex": rx, "advertises": [rcap], "listed_as_layer": listed }))?;
+        push(format!("fuzz_wai1_refines_union_{i}"), "union_floor", json!({ "envelopes_hex": [rx] }))?;
+        // WAI2 manifests: security, entries' member types, refinement components.
+        let e1cap = if next(&mut s) % 2 == 0 { pick(&mut s, &["video.av1", "video.vp9", "image.png"]) } else { pick(&mut s, CAPS) };
+        let e1 = format!(r#"{{"capability":"wai.{e1cap}","kind":"a","id":"a","sha256":"{}"}}"#, sha(&pattern(900, 7, 0)));
+        let n2 = 700 + (next(&mut s) % 300) as usize;
+        let d2 = digest(&mut s, &pattern(n2, 9, 1));
+        let e2 = pick(&mut s, &[r#"{"capability":"wai.video.int_refine","kind":"r","role":"refinement","id":"r","refines":{"base":"a"}DIGEST}"#,
+            r#"{"capability":"wai.video.int_refine","kind":"r","role":"refinement","id":"r","refines":{"base":"a","prev":"a","layer":1}DIGEST}"#,
+            r#"{"capability":"wai.video.int_refine","kind":"r","role":"refinement","id":"r","refines":{"base":"a","prev":"a","layer":1}DIGEST}"#,
+            r#"{"capability":"wai.meta.hdr10plus","kind":"d","role":"companion","companion_of":"wai.video.av1"DIGEST}"#,
+            r#"{"capability":"wai.video.vp9","kind":7}"#, r#"{"capability":"wai.video.vp9","kind":"v","id":5}"#, r#"{"capability":"wai.video.vp9","kind":"v"DIGEST}"#]).replace("DIGEST", &d2);
+        let sec2 = security(&mut s).map(|v| format!(r#","security":{v}"#)).unwrap_or_default();
+        let m2 = format!(r#"{{"wai":"1.1","media":"video","intent":"replicate","renditions":[{e1},{e2}]{sec2},"target":null}}"#);
+        let env2 = raw_envelope(true, &m2, &[900, n2]);
+        let hexed2 = hex(&env2);
+        push(format!("fuzz_wai2_head_{i}"), "parse_head", json!({ "envelope_hex": hexed2 }))?;
+        let mut adv2: Vec<String> = CAPS.iter().filter(|_| next(&mut s) % 2 == 0).map(|c| format!("wai.{c}")).collect();
+        if next(&mut s) % 3 != 0 {
+            adv2.push(format!("wai.{e1cap}"));
+        }
+        push(format!("fuzz_wai2_select_{i}"), "select", json!({ "envelope_hex": hexed2, "advertises": adv2 }))?;
+        if i % 2 == 1 {
+            push(format!("fuzz_wai2_fetch_{i}"), "fetch", json!({ "envelope_hex": hexed2, "advertises": adv2, "applies": ["wai.video.int_refine", "wai.meta.hdr10plus"] }))?;
+        }
+        let partner = if next(&mut s) % 2 == 0 { hexed.clone() } else { rx.clone() };
+        push(format!("fuzz_union_{i}"), "union_floor", json!({ "envelopes_hex": [hexed2.clone(), partner] }))?;
+        // A base and a layer whose refines names it, or does not, or is malformed.
+        let bcap = pick(&mut s, &["wai.audio.flac", "wai.video.int_motion", "wai.video.manifest", "wai.text.zstd"]);
+        let bm = format!(r#"{{"wai":"1.0","media":"audio","intent":"replicate","model_requirement":{{"capability":"{bcap}"}},"conditioning":{{"kind":"b"}},"target":null}}"#);
+        let base = raw_envelope(false, &bm, &[1100]);
+        let another = raw_envelope(false, &bm, &[1150]);
+        let bh = hex(&content_hash(&base));
+        let other = "0".repeat(64);
+        let target = pick(&mut s, &[bh.as_str(), bh.as_str(), other.as_str(), "b"]);
+        let layer_no = pick(&mut s, &["1", "1", "0", "256", r#""1""#]);
+        let lcap = pick(&mut s, &["wai.audio.int_refine", "wai.video.int_refine", "wai.audio.flac", "wai.meta.hdr10plus"]);
+        let lm = format!(r#"{{"wai":"1.0","media":"audio","intent":"replicate","model_requirement":{{"capability":"{lcap}"}},"conditioning":{{"kind":"wir1"}},"refines":{{"base":"{target}","prev":"{target}","layer":{layer_no}}},"target":null}}"#);
+        let layer = raw_envelope(false, &lm, &[1300]);
+        let (bx, lx) = (hex(&base), hex(&layer));
+        let seq = if next(&mut s) % 2 == 0 { json!([bx, lx]) } else { json!([lx, bx]) };
+        push(format!("fuzz_layer_union_{i}"), "union_floor", json!({ "envelopes_hex": seq }))?;
+        // A well-formed layer (or, now and then, a payload carrying refines) against a
+        // declared union and the base it is declared against (§4.2, §10.4): its own base's
+        // alt with it after `+`, that alt without it, another alt with it, the wrong
+        // container, no base, another object as the base.
+        let dcap = pick(&mut s, &["wai.audio.int_refine", "wai.video.int_refine", "wai.audio.int_refine", "wai.text.zstd"]);
+        let dtarget = pick(&mut s, &[bh.as_str(), bh.as_str(), bh.as_str(), other.as_str()]);
+        let dl = raw_envelope(false, &format!(r#"{{"wai":"1.0","media":"audio","intent":"replicate","model_requirement":{{"capability":"{dcap}"}},"conditioning":{{"kind":"wir1"}},"refines":{{"base":"{dtarget}","prev":"{dtarget}","layer":1}},"target":null}}"#), &[1250]);
+        let (bs, ls) = (bcap.trim_start_matches("wai."), dcap.trim_start_matches("wai."));
+        let oc = pick(&mut s, &["video.av1", "audio.flac", "text.zstd", "video.int_motion"]);
+        let decl = match next(&mut s) % 7 {
+            0 | 1 => format!("wai1.{bs}+{ls}"),
+            2 => format!("wai1.{bs}"),
+            3 => format!("wai1.{oc}+{ls}|{bs}"),
+            4 => format!("wai2.{bs}+{ls}"),
+            5 => format!("wai1.{bs}+{ls}|{oc}+{ls}"),
+            _ => format!("wai1.{ls}"),
+        };
+        let lb = match next(&mut s) % 7 {
+            0 => Value::Null,
+            1 => json!(hex(&another)),
+            2 => json!(hex(&dl)),
+            _ => json!(bx.clone()),
+        };
+        push(format!("fuzz_layer_declared_{i}"), "fetch", json!({ "envelope_hex": hex(&dl), "advertises": [dcap], "declared": decl, "layer_base_hex": lb,
+            "listed_as_layer": next(&mut s) % 4 == 0 }))?;
+        // A layer over a WAI2 component (§4.2): its refines names the hash of a component's
+        // exploded envelope (a selectable one, a companion, another selectable one), and the
+        // union, and a fetch declared against that WAI2.
+        let c0 = pick(&mut s, &["wai.audio.flac", "wai.video.av1", "wai.text.zstd"]);
+        let c2 = pick(&mut s, &["wai.audio.flac", "wai.video.vp9", "wai.video.manifest"]);
+        let wm = format!(r#"{{"wai":"1.1","media":"audio","intent":"replicate","renditions":[{{"capability":"{c0}","kind":"f","id":"x","sha256":"{}"}},{{"capability":"wai.meta.hdr10plus","kind":"d","role":"companion","companion_of":"{c0}","companion_of_id":"x"}},{{"capability":"{c2}","kind":"g","id":"y"}}],"target":null}}"#,
+            sha(&pattern(900, 7, 0)));
+        let wb = raw_envelope(true, &wm, &[900, 300, 800]);
+        let k = [0usize, 0, 2, 2, 1, 3][(next(&mut s) % 6) as usize];
+        let named = WaiMulti::explode(&wb, k.min(2)).map(|e| hex(&content_hash(&e))).unwrap_or_else(|_| other.clone());
+        let named = if k == 3 { hex(&content_hash(&wb)) } else { named };
+        let wcap = pick(&mut s, &["wai.audio.int_refine", "wai.video.int_refine", "wai.audio.int_refine", "wai.audio.flac"]);
+        let wl = raw_envelope(false, &format!(r#"{{"wai":"1.0","media":"audio","intent":"replicate","model_requirement":{{"capability":"{wcap}"}},"conditioning":{{"kind":"wir1"}},"refines":{{"base":"{named}","prev":"{named}","layer":1}},"target":null}}"#), &[1200]);
+        let (wbx, wlx) = (hex(&wb), hex(&wl));
+        push(format!("fuzz_component_layer_union_{i}"), "union_floor", json!({ "envelopes_hex": [wbx, wlx] }))?;
+        let (c0s, c2s, ls) = (c0.trim_start_matches("wai."), c2.trim_start_matches("wai."), wcap.trim_start_matches("wai."));
+        let wdecl = match next(&mut s) % 4 {
+            0 => format!("wai2.{c0s}+meta.hdr10plus+{ls}|{c2s}"),
+            1 => format!("wai2.{c0s}+meta.hdr10plus|{c2s}+{ls}"),
+            2 => format!("wai2.{c0s}+{ls}"),
+            _ => format!("wai1.{c0s}+{ls}"),
+        };
+        push(format!("fuzz_component_layer_declared_{i}"), "fetch", json!({ "envelope_hex": wlx, "advertises": [wcap], "declared": wdecl, "layer_base_hex": wbx }))?;
+        // WAI2 objects past the first request, on the range path through an origin that
+        // breaks one way: a base, a refinement or companion over it, and an alternative,
+        // each with a right, wrong or absent digest; the threshold either side, so that both
+        // the range path and the whole path meet a refinement with no digest.
+        if i % 2 == 0 {
+            let (nb, nr, na) = (1000 + (next(&mut s) % 30_000) as usize, 500 + (next(&mut s) % 20_000) as usize, 500 + (next(&mut s) % 15_000) as usize);
+            let (db, dr, da) = (digest(&mut s, &pattern(nb, 7, 0)), digest(&mut s, &pattern(nr, 9, 1)), digest(&mut s, &pattern(na, 11, 2)));
+            let second = pick(&mut s, &[
+                r#"{"capability":"wai.video.int_refine","kind":"r","role":"refinement","id":"r","refines":{"base":"a","prev":"a","layer":1}DIGEST}"#,
+                r#"{"capability":"wai.video.int_refine","kind":"r","role":"refinement","id":"r","refines":{"base":"a","prev":"a","layer":1}DIGEST}"#,
+                r#"{"capability":"wai.meta.hdr10plus","kind":"d","role":"companion","companion_of":"wai.video.av1","companion_of_id":"a"DIGEST}"#,
+                r#"{"capability":"wai.video.lcevc","kind":"l","role":"companion","companion_of":"wai.video.av1","companion_of_id":"a"DIGEST}"#,
+            ]).replace("DIGEST", &dr);
+            let m3 = format!(r#"{{"wai":"1.1","media":"video","intent":"replicate","renditions":[{{"capability":"wai.video.av1","kind":"a","id":"a"{db}}},{second},{{"capability":"wai.video.vp9","kind":"v","id":"v"{da}}}],"target":null}}"#);
+            let env3 = raw_envelope(true, &m3, &[nb, nr, na]);
+            let len = env3.len() as u64;
+            let tamper = match next(&mut s) % 8 {
+                0 => json!({ "kind": "gzip" }),
+                1 => json!({ "kind": "no_refinement" }),
+                2 => json!({ "kind": "no_proof" }),
+                3 => json!({ "first_range_flip": next(&mut s) % len }),
+                4 => json!({ "refinement": pick(&mut s, &["gzip", "bad_range", "416", "complete_length", "plus_sign", "short_200"]) }),
+                5 => json!({ "patch_object": [[next(&mut s) % len, "ff"]] }),
+                _ => json!({}),
+            };
+            let fragment = match next(&mut s) % 4 {
+                0 => String::new(),
+                1 => format!("o.wai#n={len}"),
+                2 => format!("o.wai#h={}", 100 + next(&mut s) % 20_000),
+                _ => format!("o.wai#n={len}&h={}", 100 + next(&mut s) % 20_000),
+            };
+            let adv: Vec<&str> = ["wai.video.av1", "wai.video.vp9"].into_iter().filter(|_| next(&mut s) % 3 != 0).collect();
+            let applies: Vec<&str> = ["wai.video.int_refine", "wai.meta.hdr10plus", "wai.video.lcevc"].into_iter().filter(|_| next(&mut s) % 3 != 0).collect();
+            let permille = [300u64, 500, 900, 1001][(next(&mut s) % 4) as usize];
+            push(format!("fuzz_large_fetch_{i}"), "fetch", json!({ "envelope_hex": hex(&env3), "fragment": fragment, "advertises": adv, "applies": applies,
+                "threshold_permille": permille, "tamper": tamper }))?;
+        } else {
+            // The whole path (§7 step 5, §10.3): a base whose digest is absent, or one the
+            // threshold sends whole, with a refinement whose digest is right, wrong or absent.
+            let (nb, nr) = (1000 + (next(&mut s) % 20_000) as usize, 300 + (next(&mut s) % 4000) as usize);
+            let db = if next(&mut s) % 2 == 0 { String::new() } else { format!(r#","sha256":"{}""#, sha(&pattern(nb, 7, 0))) };
+            let dr = digest(&mut s, &pattern(nr, 9, 1));
+            let m4 = format!(r#"{{"wai":"1.1","media":"video","intent":"replicate","renditions":[{{"capability":"wai.video.av1","kind":"a","id":"a"{db}}},{{"capability":"wai.video.int_refine","kind":"r","role":"refinement","id":"r","refines":{{"base":"a","prev":"a","layer":1}}{dr}}}],"target":null}}"#);
+            let permille = [300u64, 900, 1001][(next(&mut s) % 3) as usize];
+            push(format!("fuzz_whole_refine_{i}"), "fetch", json!({ "envelope_hex": hex(&raw_envelope(true, &m4, &[nb, nr])), "advertises": ["wai.video.av1"],
+                "applies": ["wai.video.int_refine"], "threshold_permille": permille }))?;
+        }
+    }
+    let n = out.len();
+    Ok((json_lines(&out), n, stats))
+}
+
+/// A `sha256` member for a payload: right, wrong, or absent.
+fn digest(s: &mut u64, payload: &[u8]) -> String {
+    match next(s) % 3 {
+        0 => String::new(),
+        1 => format!(r#","sha256":"{}""#, sha(b"another payload")),
+        _ => format!(r#","sha256":"{}""#, sha(payload)),
+    }
+}
diff --git a/wai/wai-rs/src/bin/wai_http_vectors.rs b/wai/wai-rs/src/bin/wai_http_vectors.rs
new file mode 100644
index 000000000..6c6c39928
--- /dev/null
+++ b/wai/wai-rs/src/bin/wai_http_vectors.rs
@@ -0,0 +1,27 @@
+//! `wai_http_vectors` — writes and verifies the HTTP delivery corpus
+//! (`extensions/http-delivery.md` §14, `wai/http-conformance/`). The same tool is
+//! `wai http vectors`.
+//!
+//!   wai_http_vectors gen    <http-conformance dir>
+//!   wai_http_vectors verify <http-conformance dir>
+//!   wai_http_vectors diff   <http-conformance dir> --seed S --count N --out F
+//!
+//! Exit status 1 when a case does not give its committed outcome or a file does not
+//! regenerate to its committed bytes, each named on its own line.
+
+use std::process::ExitCode;
+
+#[path = "wai_cli/http_vectors.rs"]
+mod http_vectors;
+
+fn main() -> ExitCode {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    match http_vectors::main(&args) {
+        Ok(true) => ExitCode::SUCCESS,
+        Ok(false) => ExitCode::from(1),
+        Err(e) => {
+            eprintln!("error: {e}");
+            ExitCode::from(2)
+        }
+    }
+}
diff --git a/wai/wai-rs/src/codecs/registry.rs b/wai/wai-rs/src/codecs/registry.rs
index 1b2c5b8fd..c33a3a130 100644
--- a/wai/wai-rs/src/codecs/registry.rs
+++ b/wai/wai-rs/src/codecs/registry.rs
@@ -361,6 +361,150 @@ pub const IDENTIFIERS: &[Identifier] = &[
     },
 ];
 
+/// What a [`WireIdentifier`] names.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum WireKind {
+    /// A media type.
+    MediaType,
+    /// The prefix of a `codecs` element.
+    CodecsPrefix,
+    /// An ISOBMFF four-character code.
+    FourCc,
+    /// The magic number at the start of a binary format.
+    Magic,
+    /// An HLS `EXT-X-SESSION-DATA` `DATA-ID`.
+    DataId,
+    /// A URI scheme identifier (a DASH `schemeIdUri`).
+    Scheme,
+    /// A path suffix or a path segment a resource is named by.
+    Path,
+    /// A path under `/.well-known/` (RFC 8615).
+    WellKnown,
+    /// A playlist tag.
+    PlaylistTag,
+    /// A playlist attribute.
+    PlaylistAttribute,
+    /// The `kind` member of a JSON document.
+    DocumentKind,
+    /// A MoQ catalog value, catalog field or object property.
+    Catalog,
+}
+
+impl WireKind {
+    /// Every kind, in declaration order.
+    pub const fn all() -> [Self; 12] {
+        [
+            Self::MediaType, Self::CodecsPrefix, Self::FourCc, Self::Magic, Self::DataId,
+            Self::Scheme, Self::Path, Self::WellKnown, Self::PlaylistTag,
+            Self::PlaylistAttribute, Self::DocumentKind, Self::Catalog,
+        ]
+    }
+    /// The label the export uses.
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::MediaType => "media-type",
+            Self::CodecsPrefix => "codecs-prefix",
+            Self::FourCc => "fourcc",
+            Self::Magic => "magic",
+            Self::DataId => "data-id",
+            Self::Scheme => "scheme",
+            Self::Path => "path",
+            Self::WellKnown => "well-known",
+            Self::PlaylistTag => "playlist-tag",
+            Self::PlaylistAttribute => "playlist-attribute",
+            Self::DocumentKind => "document-kind",
+            Self::Catalog => "catalog",
+        }
+    }
+}
+
+/// How settled a [`WireIdentifier`] is.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum WireStatus {
+    /// Defined by its document, and used as defined.
+    Defined,
+    /// Defined by its document for test material only, until a registration
+    /// authority registers it.
+    Provisional,
+    /// Proposed for registration; its document says it is not registered.
+    Proposed,
+}
+
+impl WireStatus {
+    /// Every status, in declaration order.
+    pub const fn all() -> [Self; 3] {
+        [Self::Defined, Self::Provisional, Self::Proposed]
+    }
+    /// The label the export uses.
+    pub fn label(self) -> &'static str {
+        match self {
+            Self::Defined => "defined",
+            Self::Provisional => "provisional",
+            Self::Proposed => "proposed",
+        }
+    }
+}
+
+/// A name a WAI text puts on the wire outside a manifest: a media type, a `codecs`
+/// prefix, a magic number, a path, a playlist tag or attribute, a document kind, a
+/// catalog field. `document` is the text that defines it, relative to `wai/`, and
+/// `section` the section there (`§N` or `Appendix X`).
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct WireIdentifier {
+    pub name: &'static str,
+    pub kind: WireKind,
+    pub document: &'static str,
+    pub section: &'static str,
+    pub status: WireStatus,
+}
+
+const HTTP_DELIVERY: &str = "extensions/http-delivery.md";
+const MOQ_FORMAT: &str = "extensions/moq-streaming-format.md";
+const JWP_RECEIPTS: &str = "extensions/jwp-receipts.md";
+
+const fn wire(name: &'static str, kind: WireKind, document: &'static str, section: &'static str,
+              status: WireStatus) -> WireIdentifier {
+    WireIdentifier { name, kind, document, section, status }
+}
+
+/// The wire identifiers of the container, of its two delivery bindings
+/// (http-delivery, moq-streaming-format) and of the key discovery those bindings
+/// serve (jwp-receipts §7), in document order. The export lists them sorted by name
+/// and kind.
+pub const WIRE_IDENTIFIERS: &[WireIdentifier] = &[
+    wire("WAI1", WireKind::Magic, "SPEC.md", "§2", WireStatus::Defined),
+    wire("WAI2", WireKind::Magic, "SPEC.md", "§7.1", WireStatus::Defined),
+    wire("application/wai", WireKind::MediaType, HTTP_DELIVERY, "§3", WireStatus::Proposed),
+    wire("wai1", WireKind::CodecsPrefix, HTTP_DELIVERY, "§4.1", WireStatus::Defined),
+    wire("wai2", WireKind::CodecsPrefix, HTTP_DELIVERY, "§4.1", WireStatus::Defined),
+    wire(".wai", WireKind::Path, HTTP_DELIVERY, "§5.2", WireStatus::Defined),
+    wire("WHP1", WireKind::Magic, HTTP_DELIVERY, "§6.2", WireStatus::Defined),
+    wire(".wai.hp", WireKind::Path, HTTP_DELIVERY, "§6.2", WireStatus::Defined),
+    wire("rcpt/", WireKind::Path, HTTP_DELIVERY, "§8.1", WireStatus::Defined),
+    wire(".wai.receipts", WireKind::Path, HTTP_DELIVERY, "§8.2", WireStatus::Defined),
+    wire("wai-receipt-index", WireKind::DocumentKind, HTTP_DELIVERY, "§8.2", WireStatus::Defined),
+    wire("/.well-known/wai-key-status", WireKind::WellKnown, HTTP_DELIVERY, "§8.4", WireStatus::Defined),
+    wire("/.well-known/wai-grants/", WireKind::WellKnown, HTTP_DELIVERY, "§8.4", WireStatus::Defined),
+    wire("wai-module-grants", WireKind::DocumentKind, HTTP_DELIVERY, "§8.4", WireStatus::Defined),
+    wire("mr/", WireKind::Path, HTTP_DELIVERY, "§8.6", WireStatus::Defined),
+    wire("#WAI-LAYER", WireKind::PlaylistTag, HTTP_DELIVERY, "§10.4", WireStatus::Defined),
+    wire("science.transaction.wai.multivariant", WireKind::DataId, HTTP_DELIVERY, "§11.1", WireStatus::Defined),
+    wire("X-WAI-FLOOR", WireKind::PlaylistAttribute, HTTP_DELIVERY, "§11.1", WireStatus::Defined),
+    wire("tag:transaction.science,2026:wai/http-delivery", WireKind::Scheme, HTTP_DELIVERY, "§11.1", WireStatus::Defined),
+    wire("tag:transaction.science,2026:wai/floor", WireKind::Scheme, HTTP_DELIVERY, "§11.1", WireStatus::Defined),
+    wire("wai1", WireKind::FourCc, HTTP_DELIVERY, "Appendix B", WireStatus::Provisional),
+    wire("wai2", WireKind::FourCc, HTTP_DELIVERY, "Appendix B", WireStatus::Provisional),
+    wire("waiC", WireKind::FourCc, HTTP_DELIVERY, "Appendix B", WireStatus::Provisional),
+    wire("wai", WireKind::Catalog, MOQ_FORMAT, "§3", WireStatus::Defined),
+    wire("wai_capabilities", WireKind::Catalog, MOQ_FORMAT, "§4", WireStatus::Defined),
+    wire("wai_determinism", WireKind::Catalog, MOQ_FORMAT, "§4", WireStatus::Defined),
+    wire("wai_receipts", WireKind::Catalog, MOQ_FORMAT, "§4", WireStatus::Defined),
+    wire("WAI_RECEIPT", WireKind::Catalog, MOQ_FORMAT, "§5", WireStatus::Defined),
+    wire("/.well-known/wai-keys", WireKind::WellKnown, JWP_RECEIPTS, "§7.1", WireStatus::Defined),
+    wire("wai-key-status", WireKind::DocumentKind, JWP_RECEIPTS, "§7.9", WireStatus::Defined),
+    wire("wai-module-grant", WireKind::DocumentKind, JWP_RECEIPTS, "§7.9", WireStatus::Defined),
+];
+
 /// A string with the shape of a capability that the reference implementation uses
 /// as a label but that no revision registers, and why.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -608,11 +752,22 @@ pub fn capabilities_json() -> String {
     let mut labels: Vec<&UnregisteredLabel> = UNREGISTERED_LABELS.iter().collect();
     labels.sort_by_key(|l| l.label);
     let labels: Vec<Value> = labels.iter().map(|l| json!({ "label": l.label, "reason": l.reason })).collect();
+    let wires: Vec<Value> = sorted_wire_identifiers()
+        .iter()
+        .map(|w| json!({
+            "name": w.name,
+            "kind": w.kind.label(),
+            "document": w.document,
+            "section": w.section,
+            "status": w.status.label(),
+        }))
+        .collect();
     json_text(&json!({
         "schema": format!("{FORGE_TREE}/registry/capabilities.schema.json"),
         "capabilities": caps,
         "identifiers": ids,
         "unregistered_labels": labels,
+        "wire_identifiers": wires,
     }))
 }
 
@@ -632,6 +787,8 @@ pub fn capabilities_schema() -> String {
     let tiers: Vec<&str> = FidelityTier::all().iter().map(|t| t.label()).collect();
     let licences: Vec<&str> = LicenseClass::all().iter().map(|l| l.label()).collect();
     let replicates: Vec<&str> = ReplicateClass::all().iter().map(|r| r.label()).collect();
+    let wire_kinds: Vec<&str> = WireKind::all().iter().map(|k| k.label()).collect();
+    let wire_statuses: Vec<&str> = WireStatus::all().iter().map(|s| s.label()).collect();
     let string_pattern = "^wai(\\.[a-z0-9_]+)+$";
     json_text(&json!({
         "$schema": "https://json-schema.org/draft/2020-12/schema",
@@ -640,7 +797,7 @@ pub fn capabilities_schema() -> String {
         "description": "Every string SPEC §5 registers, generated by `wai registry export` from the reference implementation's registry (wai-rs/src/codecs/registry.rs). REGISTRY.md states the policy.",
         "type": "object",
         "additionalProperties": false,
-        "required": ["schema", "capabilities", "identifiers", "unregistered_labels"],
+        "required": ["schema", "capabilities", "identifiers", "unregistered_labels", "wire_identifiers"],
         "properties": {
             "schema": { "type": "string" },
             "capabilities": {
@@ -697,6 +854,21 @@ pub fn capabilities_schema() -> String {
                         "reason": { "type": "string" }
                     }
                 }
+            },
+            "wire_identifiers": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "additionalProperties": false,
+                    "required": ["name", "kind", "document", "section", "status"],
+                    "properties": {
+                        "name": { "type": "string" },
+                        "kind": { "enum": wire_kinds },
+                        "document": { "type": "string" },
+                        "section": { "type": "string", "pattern": "^(§[0-9]+(\\.[0-9]+)*|Appendix [A-Z])$" },
+                        "status": { "enum": wire_statuses }
+                    }
+                }
             }
         }
     }))
@@ -1022,9 +1194,22 @@ pub fn registry_md_table() -> String {
     for l in UNREGISTERED_LABELS {
         o.push_str(&format!("| `{}` | {} |\n", l.label, l.reason));
     }
+    o.push('\n');
+    o.push_str("| wire identifier (not a capability) | kind | status | defined in |\n|---|---|---|---|\n");
+    for w in sorted_wire_identifiers() {
+        let doc = w.document.trim_end_matches(".md").trim_start_matches("extensions/");
+        o.push_str(&format!("| `{}` | {} | {} | {} {} |\n", w.name, w.kind.label(), w.status.label(), doc, w.section));
+    }
     o
 }
 
+/// [`WIRE_IDENTIFIERS`] sorted by name, then kind: the order the export writes.
+pub fn sorted_wire_identifiers() -> Vec<&'static WireIdentifier> {
+    let mut v: Vec<&WireIdentifier> = WIRE_IDENTIFIERS.iter().collect();
+    v.sort_by(|a, b| a.name.cmp(b.name).then(a.kind.cmp(&b.kind)));
+    v
+}
+
 /// `md` with the text between its [`REGISTRY_MD_BEGIN`] and [`REGISTRY_MD_END`]
 /// lines replaced by [`registry_md_table`], or `None` if the markers are missing.
 pub fn splice_registry_md(md: &str) -> Option<String> {
@@ -1343,6 +1528,67 @@ mod tests {
         assert_eq!(splice_registry_md("no markers"), None);
     }
 
+    /// The body of a numbered section (`§N`) or an appendix (`Appendix X`) of a WAI text:
+    /// from its heading to the next heading of its level or above, subsections included.
+    fn section_body<'a>(text: &'a str, section: &str) -> Option<&'a str> {
+        let level = |l: &str| l.bytes().take_while(|&b| b == b'#').count();
+        let mut starts = Vec::new();
+        let mut at = 0;
+        for l in text.split_inclusive('\n') {
+            starts.push((at, l));
+            at += l.len();
+        }
+        let is_heading = |l: &str| l.starts_with('#') && l[level(l)..].starts_with(' ');
+        let (k, (start, line)) = starts.iter().enumerate().find(|(_, (_, l))| {
+            is_heading(l) && {
+                let t = l[level(l) + 1..].trim_end();
+                match section.strip_prefix('§') {
+                    Some(num) => t.starts_with(&format!("{num} ")) || t.starts_with(&format!("{num}. ")) || t == num,
+                    None => t.starts_with(section),
+                }
+            }
+        })?;
+        let lv = level(line);
+        let end = starts[k + 1..].iter().find(|(_, l)| is_heading(l) && level(l) <= lv).map_or(text.len(), |(o, _)| *o);
+        Some(&text[*start..end])
+    }
+
+    /// Every wire identifier is written in the body of the section of the document it
+    /// names (not just somewhere in the document), and no name is listed twice with one
+    /// kind.
+    #[test]
+    fn wire_identifiers_are_in_their_documents() {
+        let mut seen = std::collections::BTreeSet::new();
+        for w in WIRE_IDENTIFIERS {
+            assert!(seen.insert((w.name, w.kind)), "{} ({}) is listed twice", w.name, w.kind.label());
+            let text = read(w.document);
+            let body = section_body(&text, w.section).unwrap_or_else(|| panic!("{} has no section {} for {}", w.document, w.section, w.name));
+            assert!(body.contains(w.name), "{} is not written in {} {}", w.name, w.document, w.section);
+        }
+    }
+
+    /// The schema's wire-identifier enums are the labels, and the export writes only
+    /// values in them.
+    #[test]
+    fn wire_identifier_schema_enums_equal_labels() {
+        let schema: serde_json::Value = serde_json::from_str(&read("registry/capabilities.schema.json")).unwrap();
+        let props = &schema["properties"]["wire_identifiers"]["items"]["properties"];
+        let enum_of = |field: &str| -> Vec<String> {
+            props[field]["enum"].as_array().unwrap_or_else(|| panic!("{field} has no enum"))
+                .iter().filter_map(|v| v.as_str().map(String::from)).collect()
+        };
+        assert_eq!(enum_of("kind"), WireKind::all().iter().map(|k| k.label().to_string()).collect::<Vec<_>>());
+        assert_eq!(enum_of("status"), WireStatus::all().iter().map(|s| s.label().to_string()).collect::<Vec<_>>());
+        let export: serde_json::Value = serde_json::from_str(&read("registry/capabilities.json")).unwrap();
+        let rows = export["wire_identifiers"].as_array().unwrap();
+        assert_eq!(rows.len(), WIRE_IDENTIFIERS.len());
+        for r in rows {
+            for field in ["kind", "status"] {
+                assert!(enum_of(field).iter().any(|e| r[field] == *e), "{field} {} is not in the schema", r[field]);
+            }
+        }
+    }
+
     /// The record and label strings copied from wai-quantum equal its constants.
     #[cfg(feature = "quantum_ops")]
     #[test]
diff --git a/wai/wai-rs/src/container.rs b/wai/wai-rs/src/container.rs
index 4be7bdc96..aeb5d2352 100644
--- a/wai/wai-rs/src/container.rs
+++ b/wai/wai-rs/src/container.rs
@@ -2329,40 +2329,18 @@ impl WaiMulti {
     pub(crate) fn pick_where<V>(
         &self,
         eligible: impl Fn(usize, &RenditionMeta) -> Result<(), Skip>,
-        mut verify: impl FnMut(&str, &Prior) -> Result<V, PinRefusal>,
+        verify: impl FnMut(&str, &Prior) -> Result<V, PinRefusal>,
     ) -> Result<Picked<'_, V>, Vec<(usize, Skip)>> {
-        // SPEC §6.4 step 2, before selection: an encrypted envelope is inert at a sink
-        // that opens no scheme, and every entry is reported so.
-        if !manifest_v2_plaintext(&self.manifest) {
-            return Err((0..self.manifest.renditions.len()).map(|i| (i, Skip::Encrypted)).collect());
-        }
-        let mut skipped = Vec::new();
-        for (index, (meta, payload)) in self.manifest.renditions.iter().zip(self.renditions.iter()).enumerate() {
-            if !meta.is_selectable() {
-                skipped.push((index, Skip::NotSelectable));
-                continue;
-            }
-            if let Err(why) = eligible(index, meta) {
-                skipped.push((index, why));
-                continue;
-            }
-            if !meta.payload_digest_matches(payload) {
-                skipped.push((index, Skip::ComponentDigest));
-                continue;
-            }
-            let verified = match meta.prior.as_ref() {
-                Some(p) if pin_applies_to(&meta.capability) => match verify(&meta.capability, p) {
-                    Ok(v) => Some(v),
-                    Err(r) => {
-                        skipped.push((index, Skip::Pin(r)));
-                        continue;
-                    }
-                },
-                _ => None,
-            };
-            return Ok(Picked { index, meta, payload, verified, skipped });
-        }
-        Err(skipped)
+        let order: Vec<usize> = (0..self.manifest.renditions.len()).collect();
+        let digest_ok = |i: usize, m: &RenditionMeta| self.renditions.get(i).is_some_and(|p| m.payload_digest_matches(p));
+        let (index, verified, skipped) = select_entries(&self.manifest, &order, eligible, digest_ok, verify)?;
+        Ok(Picked {
+            index,
+            meta: &self.manifest.renditions[index],
+            payload: &self.renditions[index],
+            verified,
+            skipped,
+        })
     }
 
     /// Check that no component, in either role, names a candidate capability
@@ -2487,18 +2465,17 @@ impl WaiMulti {
     /// SPEC §7.1). A sink offers their exploded envelopes to staged-delivery §4
     /// ([`WaiMulti::explode`]) after [`Self::check_component_roles`] passes.
     pub fn refinements_of(&self, index: usize) -> Vec<(usize, &RenditionMeta, &[u8])> {
-        let metas = &self.manifest.renditions;
-        let Some(base_id) = metas.get(index).and_then(|b| b.id.as_deref()) else { return Vec::new() };
-        metas
-            .iter()
-            .zip(self.renditions.iter())
-            .enumerate()
-            .filter(|(_, (m, p))| {
-                m.is_refinement()
-                    && m.payload_digest_matches(p)
-                    && m.refines.as_ref().and_then(|v| Refines::from_value(v, RefForm::ComponentId).ok()).is_some_and(|r| r.base == base_id)
+        self.with_matching_payloads(refinement_indices(&self.manifest.renditions, index))
+    }
+
+    /// The entries at `indices` whose payload matches its `sha256`, with their
+    /// payloads.
+    fn with_matching_payloads(&self, indices: Vec<usize>) -> Vec<(usize, &RenditionMeta, &[u8])> {
+        indices.into_iter()
+            .filter_map(|i| {
+                let (m, p) = (self.manifest.renditions.get(i)?, self.renditions.get(i)?);
+                m.payload_digest_matches(p).then_some((i, m, p.as_slice()))
             })
-            .map(|(i, (m, p))| (i, m, p.as_slice()))
             .collect()
     }
 
@@ -2637,19 +2614,7 @@ impl WaiMulti {
     /// one only if the envelope passes [`Self::check_component_roles`] and it
     /// recognises the companion's capability.
     pub fn companions_of_index(&self, index: usize) -> Vec<(usize, &RenditionMeta, &[u8])> {
-        let metas = &self.manifest.renditions;
-        let Some(base) = metas.get(index) else { return Vec::new() };
-        metas.iter().zip(self.renditions.iter()).enumerate()
-            .filter(|(_, (m, p))| {
-                m.is_companion()
-                    && m.payload_digest_matches(p)
-                    && match m.companion_of_id.as_deref() {
-                        Some(id) => base.id.as_deref() == Some(id),
-                        None => m.companion_of.as_deref() == Some(base.capability.as_str()),
-                    }
-            })
-            .map(|(i, (m, p))| (i, m, p.as_slice()))
-            .collect()
+        self.with_matching_payloads(companion_indices(&self.manifest.renditions, index))
     }
 
     /// The companions that name `capability` in `companion_of`, whatever entry
@@ -2665,6 +2630,100 @@ impl WaiMulti {
     pub fn intent(&self) -> &str { &self.manifest.intent }
 }
 
+/// SPEC §7.1 selection over a `WAI2` manifest's entries alone, with no payload in
+/// hand: the walk [`WaiMulti::pick`] makes, in `order` (a deployer policy, SPEC §7.1
+/// step 2: a permutation of a subset of the entry indices; an index not in it is not
+/// considered, and an index out of range is ignored). Each entry considered is
+/// skipped, in this order, when it is not selectable ([`Skip::NotSelectable`]), when
+/// `eligible` refuses it (its reason), when `digest_ok` is false
+/// ([`Skip::ComponentDigest`]), or when its pin is refused ([`Skip::Pin`]); the first
+/// that passes is picked, with what `verify` returned and the entries skipped before
+/// it. An encrypted envelope (SPEC §6.4 step 2) is inert before any entry is
+/// considered: every entry is [`Skip::Encrypted`].
+///
+/// `digest_ok` is the payload test: `WaiMulti::pick` passes
+/// [`RenditionMeta::payload_digest_matches`] over the entry's payload, and a client
+/// that holds only the head passes `|_, _| true`, deferring the test to the bytes it
+/// fetches (`extensions/http-delivery.md` §7 step 4). Both are this one function, so
+/// the two paths pick alike on bytes that verify (http-delivery §7.2).
+pub fn select_entries<V>(
+    manifest: &ManifestV2,
+    order: &[usize],
+    eligible: impl Fn(usize, &RenditionMeta) -> Result<(), Skip>,
+    digest_ok: impl Fn(usize, &RenditionMeta) -> bool,
+    mut verify: impl FnMut(&str, &Prior) -> Result<V, PinRefusal>,
+) -> Result<(usize, Option<V>, Vec<(usize, Skip)>), Vec<(usize, Skip)>> {
+    let entries = &manifest.renditions;
+    // SPEC §6.4 step 2, before selection: an encrypted envelope is inert at a sink
+    // that opens no scheme, and every entry is reported so.
+    if !manifest_v2_plaintext(manifest) {
+        return Err((0..entries.len()).map(|i| (i, Skip::Encrypted)).collect());
+    }
+    let mut skipped = Vec::new();
+    for &index in order {
+        let Some(meta) = entries.get(index) else { continue };
+        if !meta.is_selectable() {
+            skipped.push((index, Skip::NotSelectable));
+            continue;
+        }
+        if let Err(why) = eligible(index, meta) {
+            skipped.push((index, why));
+            continue;
+        }
+        if !digest_ok(index, meta) {
+            skipped.push((index, Skip::ComponentDigest));
+            continue;
+        }
+        let verified = match meta.prior.as_ref() {
+            Some(p) if pin_applies_to(&meta.capability) => match verify(&meta.capability, p) {
+                Ok(v) => Some(v),
+                Err(r) => {
+                    skipped.push((index, Skip::Pin(r)));
+                    continue;
+                }
+            },
+            _ => None,
+        };
+        return Ok((index, verified, skipped));
+    }
+    Err(skipped)
+}
+
+/// The companions SPEC §7.1 binds to the entry at `index`, by entry alone: each
+/// companion whose `companion_of_id` names that entry's `id`, or, with no
+/// `companion_of_id`, whose `companion_of` is that entry's capability.
+/// [`WaiMulti::companions_of_index`] is this with the payload digest checked; a client
+/// that holds only the head checks it on the bytes it fetches.
+pub fn companion_indices(entries: &[RenditionMeta], index: usize) -> Vec<usize> {
+    let Some(base) = entries.get(index) else { return Vec::new() };
+    entries.iter().enumerate()
+        .filter(|(_, m)| {
+            m.is_companion()
+                && match m.companion_of_id.as_deref() {
+                    Some(id) => base.id.as_deref() == Some(id),
+                    None => m.companion_of.as_deref() == Some(base.capability.as_str()),
+                }
+        })
+        .map(|(i, _)| i)
+        .collect()
+}
+
+/// The refinement components whose `refines.base` names the entry at `index`, in
+/// table order, by entry alone: [`WaiMulti::refinements_of`] without the payload
+/// digest, which a client that holds only the head checks on the bytes it fetches.
+pub fn refinement_indices(entries: &[RenditionMeta], index: usize) -> Vec<usize> {
+    let Some(base_id) = entries.get(index).and_then(|b| b.id.as_deref()) else { return Vec::new() };
+    entries.iter().enumerate()
+        .filter(|(_, m)| {
+            m.is_refinement()
+                && m.refines.as_ref()
+                    .and_then(|v| Refines::from_value(v, RefForm::ComponentId).ok())
+                    .is_some_and(|r| r.base == base_id)
+        })
+        .map(|(i, _)| i)
+        .collect()
+}
+
 /// Sniff the magic and return which envelope version is in this byte
 /// blob. Lets callers branch on `Wai::from_bytes` vs `WaiMulti::from_bytes`
 /// without parsing twice.
diff --git a/wai/wai-rs/src/http_binding/codecs.rs b/wai/wai-rs/src/http_binding/codecs.rs
new file mode 100644
index 000000000..568a3c5ae
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/codecs.rs
@@ -0,0 +1,423 @@
+//! The `codecs` parameter (http-delivery §4): the grammar of a WAI element, the union
+//! a variant declares (exhaustive), the floor every object of it offers, and support.
+//! The registry decides kinds: [`crate::codecs::registry::capability_kind`] and
+//! [`crate::codecs::registry::is_candidate`].
+
+use super::head::{parse_head, Head, HeadParse, Version};
+use super::RangeRefusal;
+use crate::codecs::registry::{capability_kind, is_candidate, is_dispatchable, Kind};
+use crate::container::{companion_indices, refinement_indices, ManifestV2, RefForm, Refines};
+
+/// The container an element names: `wai1` (every object is a `WAI1`) or `wai2` (some
+/// object is a `WAI2`).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub enum Prefix {
+    Wai1,
+    Wai2,
+}
+
+impl Prefix {
+    /// `wai1` or `wai2`.
+    pub fn label(self) -> &'static str {
+        match self {
+            Prefix::Wai1 => "wai1",
+            Prefix::Wai2 => "wai2",
+        }
+    }
+}
+
+/// One `alt`: a selectable capability and the companion or refinement capabilities
+/// applied with it, each without its leading `wai.`.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Alt {
+    pub cap: String,
+    pub plus: Vec<String>,
+}
+
+/// A WAI element.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Element {
+    pub prefix: Prefix,
+    pub alts: Vec<Alt>,
+}
+
+/// Why a `codecs` value, or a head against one, is refused (§4).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum CodecsError {
+    Malformed(String),
+    NotMedia(String),
+    Candidate(String),
+    NoCommonCapability,
+    Undeclared(String),
+    /// A layer object (§10.4) whose `refines.base` names no object of the sequence.
+    LayerUnbound(String),
+}
+
+impl CodecsError {
+    /// `codecs_malformed`, `codecs_not_media`, `codecs_candidate`,
+    /// `codecs_no_common_capability` or `codecs_undeclared`.
+    pub fn code(&self) -> &'static str {
+        match self {
+            CodecsError::Malformed(_) => "codecs_malformed",
+            CodecsError::NotMedia(_) => "codecs_not_media",
+            CodecsError::Candidate(_) => "codecs_candidate",
+            CodecsError::NoCommonCapability => "codecs_no_common_capability",
+            CodecsError::Undeclared(_) => "codecs_undeclared",
+            CodecsError::LayerUnbound(_) => "codecs_layer_unbound",
+        }
+    }
+}
+
+impl std::fmt::Display for CodecsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            CodecsError::Malformed(s) | CodecsError::NotMedia(s) | CodecsError::Candidate(s) | CodecsError::Undeclared(s)
+            | CodecsError::LayerUnbound(s) => {
+                write!(f, "{}: {s}", self.code())
+            }
+            CodecsError::NoCommonCapability => f.write_str(self.code()),
+        }
+    }
+}
+
+impl std::error::Error for CodecsError {}
+
+/// Whether `cap` (without `wai.`) matches the `cap` rule.
+fn cap_matches(cap: &str) -> bool {
+    let mut parts = cap.split('.');
+    let first = parts.next().unwrap_or("");
+    let lcalnum = |b: u8| b.is_ascii_lowercase() || b.is_ascii_digit();
+    let mut rest = 0;
+    let ok_rest = parts.all(|p| {
+        rest += 1;
+        !p.is_empty() && p.bytes().all(|b| lcalnum(b) || b == b'_')
+    });
+    !first.is_empty() && first.bytes().all(lcalnum) && rest >= 1 && ok_rest
+}
+
+/// What a capability may be in an element, by its registered kind: an error for a
+/// record, a derivation or a candidate; otherwise whether it is applied with another
+/// (companion-only or refinement-only). A capability this revision does not register
+/// may stand either way.
+fn applied_kind(cap: &str) -> Result<Option<bool>, CodecsError> {
+    let full = format!("wai.{cap}");
+    match capability_kind(&full) {
+        Some(Kind::Derivation | Kind::Record) => Err(CodecsError::NotMedia(full)),
+        _ if is_candidate(&full) => Err(CodecsError::Candidate(full)),
+        Some(Kind::Companion | Kind::Refinement) => Ok(Some(true)),
+        Some(Kind::Payload) => Ok(Some(false)),
+        None => Ok(None),
+    }
+}
+
+/// A `cap` in its place: leading an alt (`first`), or after `+`.
+fn check_cap(cap: &str, first: bool) -> Result<(), CodecsError> {
+    if !cap_matches(cap) {
+        return Err(CodecsError::Malformed(format!("{cap:?} is not a capability without its wai. prefix")));
+    }
+    match (first, applied_kind(cap)?) {
+        (true, Some(true)) => Err(CodecsError::Malformed(format!("wai.{cap} is applied with another and cannot lead an alt"))),
+        (false, Some(false)) => Err(CodecsError::Malformed(format!("wai.{cap} is standalone media and cannot follow +"))),
+        _ => Ok(()),
+    }
+}
+
+fn check_alt(alt: &Alt) -> Result<(), CodecsError> {
+    check_cap(&alt.cap, true)?;
+    alt.plus.iter().try_for_each(|p| check_cap(p, false))
+}
+
+/// Parse one WAI element (§4.1). A `cap` twice among an element's alts, or twice in
+/// one alt, is malformed.
+pub fn parse_element(s: &str) -> Result<Element, CodecsError> {
+    let malformed = || CodecsError::Malformed(s.to_string());
+    let (prefix, rest) = s.split_once('.').ok_or_else(malformed)?;
+    let prefix = match prefix {
+        "wai1" => Prefix::Wai1,
+        "wai2" => Prefix::Wai2,
+        _ => return Err(malformed()),
+    };
+    let mut alts: Vec<Alt> = Vec::new();
+    for a in rest.split('|') {
+        let mut caps = a.split('+');
+        let cap = caps.next().unwrap_or("").to_string();
+        let alt = Alt { cap, plus: caps.map(str::to_string).collect() };
+        check_alt(&alt)?;
+        let repeated_plus = alt.plus.iter().enumerate().any(|(i, p)| alt.plus[..i].contains(p) || *p == alt.cap);
+        if repeated_plus || alts.iter().any(|x| x.cap == alt.cap) {
+            return Err(CodecsError::Malformed(format!("{s}: a capability named twice")));
+        }
+        alts.push(alt);
+    }
+    Ok(Element { prefix, alts })
+}
+
+/// Whether an element of a `codecs` value is a WAI element: it begins with `wai` in
+/// any ASCII case. Such an element that is not a well-formed `wai1.` or `wai2.` element
+/// is malformed, never classical.
+fn is_wai_element(e: &str) -> bool {
+    e.as_bytes().get(..3).is_some_and(|b| b.eq_ignore_ascii_case(b"wai"))
+}
+
+/// Parse a `codecs` value: one entry per `,`-separated element, `None` for a
+/// classical element (§4.1). Spaces and tabs around an element are not part of it; an
+/// empty element is malformed.
+pub fn parse(value: &str) -> Result<Vec<Option<Element>>, CodecsError> {
+    value
+        .split(',')
+        .map(|e| e.trim_matches(|c| c == ' ' || c == '\t'))
+        .map(|e| {
+            if e.is_empty() {
+                Err(CodecsError::Malformed(format!("{value:?}: an empty element")))
+            } else if is_wai_element(e) {
+                parse_element(e).map(Some)
+            } else {
+                Ok(None)
+            }
+        })
+        .collect()
+}
+
+/// The element as text.
+pub fn render(e: &Element) -> String {
+    let alts: Vec<String> = e.alts.iter().map(|a| std::iter::once(a.cap.as_str()).chain(a.plus.iter().map(String::as_str)).collect::<Vec<_>>().join("+")).collect();
+    format!("{}.{}", e.prefix.label(), alts.join("|"))
+}
+
+fn short(cap: &str) -> String {
+    cap.strip_prefix("wai.").unwrap_or(cap).to_string()
+}
+
+fn push_unique(v: &mut Vec<String>, s: String) {
+    if !v.contains(&s) {
+        v.push(s);
+    }
+}
+
+/// The alts of one `WAI2` manifest: one per distinct selectable capability (SPEC §7.1:
+/// never a companion, a refinement or a capability SPEC §4 does not dispatch) in table
+/// order, each with the companion capabilities bound to a rendition of it and the
+/// refinement capabilities whose base is one, in table order.
+fn alts_v2(m: &ManifestV2) -> Vec<Alt> {
+    let e = &m.renditions;
+    let mut alts: Vec<Alt> = Vec::new();
+    for (i, r) in e.iter().enumerate() {
+        if !r.is_selectable() {
+            continue;
+        }
+        let cap = short(&r.capability);
+        let pos = match alts.iter().position(|a| a.cap == cap) {
+            Some(p) => p,
+            None => {
+                alts.push(Alt { cap, plus: Vec::new() });
+                alts.len() - 1
+            }
+        };
+        let mut bound: Vec<usize> = companion_indices(e, i);
+        bound.extend(refinement_indices(e, i));
+        bound.sort_unstable();
+        for j in bound {
+            push_unique(&mut alts[pos].plus, short(&e[j].capability));
+        }
+    }
+    // `+` capabilities in table order across the renditions of one capability.
+    for a in &mut alts {
+        a.plus.sort_by_key(|p| e.iter().position(|r| short(&r.capability) == *p));
+    }
+    alts
+}
+
+/// The element describing one object that is not a layer (§4.2): its union. A `WAI1`
+/// lists its capability and its fallback where SPEC §4 dispatches them; an object that
+/// lists none is not media (`codecs_not_media`). A layer has no element of its own: it
+/// joins its base's (§4.2, [`union_of`]).
+pub fn element_of(head: &Head) -> Result<Element, CodecsError> {
+    let bad = |e: super::RangeRefusal| CodecsError::Malformed(e.to_string());
+    if head.is_layer() {
+        return Err(CodecsError::Malformed("a layer is described with its base".into()));
+    }
+    let (prefix, alts) = match head.version {
+        Version::Wai1 => {
+            let m = head.manifest_v1().map_err(bad)?;
+            let mut alts: Vec<Alt> = Vec::new();
+            for c in [Some(m.model_requirement.capability.as_str()), m.model_requirement.fallback.as_deref()].into_iter().flatten() {
+                if is_dispatchable(c) && !alts.iter().any(|a| a.cap == short(c)) {
+                    alts.push(Alt { cap: short(c), plus: Vec::new() });
+                }
+            }
+            (Prefix::Wai1, alts)
+        }
+        Version::Wai2 => (Prefix::Wai2, alts_v2(&head.manifest_v2().map_err(bad)?)),
+    };
+    if alts.is_empty() {
+        return Err(CodecsError::NotMedia("no capability SPEC §4 dispatches".into()));
+    }
+    for a in &alts {
+        check_alt(a)?;
+    }
+    Ok(Element { prefix, alts })
+}
+
+/// One object of a sequence, as [`union_of`] and [`floor_of`] read it: its content
+/// hash, its head, and, for a `WAI2`, the content hash of each component's exploded
+/// envelope (SPEC §7.1) where one can be built: a layer may name any of these as its
+/// base.
+#[derive(Clone, Debug)]
+pub struct SeqObject {
+    pub cid: [u8; 32],
+    pub head: Head,
+    pub components: Vec<Option<[u8; 32]>>,
+}
+
+impl SeqObject {
+    /// The object an envelope is.
+    pub fn from_envelope(env: &[u8]) -> Result<SeqObject, RangeRefusal> {
+        let head = match parse_head(env, env.len() as u64)? {
+            HeadParse::Head(h) => h,
+            HeadParse::Need(n) => return Err(RangeRefusal::HeadMalformed(format!("the head needs {n} bytes"))),
+        };
+        let components = match head.version {
+            Version::Wai1 => Vec::new(),
+            Version::Wai2 => crate::container::WaiMulti::explode_each(env)
+                .map(|v| v.into_iter().map(|r| r.ok().map(|b| super::content_hash(&b))).collect())
+                .unwrap_or_default(),
+        };
+        Ok(SeqObject { cid: super::content_hash(env), head, components })
+    }
+}
+
+/// The capability through which object `b` is the base whose content hash is `base`: a
+/// `WAI1`'s `capability` when its cid is `base`, or the capability of the selectable
+/// component of a `WAI2` whose exploded envelope has that hash. `None` otherwise.
+fn base_capability(b: &SeqObject, base: &[u8; 32]) -> Option<String> {
+    if b.head.is_layer() {
+        return None;
+    }
+    if b.cid == *base && b.head.version == Version::Wai1 {
+        return b.head.manifest_v1().ok().map(|m| short(&m.model_requirement.capability));
+    }
+    let i = b.components.iter().position(|c| *c == Some(*base))?;
+    let m = b.head.manifest_v2().ok()?;
+    m.renditions.get(i).filter(|r| r.is_selectable()).map(|r| short(&r.capability))
+}
+
+/// The alts of each object of a sequence that is not a layer, with each layer's
+/// capability after `+` in the alt of the base its `refines.base` names: a `WAI1`
+/// object of the sequence, through its capability (staged delivery's base is never
+/// decoded through a fallback), or a `WAI2` component, through the component's
+/// capability. Layers join in sequence order, after the object's own capabilities.
+fn described(objects: &[SeqObject]) -> Result<Vec<Element>, CodecsError> {
+    let mut els: Vec<Option<Element>> = Vec::new();
+    for o in objects {
+        els.push(if o.head.is_layer() { None } else { Some(element_of(&o.head)?) });
+    }
+    for o in objects.iter().filter(|o| o.head.is_layer()) {
+        let m = o.head.manifest_v1().map_err(|e| CodecsError::Malformed(e.to_string()))?;
+        let cap = short(&m.model_requirement.capability);
+        check_cap(&cap, false)?;
+        let refines = m.refines.as_ref()
+            .ok_or_else(|| CodecsError::Malformed(format!("the layer wai.{cap} carries no refines")))
+            .and_then(|v| Refines::from_value(v, RefForm::ContentHash).map_err(|e| CodecsError::Malformed(format!("refines: {}", e.0))))?;
+        let base = super::unhex32(&refines.base).ok_or_else(|| CodecsError::Malformed("refines.base".into()))?;
+        let target: Option<(usize, String)> = objects.iter().enumerate()
+            .filter(|(_, b)| !b.head.is_layer())
+            .find_map(|(k, b)| base_capability(b, &base).map(|c| (k, c)));
+        let (k, base_cap) = target.ok_or_else(|| CodecsError::LayerUnbound(format!("wai.{cap} refines {}", refines.base)))?;
+        let el = els[k].as_mut().expect("a base is not a layer");
+        let alt = el.alts.iter_mut().find(|a| a.cap == base_cap)
+            .ok_or_else(|| CodecsError::LayerUnbound(format!("wai.{cap}: its base's capability is not dispatched")))?;
+        push_unique(&mut alt.plus, cap);
+    }
+    Ok(els.into_iter().flatten().collect())
+}
+
+/// The union of a sequence of objects (§4.2): every `alt` any of them has, by first
+/// appearance, each with every capability applied with it in any of them, layers
+/// included. `wai2` when any object is a `WAI2`.
+pub fn union_of(objects: &[SeqObject]) -> Result<Element, CodecsError> {
+    let each = described(objects)?;
+    let prefix = objects.iter().map(|o| if o.head.version == Version::Wai2 { Prefix::Wai2 } else { Prefix::Wai1 }).max().unwrap_or(Prefix::Wai1);
+    let mut alts: Vec<Alt> = Vec::new();
+    for e in each {
+        for a in e.alts {
+            match alts.iter_mut().find(|x| x.cap == a.cap) {
+                Some(x) => {
+                    for p in a.plus {
+                        push_unique(&mut x.plus, p);
+                    }
+                }
+                None => alts.push(a),
+            }
+        }
+    }
+    if alts.is_empty() {
+        return Err(CodecsError::NoCommonCapability);
+    }
+    Ok(Element { prefix, alts })
+}
+
+/// The floor of a sequence of objects (§4.2): the `alt`s whose capability every object
+/// that is not a layer has, each with the capabilities applied with it in every such
+/// object, written with the union's prefix. Empty: `codecs_no_common_capability`.
+pub fn floor_of(objects: &[SeqObject]) -> Result<Element, CodecsError> {
+    let union = union_of(objects)?;
+    let each = described(objects)?;
+    let mut alts = Vec::new();
+    for a in &union.alts {
+        let found: Vec<&Alt> = each.iter().filter_map(|e| e.alts.iter().find(|x| x.cap == a.cap)).collect();
+        if found.len() != each.len() {
+            continue;
+        }
+        let plus = a.plus.iter().filter(|p| found.iter().all(|x| x.plus.contains(p))).cloned().collect();
+        alts.push(Alt { cap: a.cap.clone(), plus });
+    }
+    if alts.is_empty() {
+        return Err(CodecsError::NoCommonCapability);
+    }
+    Ok(Element { prefix: union.prefix, alts })
+}
+
+/// §7 step 3: refuse an object whose head names a capability, or a container, the
+/// variant's union does not list (`codecs_undeclared`). A layer is declared when its
+/// capability follows `+` in the alt of its own base's capability, as [`union_of`] puts
+/// it there: `base` is the object its playlist lists it under, and a layer whose
+/// `refines.base` does not name `base` (or one of its components), or that comes with no
+/// base, is undeclared.
+pub fn check_declared(head: &Head, union: &Element, base: Option<&SeqObject>) -> Result<(), CodecsError> {
+    if head.is_layer() {
+        let m = head.manifest_v1().map_err(|e| CodecsError::Malformed(e.to_string()))?;
+        let cap = short(&m.model_requirement.capability);
+        let undeclared = || CodecsError::Undeclared(format!("the layer wai.{cap}"));
+        let refines = m.refines.as_ref()
+            .and_then(|v| Refines::from_value(v, RefForm::ContentHash).ok())
+            .and_then(|r| super::unhex32(&r.base))
+            .ok_or_else(undeclared)?;
+        let base_cap = base.and_then(|b| base_capability(b, &refines)).ok_or_else(undeclared)?;
+        return if union.alts.iter().any(|a| a.cap == base_cap && a.plus.contains(&cap)) { Ok(()) } else { Err(undeclared()) };
+    }
+    let e = element_of(head)?;
+    if e.prefix > union.prefix {
+        return Err(CodecsError::Undeclared("a WAI2 object under a wai1 element".into()));
+    }
+    for a in &e.alts {
+        let Some(u) = union.alts.iter().find(|u| u.cap == a.cap) else {
+            return Err(CodecsError::Undeclared(format!("wai.{}", a.cap)));
+        };
+        if let Some(p) = a.plus.iter().find(|p| !u.plus.contains(p)) {
+            return Err(CodecsError::Undeclared(format!("wai.{p} with wai.{}", a.cap)));
+        }
+    }
+    Ok(())
+}
+
+/// §4.2's support over the floor: the sink reads the element's container
+/// (`containers`) and has the leading capability of at least one of the floor's
+/// `alt`s (`has`, given the full capability string). The capabilities after `+`
+/// never affect support.
+pub fn supports(floor: &Element, containers: &[Prefix], has: impl Fn(&str) -> bool) -> bool {
+    let reads = match floor.prefix {
+        Prefix::Wai1 => containers.contains(&Prefix::Wai1),
+        Prefix::Wai2 => containers.contains(&Prefix::Wai1) && containers.contains(&Prefix::Wai2),
+    };
+    reads && floor.alts.iter().any(|a| has(&format!("wai.{}", a.cap)))
+}
diff --git a/wai/wai-rs/src/http_binding/head.rs b/wai/wai-rs/src/http_binding/head.rs
new file mode 100644
index 000000000..97ff1fac8
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/head.rs
@@ -0,0 +1,169 @@
+//! The head of an object (http-delivery §2, §5.1): for `WAI1`, the magic, `man_len`,
+//! the manifest and `payload_len`; for `WAI2`, the magic, `man_len`, the manifest,
+//! `n_renditions` and the rendition table (SPEC §2, §7.1). The head gives every
+//! component's byte range and, through each entry's `sha256`, its digest.
+
+use super::{RangeRefusal, DOMAIN_LEN};
+use crate::container::{check_unique_members, Manifest, ManifestV2};
+
+/// Which container an object is.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Version {
+    Wai1,
+    Wai2,
+}
+
+/// One component's byte range in the object: [start, start + len).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct ComponentRange {
+    pub index: usize,
+    pub start: u64,
+    pub len: u64,
+}
+
+/// A parsed head. `bytes` is the head itself, [0, head_len).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Head {
+    pub version: Version,
+    pub head_len: u64,
+    pub envelope_len: u64,
+    pub manifest: std::ops::Range<u64>,
+    pub components: Vec<ComponentRange>,
+    pub bytes: Vec<u8>,
+}
+
+/// What [`parse_head`] found: the head, or how many bytes from offset 0 it needs.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum HeadParse {
+    Need(u64),
+    Head(Head),
+}
+
+/// `covered_len` (http-delivery §2): the head rounded up so that, with the content
+/// hash's domain prefix, it ends on a BLAKE3 chunk boundary, and never past the object.
+pub fn covered_len(head_len: u64, envelope_len: u64) -> u64 {
+    let x = DOMAIN_LEN + head_len;
+    envelope_len.min(x.div_ceil(1024) * 1024 - DOMAIN_LEN)
+}
+
+fn u32_at(b: &[u8], at: usize) -> u64 {
+    u64::from(u32::from_le_bytes(b[at..at + 4].try_into().expect("4 bytes")))
+}
+
+/// Parse the head at the start of `prefix`, an object of `envelope_len` bytes, and
+/// apply §5.1: the object is exactly one envelope. Returns `Need(n)` while `prefix`
+/// holds fewer than the `n` bytes the head needs.
+pub fn parse_head(prefix: &[u8], envelope_len: u64) -> Result<HeadParse, RangeRefusal> {
+    let have = prefix.len() as u64;
+    if have < 8 {
+        return Ok(HeadParse::Need(8));
+    }
+    let version = match &prefix[..4] {
+        b"WAI1" => Version::Wai1,
+        b"WAI2" => Version::Wai2,
+        _ => return Err(RangeRefusal::HeadMalformed("the magic is neither WAI1 nor WAI2".into())),
+    };
+    let man_len = u32_at(prefix, 4);
+    let manifest = 8..8 + man_len;
+    let (head_len, components) = match version {
+        Version::Wai1 => {
+            let head_len = 12 + man_len;
+            if have < head_len {
+                return Ok(HeadParse::Need(head_len));
+            }
+            let payload_len = u32_at(prefix, (8 + man_len) as usize);
+            (head_len, vec![ComponentRange { index: 0, start: head_len, len: payload_len }])
+        }
+        Version::Wai2 => {
+            if have < 10 + man_len {
+                return Ok(HeadParse::Need(10 + man_len));
+            }
+            let at = (8 + man_len) as usize;
+            let n = u64::from(u16::from_le_bytes([prefix[at], prefix[at + 1]]));
+            let head_len = 10 + man_len + 8 * n;
+            if have < head_len {
+                return Ok(HeadParse::Need(head_len));
+            }
+            let table = at + 2;
+            let mut expected = 0u64;
+            let mut components = Vec::with_capacity(n as usize);
+            for i in 0..n as usize {
+                let off = u32_at(prefix, table + 8 * i);
+                let len = u32_at(prefix, table + 8 * i + 4);
+                if off != expected {
+                    return Err(RangeRefusal::HeadMalformed(format!(
+                        "rendition {i}'s offset {off} is not contiguous (expected {expected})")));
+                }
+                components.push(ComponentRange { index: i, start: head_len + off, len });
+                expected += len;
+            }
+            (head_len, components)
+        }
+    };
+    let total = head_len + components.iter().map(|c| c.len).sum::<u64>();
+    if total != envelope_len {
+        return Err(RangeRefusal::ObjectLengthMismatch { expected: total, got: envelope_len });
+    }
+    let bytes = prefix[..head_len as usize].to_vec();
+    let head = Head { version, head_len, envelope_len, manifest, components, bytes };
+    // The manifest parses, names no member twice, and (WAI2) has one entry per row.
+    match head.version {
+        Version::Wai1 => {
+            head.manifest_v1()?;
+        }
+        Version::Wai2 => {
+            let m = head.manifest_v2()?;
+            if m.renditions.len() != head.components.len() {
+                return Err(RangeRefusal::HeadMalformed(format!(
+                    "the table has {} rows and the manifest {} renditions",
+                    head.components.len(), m.renditions.len())));
+            }
+        }
+    }
+    Ok(HeadParse::Head(head))
+}
+
+impl Head {
+    fn manifest_bytes(&self) -> &[u8] {
+        &self.bytes[self.manifest.start as usize..self.manifest.end as usize]
+    }
+
+    /// The `WAI1` manifest.
+    pub fn manifest_v1(&self) -> Result<Manifest, RangeRefusal> {
+        if self.version != Version::Wai1 {
+            return Err(RangeRefusal::HeadMalformed("not a WAI1 head".into()));
+        }
+        let b = self.manifest_bytes();
+        check_unique_members(b).map_err(|e| RangeRefusal::HeadMalformed(e.to_string()))?;
+        serde_json::from_slice(b).map_err(|e| RangeRefusal::HeadMalformed(e.to_string()))
+    }
+
+    /// The `WAI2` manifest.
+    pub fn manifest_v2(&self) -> Result<ManifestV2, RangeRefusal> {
+        if self.version != Version::Wai2 {
+            return Err(RangeRefusal::HeadMalformed("not a WAI2 head".into()));
+        }
+        let b = self.manifest_bytes();
+        check_unique_members(b).map_err(|e| RangeRefusal::HeadMalformed(e.to_string()))?;
+        serde_json::from_slice(b).map_err(|e| RangeRefusal::HeadMalformed(e.to_string()))
+    }
+
+    /// The component at `index`.
+    pub fn component(&self, index: usize) -> Option<ComponentRange> {
+        self.components.get(index).copied()
+    }
+
+    /// This object's `covered_len`.
+    pub fn covered_len(&self) -> u64 {
+        covered_len(self.head_len, self.envelope_len)
+    }
+
+    /// Whether the object is a layer (http-delivery §2, §10.4): a `WAI1` whose capability
+    /// is refinement-only (SPEC §5; staged-delivery §3). A layer goes to staged delivery
+    /// §4, never to SPEC §4's dispatch. A payload capability that carries `refines` is an
+    /// ordinary object: SPEC §4 dispatches it, and `refines` is not read there.
+    pub fn is_layer(&self) -> bool {
+        self.version == Version::Wai1
+            && self.manifest_v1().is_ok_and(|m| crate::codecs::is_refinement_only(&m.model_requirement.capability))
+    }
+}
diff --git a/wai/wai-rs/src/http_binding/head_proof.rs b/wai/wai-rs/src/http_binding/head_proof.rs
new file mode 100644
index 000000000..16c372354
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/head_proof.rs
@@ -0,0 +1,226 @@
+//! The `WHP1` head proof (http-delivery §6): the BLAKE3 chaining values that prove an
+//! object's bytes [0, covered_len) against its content hash without the rest.
+//!
+//! The content hash is the BLAKE3 root over `X = "moq-jwp:object\x01" ‖ envelope`
+//! (jwp-receipts §2.1). The proof carries the chaining value of every subtree of `X`
+//! that lies wholly at or after `c = 15 + covered_len`, in the order §6.3's procedure
+//! consumes them; a verifier computes every subtree before `c` from the bytes it holds
+//! and merges up to the root.
+
+use blake3::hazmat::{merge_subtrees_non_root, merge_subtrees_root, ChainingValue, HasherExt, Mode};
+
+use super::head::{covered_len, parse_head, HeadParse};
+use super::{RangeRefusal, DOMAIN_LEN};
+use crate::jwp_hash::DOMAIN_OBJECT;
+
+/// The file's magic, "WHP1".
+pub const MAGIC: &[u8; 4] = b"WHP1";
+// Kept out of the crate's public constants, which the C header generator exports.
+const MAX_CV: usize = HeadProof::MAX_CV;
+const FIXED_LEN: usize = HeadProof::FIXED_LEN;
+
+const CHUNK: u64 = 1024;
+
+/// A parsed head proof.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct HeadProof {
+    pub cid: [u8; 32],
+    pub envelope_len: u64,
+    pub covered_len: u64,
+    pub cvs: Vec<[u8; 32]>,
+}
+
+/// The length of the left subtree of a BLAKE3 subtree of `n` bytes (`n` > 1024):
+/// `1024 · 2^⌊log₂((n−1)/1024)⌋`, the largest power-of-two number of chunks that
+/// leaves at least one byte to the right.
+fn left_len(n: u64) -> u64 {
+    let q = (n - 1) / CHUNK;
+    CHUNK << (63 - q.leading_zeros())
+}
+
+/// The root of a tree from its two children: BLAKE3's parent node with the ROOT flag.
+fn merge_root(l: &ChainingValue, r: &ChainingValue) -> [u8; 32] {
+    *merge_subtrees_root(l, r, Mode::Hash).as_bytes()
+}
+
+/// The non-root chaining value of the subtree `x[..len]` whose first chunk is at
+/// byte offset `start` of the whole input.
+fn subtree_cv(x: &[u8], start: u64) -> ChainingValue {
+    let mut h = blake3::Hasher::new();
+    h.set_input_offset(start);
+    h.update(x);
+    h.finalize_non_root()
+}
+
+/// §6.3's `cv(start, len)`: the chaining value of the subtree [start, start + len) of
+/// `X`, computed from `x_prefix` (`X`'s first `c` bytes) where the subtree lies wholly
+/// before `c`, taken from `it` where it lies wholly at or after `c`, and merged from
+/// its two children otherwise.
+fn node_cv(
+    x_prefix: &[u8],
+    start: u64,
+    len: u64,
+    c: u64,
+    it: &mut dyn Iterator<Item = [u8; 32]>,
+) -> Result<ChainingValue, RangeRefusal> {
+    if start >= c {
+        it.next().ok_or(RangeRefusal::HeadProofMismatch)
+    } else if start + len <= c {
+        Ok(subtree_cv(&x_prefix[start as usize..(start + len) as usize], start))
+    } else {
+        let l = left_len(len);
+        let left = node_cv(x_prefix, start, l, c, it)?;
+        let right = node_cv(x_prefix, start + l, len - l, c, it)?;
+        Ok(merge_subtrees_non_root(&left, &right, Mode::Hash))
+    }
+}
+
+/// The producer's walk: the chaining values of the subtrees at or after `c`, in the
+/// order [`node_cv`] consumes them.
+fn collect_cvs(x: &[u8], start: u64, len: u64, c: u64, out: &mut Vec<[u8; 32]>) {
+    if start >= c {
+        out.push(subtree_cv(&x[start as usize..(start + len) as usize], start));
+    } else if start + len > c {
+        let l = left_len(len);
+        collect_cvs(x, start, l, c, out);
+        collect_cvs(x, start + l, len - l, c, out);
+    }
+}
+
+impl HeadProof {
+    /// The most chaining values a proof may carry.
+    pub const MAX_CV: usize = 64;
+    /// The fixed part of the file: magic, cid, `envelope_len`, `covered_len`, `n_cv`.
+    pub const FIXED_LEN: usize = 53;
+
+    /// The head proof of `envelope`, whose head must parse (§5.1 included).
+    pub fn build(envelope: &[u8]) -> Result<HeadProof, RangeRefusal> {
+        let envelope_len = envelope.len() as u64;
+        let head = match parse_head(envelope, envelope_len)? {
+            HeadParse::Head(h) => h,
+            HeadParse::Need(n) => {
+                return Err(RangeRefusal::HeadMalformed(format!("the head needs {n} bytes; the object has {envelope_len}")))
+            }
+        };
+        let cid = super::content_hash(envelope);
+        let covered = covered_len(head.head_len, envelope_len);
+        let mut cvs = Vec::new();
+        if covered < envelope_len {
+            let mut x = Vec::with_capacity(DOMAIN_OBJECT.len() + envelope.len());
+            x.extend_from_slice(DOMAIN_OBJECT);
+            x.extend_from_slice(envelope);
+            let (l_total, c) = (x.len() as u64, DOMAIN_LEN + covered);
+            let l = left_len(l_total);
+            collect_cvs(&x, 0, l, c, &mut cvs);
+            collect_cvs(&x, l, l_total - l, c, &mut cvs);
+        }
+        Ok(HeadProof { cid, envelope_len, covered_len: covered, cvs })
+    }
+
+    /// The `WHP1` file.
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let mut out = Vec::with_capacity(FIXED_LEN + 32 * self.cvs.len());
+        out.extend_from_slice(MAGIC);
+        out.extend_from_slice(&self.cid);
+        out.extend_from_slice(&self.envelope_len.to_le_bytes());
+        out.extend_from_slice(&self.covered_len.to_le_bytes());
+        out.push(self.cvs.len() as u8);
+        for cv in &self.cvs {
+            out.extend_from_slice(cv);
+        }
+        out
+    }
+
+    /// Read a `WHP1` file: its magic, its length, `n_cv` at most [`MAX_CV`], and a
+    /// `covered_len` that is the object's length or ends `X` on a chunk boundary
+    /// before the object's end (§6.3 check 1, the part the file alone decides).
+    pub fn from_bytes(b: &[u8]) -> Result<HeadProof, RangeRefusal> {
+        if b.len() < FIXED_LEN || &b[..4] != MAGIC {
+            return Err(RangeRefusal::HeadProofMalformed("not a WHP1 file"));
+        }
+        let n = b[52] as usize;
+        if n > MAX_CV {
+            return Err(RangeRefusal::HeadProofMalformed("more than 64 chaining values"));
+        }
+        if b.len() != FIXED_LEN + 32 * n {
+            return Err(RangeRefusal::HeadProofMalformed("the file is not 53 + 32·n_cv bytes"));
+        }
+        let cid: [u8; 32] = b[4..36].try_into().expect("32 bytes");
+        let envelope_len = u64::from_le_bytes(b[36..44].try_into().expect("8 bytes"));
+        let covered = u64::from_le_bytes(b[44..52].try_into().expect("8 bytes"));
+        // `X` is the domain and the envelope: its length must be a u64 too.
+        if envelope_len > u64::MAX - DOMAIN_LEN || covered > envelope_len {
+            return Err(RangeRefusal::HeadProofMalformed("envelope_len or covered_len past what a u64 offset into X can name"));
+        }
+        let aligned = covered < envelope_len && (DOMAIN_LEN + covered) % CHUNK == 0;
+        if !(covered == envelope_len || aligned) {
+            return Err(RangeRefusal::HeadProofMalformed("covered_len neither ends a chunk nor is the object's length"));
+        }
+        if covered == envelope_len && n != 0 {
+            return Err(RangeRefusal::HeadProofMalformed("a proof that covers the whole object carries chaining values"));
+        }
+        let cvs = b[FIXED_LEN..].chunks_exact(32).map(|c| c.try_into().expect("32 bytes")).collect();
+        Ok(HeadProof { cid, envelope_len, covered_len: covered, cvs })
+    }
+
+    /// §6.3: check this proof against the object's `cid` and the bytes `prefix` (at
+    /// least [0, covered_len) of the object), in order: the proof names this object
+    /// (`head_proof_malformed`); its chaining values are consumed exactly and the
+    /// root equals the cid (`head_proof_mismatch`); and its `envelope_len` is the
+    /// length the verified head gives and its `covered_len` §2's formula for that head
+    /// (`head_proof_malformed`). No byte of `prefix` is parsed before its hash is
+    /// checked.
+    pub fn verify(&self, cid: &[u8; 32], prefix: &[u8]) -> Result<(), RangeRefusal> {
+        if &self.cid != cid {
+            return Err(RangeRefusal::HeadProofMalformed("the proof names another object"));
+        }
+        if (prefix.len() as u64) < self.covered_len {
+            return Err(RangeRefusal::HeadProofMalformed("fewer bytes are held than the proof covers"));
+        }
+        let covered = &prefix[..self.covered_len as usize];
+        if self.covered_len == self.envelope_len {
+            if !self.cvs.is_empty() {
+                return Err(RangeRefusal::HeadProofMalformed("a proof that covers the whole object carries chaining values"));
+            }
+            if &super::content_hash(covered) != cid {
+                return Err(RangeRefusal::HeadProofMismatch);
+            }
+        } else {
+            let mut x = Vec::with_capacity(DOMAIN_OBJECT.len() + covered.len());
+            x.extend_from_slice(DOMAIN_OBJECT);
+            x.extend_from_slice(covered);
+            let past = RangeRefusal::HeadProofMalformed("envelope_len or covered_len past what a u64 offset into X can name");
+            let l_total = DOMAIN_LEN.checked_add(self.envelope_len).ok_or(past.clone())?;
+            let c = DOMAIN_LEN.checked_add(self.covered_len).ok_or(past)?;
+            if c % CHUNK != 0 || c >= l_total {
+                return Err(RangeRefusal::HeadProofMalformed("covered_len neither ends a chunk nor is the object's length"));
+            }
+            let mut it = self.cvs.iter().copied();
+            let l = left_len(l_total);
+            let left = node_cv(&x, 0, l, c, &mut it)?;
+            let right = node_cv(&x, l, l_total - l, c, &mut it)?;
+            if it.next().is_some() || &merge_root(&left, &right) != cid {
+                return Err(RangeRefusal::HeadProofMismatch);
+            }
+        }
+        // The bytes are the object's: now read the head they hold, whose fields give the
+        // object's length (§5.1).
+        let head = match parse_head(covered, self.envelope_len) {
+            Ok(HeadParse::Head(h)) => h,
+            Ok(HeadParse::Need(_)) => return Err(RangeRefusal::HeadProofMalformed("covered_len ends before the head does")),
+            Err(RangeRefusal::ObjectLengthMismatch { .. }) => {
+                return Err(RangeRefusal::HeadProofMalformed("envelope_len is not the length the head gives"))
+            }
+            Err(e) => return Err(e),
+        };
+        if covered_len(head.head_len, self.envelope_len) != self.covered_len {
+            return Err(RangeRefusal::HeadProofMalformed("covered_len is not §2's formula for this head"));
+        }
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+pub(super) fn left_len_for_test(n: u64) -> u64 {
+    left_len(n)
+}
diff --git a/wai/wai-rs/src/http_binding/mod.rs b/wai/wai-rs/src/http_binding/mod.rs
new file mode 100644
index 000000000..209d06399
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/mod.rs
@@ -0,0 +1,217 @@
+//! HTTP delivery (`extensions/http-delivery.md`): an envelope served as one immutable
+//! object named by its content hash, its head proved against that hash (`WHP1`), and
+//! one `WAI2` component fetched by range and checked against its entry's digest, with
+//! the pick equal to whole-envelope selection on every path.
+//!
+//! - [`head`]: the head of a `WAI1` or `WAI2` (§2, §5.1) and `covered_len`;
+//! - [`head_proof`]: the `WHP1` head proof (§6);
+//! - [`plan`]: which ranges to request, in which priority class (§7, §10.1);
+//! - [`session`]: a sans-IO driver of §7, its response checks (§7.1) and the
+//!   whole-object fallback;
+//! - [`codecs`]: the `codecs` grammar, the union and the floor (§4);
+//! - [`playlist`]: the `#WAI-LAYER` tag (§10.4);
+//! - [`origin`]: an origin's responses (§5.3) and byte-range answers.
+//!
+//! Nothing here performs I/O: the `wai http` commands and the reference origin do.
+
+pub mod codecs;
+pub mod head;
+pub mod head_proof;
+pub mod origin;
+pub mod plan;
+pub mod playlist;
+pub mod session;
+
+#[cfg(test)]
+mod tests;
+
+/// The proposed media type of an object (§3). It is not registered.
+pub const MEDIA_TYPE: &str = "application/wai";
+
+/// jwp-receipts §2.1's content hash: an object's name (§2). One implementation,
+/// [`crate::jwp_hash::content_hash`].
+pub use crate::jwp_hash::content_hash;
+
+/// The smallest `envelope_len` a head proof can leave uncovered bytes in: one BLAKE3
+/// chunk less the content-hash domain (§5.4). Below it a client fetches whole.
+pub(crate) const MIN_RANGE_OBJECT: u64 = 1024 - DOMAIN_LEN;
+
+/// The length of jwp-receipts §2.1's domain prefix, `"moq-jwp:object\x01"`.
+pub(crate) const DOMAIN_LEN: u64 = crate::jwp_hash::DOMAIN_OBJECT.len() as u64;
+
+/// 64 lowercase hexadecimal digits.
+pub fn hex(bytes: &[u8]) -> String {
+    bytes.iter().map(|b| format!("{b:02x}")).collect()
+}
+
+/// 32 bytes from 64 lowercase hexadecimal digits, or `None`.
+pub fn unhex32(s: &str) -> Option<[u8; 32]> {
+    if s.len() != 64 || !s.bytes().all(|b| b.is_ascii_digit() || (b'a'..=b'f').contains(&b)) {
+        return None;
+    }
+    let mut out = [0u8; 32];
+    for (i, o) in out.iter_mut().enumerate() {
+        *o = u8::from_str_radix(&s[2 * i..2 * i + 2], 16).ok()?;
+    }
+    Some(out)
+}
+
+/// The last path segment of an object's canonical URI, `<cid>.wai` (§5.2).
+pub fn object_name(cid: &[u8; 32]) -> String {
+    format!("{}.wai", hex(cid))
+}
+
+/// The fragment identifiers of an object's URI (§3.1). Unknown keys are ignored, and
+/// so is a value that does not parse.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct Fragment {
+    pub cid: Option<[u8; 32]>,
+    pub n: Option<u64>,
+    pub h: Option<u64>,
+    pub c: Option<String>,
+}
+
+/// Split `uri` at its fragment: the URI without it, and the identifiers it carries.
+pub fn parse_fragment(uri: &str) -> (String, Fragment) {
+    let Some((base, frag)) = uri.split_once('#') else { return (uri.to_string(), Fragment::default()) };
+    let mut f = Fragment::default();
+    for pair in frag.split('&') {
+        let Some((k, v)) = pair.split_once('=') else { continue };
+        match k {
+            "cid" => f.cid = unhex32(v),
+            "n" => f.n = v.parse().ok(),
+            "h" => f.h = v.parse().ok(),
+            "c" if crate::container::is_component_id(v) => f.c = Some(v.to_string()),
+            _ => {}
+        }
+    }
+    (base.to_string(), f)
+}
+
+/// An inclusive byte range, as an HTTP `Range` names one (RFC 9110 §14.1.2).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ByteRange {
+    pub first: u64,
+    pub last: u64,
+}
+
+impl ByteRange {
+    /// The range [first, first + len), or `None` when `len` is 0 or the range would
+    /// pass the last byte offset a `u64` names.
+    pub fn from_len(first: u64, len: u64) -> Option<Self> {
+        let last = first.checked_add(len.checked_sub(1)?)?;
+        Some(ByteRange { first, last })
+    }
+    /// The `Range` header value, `bytes=first-last`.
+    pub fn header(&self) -> String {
+        format!("bytes={}-{}", self.first, self.last)
+    }
+    /// The number of bytes (saturating at `u64::MAX` for the whole of `u64`).
+    pub fn len(&self) -> u64 {
+        (self.last - self.first).saturating_add(1)
+    }
+    /// Never empty: a range holds at least one byte.
+    pub fn is_empty(&self) -> bool {
+        false
+    }
+    /// The end, exclusive (saturating at `u64::MAX`).
+    pub fn end(&self) -> u64 {
+        self.last.saturating_add(1)
+    }
+}
+
+/// Why a client refused bytes, or fetched a whole object instead of ranges
+/// (http-delivery §13). [`RangeRefusal::code`] is the reason.
+#[non_exhaustive]
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum RangeRefusal {
+    /// §5.1: the envelope's length is not its fields' sum.
+    ObjectLengthMismatch { expected: u64, got: u64 },
+    /// §7 step 3: the head does not parse.
+    HeadMalformed(String),
+    /// §6.3 check 1.
+    HeadProofMalformed(&'static str),
+    /// §6.3 check 2.
+    HeadProofMismatch,
+    /// §7.1: a status other than `206`, or a `200` that is not the whole object.
+    HttpStatusUnexpected(u16),
+    /// §7.1: a content coding other than none.
+    ContentCodingPresent(String),
+    /// §7.1: `Content-Range` names another range than the one requested.
+    ContentRangeMismatch { want: ByteRange, got: String },
+    /// §7.1: a complete length, or a `200` body length, other than the object's.
+    CompleteLengthMismatch { want: u64, got: u64 },
+    /// §7 step 5: a component the sink uses states no `sha256`. A reason to fetch the
+    /// whole object, never a skip.
+    ComponentDigestAbsent { index: usize },
+    /// §7 step 6: a component's bytes do not match its entry's `sha256`. A reason to
+    /// fetch the whole object, where SPEC §7.1's selection skips the entry.
+    ComponentDigestMismatch { index: usize },
+    /// §7 step 7: the whole envelope does not hash to the cid.
+    ObjectDigestMismatch,
+    /// §4: a `codecs` value, or a head against one.
+    Codecs(codecs::CodecsError),
+    /// SPEC §7.1 step 5: no entry is picked; each entry with its reason, unchanged.
+    Selection(Vec<(usize, crate::container::Skip)>),
+    /// A base-class request was never answered (§10.1: a deadline never applies to a
+    /// base).
+    BaseUnanswered,
+    /// An object listed as a layer (§10.4) is not one: not a `WAI1` that carries
+    /// `refines` or names a refinement-only capability.
+    NotALayer,
+    /// A `#WAI-LAYER` line that does not have §10.4's form.
+    LayerTagMalformed(&'static str),
+}
+
+impl RangeRefusal {
+    /// The reason code (http-delivery §13; `inert` for a selection that picks nothing,
+    /// whose per-entry reasons are SPEC §7.1's).
+    pub fn code(&self) -> &'static str {
+        match self {
+            Self::ObjectLengthMismatch { .. } => "object_length_mismatch",
+            Self::HeadMalformed(_) => "head_malformed",
+            Self::HeadProofMalformed(_) => "head_proof_malformed",
+            Self::HeadProofMismatch => "head_proof_mismatch",
+            Self::HttpStatusUnexpected(_) => "http_status_unexpected",
+            Self::ContentCodingPresent(_) => "content_coding_present",
+            Self::ContentRangeMismatch { .. } => "content_range_mismatch",
+            Self::CompleteLengthMismatch { .. } => "complete_length_mismatch",
+            Self::ComponentDigestAbsent { .. } => "component_digest_absent",
+            Self::ComponentDigestMismatch { .. } => "component_digest_mismatch",
+            Self::ObjectDigestMismatch => "object_digest_mismatch",
+            Self::Codecs(e) => e.code(),
+            Self::Selection(_) => "inert",
+            Self::BaseUnanswered => "base_unanswered",
+            Self::NotALayer => "not_a_layer",
+            Self::LayerTagMalformed(_) => "layer_tag_malformed",
+        }
+    }
+}
+
+impl std::fmt::Display for RangeRefusal {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::ObjectLengthMismatch { expected, got } => write!(f, "object_length_mismatch: the fields give {expected} bytes, the object has {got}"),
+            Self::HeadMalformed(why) => write!(f, "head_malformed: {why}"),
+            Self::HeadProofMalformed(why) => write!(f, "head_proof_malformed: {why}"),
+            Self::LayerTagMalformed(why) => write!(f, "layer_tag_malformed: {why}"),
+            Self::HttpStatusUnexpected(s) => write!(f, "http_status_unexpected: {s}"),
+            Self::ContentCodingPresent(c) => write!(f, "content_coding_present: {c}"),
+            Self::ContentRangeMismatch { want, got } => write!(f, "content_range_mismatch: asked {}, got {got:?}", want.header()),
+            Self::CompleteLengthMismatch { want, got } => write!(f, "complete_length_mismatch: {got}, the object has {want}"),
+            Self::ComponentDigestAbsent { index } => write!(f, "component_digest_absent: entry {index}"),
+            Self::ComponentDigestMismatch { index } => write!(f, "component_digest_mismatch: entry {index}"),
+            Self::Codecs(e) => e.fmt(f),
+            Self::Selection(skips) => {
+                f.write_str("inert:")?;
+                for (i, s) in skips {
+                    write!(f, " {i}={}", s.code())?;
+                }
+                Ok(())
+            }
+            other => f.write_str(other.code()),
+        }
+    }
+}
+
+impl std::error::Error for RangeRefusal {}
diff --git a/wai/wai-rs/src/http_binding/origin.rs b/wai/wai-rs/src/http_binding/origin.rs
new file mode 100644
index 000000000..a5c895dc1
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/origin.rs
@@ -0,0 +1,128 @@
+//! An origin's side of http-delivery §5.3 and §6.2: the headers it sends for an
+//! object, a head proof and a preflight, and its answer to a `Range` header (RFC 9110
+//! §14). The `wai http origin` command serves files with these.
+
+use super::{hex, MEDIA_TYPE};
+
+/// The `Cache-Control` of an immutable resource (§5.3).
+pub const IMMUTABLE: &str = "public, max-age=31536000, immutable, no-transform";
+
+/// The headers an origin sends for a `GET` or `HEAD` of an object whose content hash
+/// is `cid` (§5.3), with the object's `codecs` value when given. No
+/// `Content-Encoding`, no `Vary`.
+pub fn object_headers(cid: &[u8; 32], codecs: Option<&str>) -> Vec<(&'static str, String)> {
+    let content_type = match codecs {
+        Some(c) => format!("{MEDIA_TYPE}; codecs=\"{c}\""),
+        None => MEDIA_TYPE.to_string(),
+    };
+    vec![
+        ("Content-Type", content_type),
+        ("Cache-Control", IMMUTABLE.to_string()),
+        ("ETag", format!("\"{}\"", hex(cid))),
+        ("Accept-Ranges", "bytes".to_string()),
+        ("Access-Control-Allow-Origin", "*".to_string()),
+        ("Access-Control-Expose-Headers", "Content-Range, Content-Length, ETag".to_string()),
+        ("Timing-Allow-Origin", "*".to_string()),
+    ]
+}
+
+/// The headers for an immutable sidecar (a head proof, a receipt file, a parameter
+/// set) of the given content type (§6.2, §8.1, §8.5).
+pub fn immutable_headers(content_type: &str) -> Vec<(&'static str, String)> {
+    vec![
+        ("Content-Type", content_type.to_string()),
+        ("Cache-Control", IMMUTABLE.to_string()),
+        ("Access-Control-Allow-Origin", "*".to_string()),
+        ("Timing-Allow-Origin", "*".to_string()),
+    ]
+}
+
+/// The headers for an object listed only at a live edge, which an origin MAY serve
+/// with a smaller `max-age` (§5.3): [`object_headers`] with that `Cache-Control`.
+pub fn live_object_headers(cid: &[u8; 32], codecs: Option<&str>, max_age_s: u64) -> Vec<(&'static str, String)> {
+    object_headers(cid, codecs)
+        .into_iter()
+        .map(|(k, v)| if k == "Cache-Control" { (k, format!("public, max-age={max_age_s}, no-transform")) } else { (k, v) })
+        .collect()
+}
+
+/// The headers for a key log or module grants file (§8.4): JSON, `max-age=300`.
+pub fn key_resource_headers() -> Vec<(&'static str, String)> {
+    vec![
+        ("Content-Type", "application/json".to_string()),
+        ("Cache-Control", "max-age=300, no-transform".to_string()),
+        ("Access-Control-Allow-Origin", "*".to_string()),
+    ]
+}
+
+/// Whether a `Range` is honoured under `If-Range` (RFC 9110 §13.1.5): with no
+/// `If-Range`, yes; with one, only when it is the representation's strong `etag`
+/// exactly. A weak validator never matches, and a date is not used for an object.
+pub fn if_range_allows(if_range: Option<&str>, etag: &str) -> bool {
+    match if_range {
+        None => true,
+        Some(v) => v.trim() == etag,
+    }
+}
+
+/// The headers that answer a CORS preflight for an object (§5.3).
+pub fn preflight_headers() -> Vec<(&'static str, String)> {
+    vec![
+        ("Access-Control-Allow-Origin", "*".to_string()),
+        ("Access-Control-Allow-Methods", "GET, HEAD".to_string()),
+        ("Access-Control-Allow-Headers", "Range, Priority".to_string()),
+        ("Access-Control-Max-Age", "86400".to_string()),
+    ]
+}
+
+/// An answer to a request for a representation of `len` bytes.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Served {
+    pub status: u16,
+    /// `Content-Range`, on a `206` or a `416`.
+    pub content_range: Option<String>,
+    /// The bytes of the representation the body holds: empty on a `416`.
+    pub body: std::ops::Range<u64>,
+}
+
+/// Answer `range` (a `Range` header value, or none) on a representation of `len`
+/// bytes: `200` and the whole without one, with a multi-range request, or with one
+/// this does not read (RFC 9110 §14.2 lets a server ignore it); `206` and the bytes
+/// for one satisfiable range (a first and last position, an open end, or a suffix);
+/// `416` with `bytes */len` for an unsatisfiable one.
+pub fn serve(len: u64, range: Option<&str>) -> Served {
+    let whole = Served { status: 200, content_range: None, body: 0..len };
+    let unsatisfiable = Served { status: 416, content_range: Some(format!("bytes */{len}")), body: 0..0 };
+    let Some(spec) = range.and_then(|r| r.trim().strip_prefix("bytes=")) else { return whole };
+    if spec.contains(',') {
+        return whole;
+    }
+    let Some((a, b)) = spec.trim().split_once('-') else { return whole };
+    let (a, b) = (a.trim(), b.trim());
+    let (first, last) = match (a.is_empty(), b.is_empty()) {
+        (true, true) => return whole,
+        (true, false) => {
+            let Ok(suffix) = b.parse::<u64>() else { return whole };
+            if suffix == 0 || len == 0 {
+                return unsatisfiable;
+            }
+            (len.saturating_sub(suffix), len - 1)
+        }
+        (false, _) => {
+            let Ok(first) = a.parse::<u64>() else { return whole };
+            let last = if b.is_empty() {
+                u64::MAX
+            } else {
+                match b.parse::<u64>() {
+                    Ok(l) if l >= first => l,
+                    _ => return whole,
+                }
+            };
+            if first >= len {
+                return unsatisfiable;
+            }
+            (first, last.min(len - 1))
+        }
+    };
+    Served { status: 206, content_range: Some(format!("bytes {first}-{last}/{len}")), body: first..last + 1 }
+}
diff --git a/wai/wai-rs/src/http_binding/plan.rs b/wai/wai-rs/src/http_binding/plan.rs
new file mode 100644
index 000000000..e0d149cfc
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/plan.rs
@@ -0,0 +1,188 @@
+//! Which ranges a client requests (http-delivery §7, §10.1): the head first, then the
+//! picked component and what it applies, one request per range and priority class,
+//! or the rest of the object when ranges cannot be checked or would cost nearly as
+//! much. Deterministic, so the corpus pins its output.
+
+use super::head::Head;
+use super::{ByteRange, Fragment, MIN_RANGE_OBJECT};
+
+/// A request's priority class (§10.1): a base never waits on a refinement.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub enum Class {
+    Base,
+    Refinement,
+}
+
+impl Class {
+    /// `base` or `refinement`.
+    pub fn label(self) -> &'static str {
+        match self {
+            Class::Base => "base",
+            Class::Refinement => "refinement",
+        }
+    }
+}
+
+/// A client's reference policy: how much to request first, when ranges are not worth
+/// it, and how long it waits for a refinement. None of it is normative (§7: the 16369
+/// bytes and the 90 % are what the reference client uses).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct FetchPolicy {
+    /// The first request's length when no `h` fragment is given: sixteen chunks of
+    /// `X` less the domain prefix.
+    pub default_head: u64,
+    /// Fetch the rest instead when the planned ranges reach this share, in ‰, of the
+    /// bytes after `covered_len`.
+    pub full_threshold_permille: u16,
+    /// The deadline on a refinement request, in milliseconds from the moment the base
+    /// verified (§10.2), on the caller's clock ([`super::session::FetchSession::tick`]).
+    pub refinement_deadline_ms: Option<u32>,
+}
+
+impl Default for FetchPolicy {
+    fn default() -> Self {
+        FetchPolicy { default_head: 16 * 1024 - super::DOMAIN_LEN, full_threshold_permille: 900, refinement_deadline_ms: None }
+    }
+}
+
+/// Why a client fetched the rest of the object rather than ranges of it, or why it
+/// dropped a refinement.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum WhyWhole {
+    /// The object is below one chunk (§5.4): fetched whole from the start.
+    BelowOneChunk,
+    /// A `WAI1`: its one component is the rest of the object.
+    SingleComponent,
+    /// A layer object (§10.4): fetched whole and handed to staged delivery.
+    Layer,
+    /// §7 step 5: a component the sink uses states no `sha256`.
+    DigestAbsent { index: usize },
+    /// §7 step 6: a component did not match its `sha256`.
+    DigestMismatch { index: usize },
+    /// §7: the planned base ranges reach the policy's share of the rest.
+    Threshold,
+}
+
+impl WhyWhole {
+    /// `below_one_chunk`, `single_component`, `layer`, `component_digest_absent`,
+    /// `component_digest_mismatch` or `range_threshold`.
+    pub fn code(self) -> &'static str {
+        match self {
+            WhyWhole::BelowOneChunk => "below_one_chunk",
+            WhyWhole::SingleComponent => "single_component",
+            WhyWhole::Layer => "layer",
+            WhyWhole::DigestAbsent { .. } => "component_digest_absent",
+            WhyWhole::DigestMismatch { .. } => "component_digest_mismatch",
+            WhyWhole::Threshold => "range_threshold",
+        }
+    }
+}
+
+/// The requests for a pick: ranges by class, or the rest of the object and why; and
+/// the refinements dropped because they state no digest.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Plan {
+    pub requests: Vec<(ByteRange, Class)>,
+    pub whole_rest: Option<(ByteRange, WhyWhole)>,
+    pub dropped: Vec<(usize, WhyWhole)>,
+}
+
+/// The first request (§7 step 1): bytes [0, E), with `E` the `h` fragment or the
+/// policy's default, and never past a known `n`. `None` when `n` is below one chunk
+/// (§5.4): the client fetches the object whole.
+pub fn plan_head(policy: &FetchPolicy, frag: &Fragment) -> Option<ByteRange> {
+    if frag.n.is_some_and(|n| n < MIN_RANGE_OBJECT) {
+        return None;
+    }
+    let mut e = frag.h.filter(|&h| h > 0).unwrap_or(policy.default_head);
+    if let Some(n) = frag.n {
+        e = e.min(n);
+    }
+    ByteRange::from_len(0, e)
+}
+
+/// The rest of an object after its covered head, or `None` when the head covers it.
+pub fn rest_of(head: &Head) -> Option<ByteRange> {
+    let covered = head.covered_len();
+    ByteRange::from_len(covered, head.envelope_len - covered)
+}
+
+/// Subtract the `held` ranges from [first, end).
+fn subtract(first: u64, end: u64, held: &[ByteRange]) -> Vec<(u64, u64)> {
+    let mut out = vec![(first, end)];
+    for h in held {
+        let mut next = Vec::new();
+        for (a, b) in out {
+            let (hs, he) = (h.first, h.end());
+            if he <= a || hs >= b {
+                next.push((a, b));
+                continue;
+            }
+            if a < hs {
+                next.push((a, hs));
+            }
+            if he < b {
+                next.push((he, b));
+            }
+        }
+        out = next;
+    }
+    out
+}
+
+/// The requests for the components in `wanted` (§7 steps 5 and 6), each with its
+/// class (§10.1):
+///
+/// - a base-class component with no digest sends the base to the rest of the object
+///   (`component_digest_absent`); a refinement with no digest is dropped, alone;
+/// - otherwise each component's range less the `held` ranges, ranges that touch merged
+///   within one class only, refinements always in requests of their own;
+/// - and the rest of the object instead when the base-class ranges alone reach the
+///   policy's threshold of the bytes after `covered_len`. A refinement never moves the
+///   base to the rest: its bytes do not count.
+pub fn plan_components(
+    head: &Head,
+    wanted: &[(usize, Class)],
+    digests_present: &[bool],
+    held: &[ByteRange],
+    policy: &FetchPolicy,
+) -> Plan {
+    let mut plan = Plan { requests: Vec::new(), whole_rest: None, dropped: Vec::new() };
+    let Some(rest) = rest_of(head) else { return plan };
+    let has_digest = |i: usize| digests_present.get(i).copied().unwrap_or(false);
+    if let Some(&(index, _)) = wanted.iter().find(|&&(i, c)| c == Class::Base && !has_digest(i)) {
+        plan.whole_rest = Some((rest, WhyWhole::DigestAbsent { index }));
+        return plan;
+    }
+    let mut pieces: Vec<(Class, u64, u64)> = Vec::new();
+    for &(index, class) in wanted {
+        if !has_digest(index) {
+            plan.dropped.push((index, WhyWhole::DigestAbsent { index }));
+            continue;
+        }
+        let Some(c) = head.component(index) else { continue };
+        for (a, b) in subtract(c.start, c.start + c.len, held) {
+            pieces.push((class, a, b));
+        }
+    }
+    pieces.sort();
+    let mut merged: Vec<(Class, u64, u64)> = Vec::new();
+    for (class, a, b) in pieces {
+        match merged.last_mut() {
+            Some((c, _, e)) if *c == class && *e >= a => *e = (*e).max(b),
+            _ => merged.push((class, a, b)),
+        }
+    }
+    let base: u128 = merged.iter().filter(|(c, _, _)| *c == Class::Base).map(|(_, a, b)| u128::from(b - a)).sum();
+    if base * 1000 >= u128::from(policy.full_threshold_permille) * u128::from(rest.len()) && base > 0 {
+        plan.whole_rest = Some((rest, WhyWhole::Threshold));
+        plan.dropped.clear();
+        return plan;
+    }
+    plan.requests = merged
+        .into_iter()
+        .filter_map(|(class, a, b)| ByteRange::from_len(a, b - a).map(|r| (r, class)))
+        .collect();
+    plan.requests.sort_by_key(|(r, class)| (*class, r.first));
+    plan
+}
diff --git a/wai/wai-rs/src/http_binding/playlist.rs b/wai/wai-rs/src/http_binding/playlist.rs
new file mode 100644
index 000000000..4ffa9defb
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/playlist.rs
@@ -0,0 +1,82 @@
+//! Playlist lines this binding defines (http-delivery §10.4): the `#WAI-LAYER` tag that
+//! lists a layer object after its segment or part.
+
+use super::RangeRefusal;
+
+/// The tag's name, with its colon.
+pub const LAYER_TAG: &str = "#WAI-LAYER:";
+
+/// A `#WAI-LAYER` line: the layer a client may fetch to depth `n`, and its URI. `n` is a
+/// locator only; the envelope's `refines.layer` decides (§10.4).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct LayerTag {
+    pub n: u8,
+    pub uri: String,
+}
+
+/// Read a `#WAI-LAYER` line (§10.4). Its attributes are an HLS attribute list (RFC 8216
+/// §4.2): names of `A`–`Z`, `0`–`9` and `-`; values a decimal integer, a quoted string
+/// with no `"`, CR or LF, or an enumerated string. `N` (1 to 255) and `URI` (a quoted
+/// string) are required, no attribute is named twice, and an attribute this revision
+/// does not define is ignored. Anything else is `layer_tag_malformed`.
+pub fn parse_layer_tag(line: &str) -> Result<LayerTag, RangeRefusal> {
+    let bad = RangeRefusal::LayerTagMalformed;
+    let mut rest = line.strip_prefix(LAYER_TAG).ok_or(bad("not a #WAI-LAYER line"))?.as_bytes();
+    let (mut n, mut uri): (Option<u8>, Option<String>) = (None, None);
+    let mut names: Vec<Vec<u8>> = Vec::new();
+    loop {
+        let eq = rest.iter().position(|&b| b == b'=').ok_or(bad("an attribute without ="))?;
+        let name = &rest[..eq];
+        if name.is_empty() || !name.iter().all(|b| b.is_ascii_uppercase() || b.is_ascii_digit() || *b == b'-') {
+            return Err(bad("an attribute name"));
+        }
+        if names.iter().any(|x| x == name) {
+            return Err(bad("an attribute named twice"));
+        }
+        names.push(name.to_vec());
+        rest = &rest[eq + 1..];
+        let (value, quoted, after) = if rest.first() == Some(&b'"') {
+            let close = rest[1..].iter().position(|&b| b == b'"').ok_or(bad("an unterminated quoted string"))? + 1;
+            let v = &rest[1..close];
+            if v.iter().any(|&b| b == b'\r' || b == b'\n') {
+                return Err(bad("CR or LF in a quoted string"));
+            }
+            (v, true, &rest[close + 1..])
+        } else {
+            let end = rest.iter().position(|&b| b == b',').unwrap_or(rest.len());
+            let v = &rest[..end];
+            if v.is_empty() || v.iter().any(|&b| b == b'"' || b.is_ascii_whitespace()) {
+                return Err(bad("an unquoted value"));
+            }
+            (v, false, &rest[end..])
+        };
+        match name {
+            b"N" => {
+                if quoted || value.len() > 3 || !value.iter().all(u8::is_ascii_digit) {
+                    return Err(bad("N is not a decimal integer"));
+                }
+                let v: u16 = std::str::from_utf8(value).ok().and_then(|s| s.parse().ok()).ok_or(bad("N"))?;
+                if !(1..=255).contains(&v) {
+                    return Err(bad("N is not 1 to 255"));
+                }
+                n = Some(v as u8);
+            }
+            b"URI" => {
+                if !quoted {
+                    return Err(bad("URI is not a quoted string"));
+                }
+                uri = Some(std::str::from_utf8(value).map_err(|_| bad("URI is not UTF-8"))?.to_string());
+            }
+            _ => {}
+        }
+        match after.first() {
+            None => break,
+            Some(b',') => rest = &after[1..],
+            Some(_) => return Err(bad("text after a value")),
+        }
+    }
+    match (n, uri) {
+        (Some(n), Some(uri)) => Ok(LayerTag { n, uri }),
+        _ => Err(bad("N and URI are required")),
+    }
+}
diff --git a/wai/wai-rs/src/http_binding/session.rs b/wai/wai-rs/src/http_binding/session.rs
new file mode 100644
index 000000000..ec31518e0
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/session.rs
@@ -0,0 +1,913 @@
+//! A sans-IO driver of http-delivery §7: it says which requests to make, checks each
+//! response (§7.1), verifies the head against the cid (§6) and each component against
+//! its entry's digest, selects from the head as SPEC §7.1 does, and falls back to the
+//! whole object, selecting again on it, exactly where §7 says to. A refinement never
+//! changes its base's path (§10): its bytes do not count toward the threshold, its
+//! requests are its own, and a refinement that states no digest, fails its digest or
+//! has a response refused is dropped or abandoned alone. A layer object (§10.4) is
+//! fetched whole at refinement class and delivered for staged delivery, never
+//! dispatched. The caller moves the bytes; nothing here performs I/O or reads a clock.
+
+use std::collections::BTreeMap;
+
+use super::codecs::{check_declared, Element};
+use super::head::{parse_head, Head, HeadParse, Version};
+use super::head_proof::HeadProof;
+use super::plan::{plan_components, plan_head, rest_of, Class, FetchPolicy, Plan, WhyWhole};
+use super::{ByteRange, Fragment, RangeRefusal};
+use crate::container::{
+    companion_indices, refinement_indices, select_entries, ManifestV2, PinRefusal, Prior, RenditionMeta, Skip, Wai,
+    WaiMulti,
+};
+
+/// What a response's headers say, as a client reads them.
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ResponseMeta {
+    pub status: u16,
+    pub content_range: Option<String>,
+    pub content_encoding: Option<String>,
+}
+
+/// One request a session wants made.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Want {
+    /// `GET` the object with `Range: <range>`, at the class's priority.
+    Range(ByteRange, Class),
+    /// `GET <cid>.wai.hp`, at base priority.
+    HeadProof,
+    /// `GET` the object with no `Range`: an object below one chunk, or a layer.
+    Whole(Class),
+    /// `GET` the object with `Range: bytes=<first>-`, the rest after the covered head
+    /// (§7 step 7). Its last position is the object's.
+    Rest(ByteRange, Class),
+}
+
+impl Want {
+    /// The request's priority class (§10.1).
+    pub fn class(&self) -> Class {
+        match self {
+            Want::Range(_, c) | Want::Whole(c) | Want::Rest(_, c) => *c,
+            Want::HeadProof => Class::Base,
+        }
+    }
+}
+
+/// How the bytes a session returns were verified.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum VerifiedBy {
+    /// The head by its proof (§6), each component by its entry's `sha256`.
+    HeadProof,
+    /// The whole envelope against the cid.
+    WholeObject,
+}
+
+impl VerifiedBy {
+    /// `head-proof` or `whole-object`.
+    pub fn label(self) -> &'static str {
+        match self {
+            VerifiedBy::HeadProof => "head-proof",
+            VerifiedBy::WholeObject => "whole-object",
+        }
+    }
+}
+
+/// What a session delivered.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Role {
+    /// A component picked by SPEC §4 or §7.1, for the sink to present.
+    Base,
+    /// A layer object (§10.4), for staged delivery §4 (its `envelope`).
+    Layer,
+}
+
+impl Role {
+    /// `base` or `layer`.
+    pub fn label(self) -> &'static str {
+        match self {
+            Role::Base => "base",
+            Role::Layer => "layer",
+        }
+    }
+}
+
+/// What a session delivers: the picked component, the companions and refinements
+/// it applies, verified, and how it got them.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Fetched {
+    pub role: Role,
+    pub index: usize,
+    pub component: Vec<u8>,
+    pub companions: Vec<(usize, Vec<u8>)>,
+    pub refinements: Vec<(usize, Vec<u8>)>,
+    /// Refinements whose request the client abandoned: at its deadline (§10.2), or
+    /// because its response was refused (§7.1). For a layer, `[0]` when the layer was.
+    pub abandoned: Vec<usize>,
+    /// Refinements not applied because they state no digest or fail theirs, with
+    /// why; their base is unaffected.
+    pub dropped: Vec<(usize, WhyWhole)>,
+    /// The entries selection skipped before the pick, with their reasons.
+    pub skipped: Vec<(usize, Skip)>,
+    pub head: Head,
+    pub verified_by: VerifiedBy,
+    pub why_whole: Option<WhyWhole>,
+    /// The whole envelope, when it was fetched and verified against the cid.
+    pub envelope: Option<Vec<u8>>,
+    /// Response body bytes received, the head proof's included.
+    pub body_bytes: u64,
+    pub requests: u32,
+}
+
+/// The sink's side of selection: what it advertises, how it checks a pin, which
+/// companions and refinements it applies, a deployer policy's order, and the union
+/// the variant declared.
+pub struct Selector {
+    pub advertises: Box<dyn Fn(&str) -> bool>,
+    pub verify_pin: Box<dyn FnMut(&str, &Prior) -> Result<(), PinRefusal>>,
+    /// Whether the sink applies a companion or refinement entry.
+    pub applies: Box<dyn Fn(&RenditionMeta) -> bool>,
+    /// The order in which entries are considered (SPEC §7.1 step 2); `None` is table
+    /// order.
+    pub order: Option<Box<dyn Fn(&ManifestV2) -> Vec<usize>>>,
+    /// The variant's union (§4.2), when the client holds one.
+    pub declared: Option<Element>,
+    /// For a layer, the object its playlist lists it under: the base a declared layer is
+    /// checked against (§4.2).
+    pub layer_base: Option<super::codecs::SeqObject>,
+}
+
+impl Selector {
+    /// A sink that advertises what `advertises` accepts, holds no parameter set,
+    /// applies every companion and refinement, and keeps table order.
+    pub fn new(advertises: impl Fn(&str) -> bool + 'static) -> Self {
+        Selector {
+            advertises: Box::new(advertises),
+            verify_pin: Box::new(|cap, _| Err(PinRefusal::NotHeld { capability: cap.to_string() })),
+            applies: Box::new(|_| true),
+            order: None,
+            declared: None,
+            layer_base: None,
+        }
+    }
+
+    fn order_of(&self, m: &ManifestV2) -> Vec<usize> {
+        match &self.order {
+            Some(f) => f(m),
+            None => (0..m.renditions.len()).collect(),
+        }
+    }
+
+    /// SPEC §7.1 over `m`, with the digest test `digest_ok`.
+    fn select(&mut self, m: &ManifestV2, digest_ok: impl Fn(usize, &RenditionMeta) -> bool)
+        -> Result<(usize, Vec<(usize, Skip)>), Vec<(usize, Skip)>> {
+        let order = self.order_of(m);
+        let advertises = &self.advertises;
+        let verify = &mut self.verify_pin;
+        let eligible = |_: usize, e: &RenditionMeta| if advertises(&e.capability) { Ok(()) } else { Err(Skip::NotEligible) };
+        select_entries(m, &order, eligible, digest_ok, |c: &str, p: &Prior| verify(c, p)).map(|(i, _, s)| (i, s))
+    }
+
+    /// SPEC §4 for a `WAI1` from its manifest alone (§7: decided before the payload is
+    /// fetched): `Ok` when the sink dispatches it, its reason otherwise.
+    fn dispatch_wai1(&mut self, w: &Wai) -> Result<(), RangeRefusal> {
+        let advertises = &self.advertises;
+        let verify = &mut self.verify_pin;
+        w.dispatch_verified(|c| advertises(c), |c, p| verify(c, p)).map(|_| ()).map_err(|inert| {
+            let skip = match inert {
+                crate::container::Inert::PinRefused { refusal, .. } => Skip::Pin(refusal),
+                crate::container::Inert::Encrypted { .. } => Skip::Encrypted,
+                _ => Skip::NotEligible,
+            };
+            RangeRefusal::Selection(vec![(0, skip)])
+        })
+    }
+
+    /// The companions and refinements of entry `index` the sink applies, with their
+    /// classes: an enhancement layer or a refinement is a refinement (§10.1).
+    fn applied(&self, m: &ManifestV2, index: usize) -> Vec<(usize, Class)> {
+        let e = &m.renditions;
+        let mut out: Vec<(usize, Class)> = companion_indices(e, index)
+            .into_iter()
+            .filter(|&i| (self.applies)(&e[i]))
+            .map(|i| (i, if crate::codecs::is_enhancement_layer(&e[i].capability) { Class::Refinement } else { Class::Base }))
+            .collect();
+        out.extend(refinement_indices(e, index).into_iter().filter(|&i| (self.applies)(&e[i])).map(|i| (i, Class::Refinement)));
+        out
+    }
+}
+
+/// Whether `s` is one or more ASCII digits: the `1*DIGIT` of RFC 9110 §14.4. No sign,
+/// separator, space or other script's digit.
+fn digits(s: &str) -> Option<u64> {
+    if s.is_empty() || !s.bytes().all(|b| b.is_ascii_digit()) {
+        return None;
+    }
+    s.parse().ok()
+}
+
+/// §7.1: check one response to a request for `req` (`None`: no `Range` was sent)
+/// on an object of `envelope_len` bytes. Returns the bytes the body holds.
+pub fn check_response(req: Option<ByteRange>, r: &ResponseMeta, body_len: u64, envelope_len: u64)
+    -> Result<ByteRange, RangeRefusal> {
+    let coded = |r: &ResponseMeta| r.content_encoding.as_deref()
+        .map(str::trim)
+        .filter(|c| !c.is_empty() && !c.eq_ignore_ascii_case("identity"))
+        .map(str::to_string);
+    match r.status {
+        206 => {
+            let Some(want) = req else { return Err(RangeRefusal::HttpStatusUnexpected(206)) };
+            if let Some(c) = coded(r) {
+                return Err(RangeRefusal::ContentCodingPresent(c));
+            }
+            let got = r.content_range.clone().unwrap_or_default();
+            let mismatch = || RangeRefusal::ContentRangeMismatch { want, got: got.clone() };
+            let field = got.trim_matches(|c| c == ' ' || c == '\t');
+            let (span, complete) = field.strip_prefix("bytes ").and_then(|s| s.split_once('/')).ok_or_else(mismatch)?;
+            let (a, b) = span.split_once('-').ok_or_else(mismatch)?;
+            let (a, b) = (digits(a).ok_or_else(mismatch)?, digits(b).ok_or_else(mismatch)?);
+            let expect_last = want.last.min(envelope_len.saturating_sub(1));
+            if a != want.first || b != expect_last || b < a || (b - a).checked_add(1) != Some(body_len) {
+                return Err(mismatch());
+            }
+            match digits(complete) {
+                Some(n) if n == envelope_len => Ok(ByteRange { first: a, last: b }),
+                Some(n) => Err(RangeRefusal::CompleteLengthMismatch { want: envelope_len, got: n }),
+                None => Err(RangeRefusal::CompleteLengthMismatch { want: envelope_len, got: 0 }),
+            }
+        }
+        200 => {
+            if let Some(c) = coded(r) {
+                return Err(RangeRefusal::ContentCodingPresent(c));
+            }
+            if body_len != envelope_len {
+                return Err(RangeRefusal::CompleteLengthMismatch { want: envelope_len, got: body_len });
+            }
+            ByteRange::from_len(0, envelope_len).ok_or(RangeRefusal::CompleteLengthMismatch { want: envelope_len, got: body_len })
+        }
+        s => Err(RangeRefusal::HttpStatusUnexpected(s)),
+    }
+}
+
+/// Whether `bytes` match entry `index`'s `sha256` in `m`; false when it states none.
+fn check_component(m: &ManifestV2, index: usize, bytes: &[u8]) -> bool {
+    m.renditions.get(index).is_some_and(|e| e.sha256.is_some() && e.payload_digest_matches(bytes))
+}
+
+enum Stage {
+    /// Waiting for the head and its proof.
+    Head,
+    /// Fetching the planned component ranges.
+    Components { index: usize, skipped: Vec<(usize, Skip)>, wanted: Vec<(usize, Class)> },
+    /// Fetching the rest of the object, at `class` (a layer's at refinement class).
+    Rest { why: WhyWhole, class: Class },
+    /// Fetching an object listed as a layer, whole (§10.4).
+    Layer,
+    /// Finished, delivered or refused.
+    Done,
+}
+
+/// A fetch of one object by the procedure of http-delivery §7.
+pub struct FetchSession {
+    cid: [u8; 32],
+    frag: Fragment,
+    policy: FetchPolicy,
+    sel: Selector,
+    next_id: u32,
+    queued: Vec<(u32, Want)>,
+    issued: BTreeMap<u32, Want>,
+    early: Vec<(Want, ResponseMeta, Vec<u8>)>,
+    proof: Option<HeadProof>,
+    held: Vec<(ByteRange, Vec<u8>)>,
+    head: Option<Head>,
+    manifest: Option<ManifestV2>,
+    stage: Stage,
+    abandoned: Vec<usize>,
+    dropped: Vec<(usize, WhyWhole)>,
+    body_bytes: u64,
+    requests: u32,
+    result: Option<Result<Fetched, RangeRefusal>>,
+    /// The caller's clock, in milliseconds, as last given with a response
+    /// ([`FetchSession::on_response`]) or to [`FetchSession::tick`].
+    now_ms: u64,
+    /// The base, once it verified, with the clock of the response that verified it.
+    base: Option<(Fetched, u64)>,
+    /// Each component that has verified against its digest, by index: frozen, never
+    /// read again from the held bytes, so no later response changes it (§10.1).
+    verified: BTreeMap<usize, Vec<u8>>,
+}
+
+impl FetchSession {
+    fn empty(cid: [u8; 32], frag: Fragment, policy: FetchPolicy, sel: Selector, stage: Stage) -> Self {
+        FetchSession {
+            cid, frag, policy, sel,
+            next_id: 0,
+            queued: Vec::new(),
+            issued: BTreeMap::new(),
+            early: Vec::new(),
+            proof: None,
+            held: Vec::new(),
+            head: None,
+            manifest: None,
+            stage,
+            abandoned: Vec::new(),
+            dropped: Vec::new(),
+            body_bytes: 0,
+            requests: 0,
+            result: None,
+            now_ms: 0,
+            base: None,
+            verified: BTreeMap::new(),
+        }
+    }
+
+    /// A session for the object `cid`, with the hints of its URI's fragment.
+    pub fn new(cid: [u8; 32], frag: Fragment, policy: FetchPolicy, sel: Selector) -> Self {
+        let mut s = Self::empty(cid, frag, policy, sel, Stage::Head);
+        match plan_head(&s.policy, &s.frag) {
+            Some(r) => {
+                s.queue(Want::Range(r, Class::Base));
+                s.queue(Want::HeadProof);
+            }
+            None => {
+                s.stage = Stage::Rest { why: WhyWhole::BelowOneChunk, class: Class::Base };
+                s.queue(Want::Whole(Class::Base));
+            }
+        }
+        s
+    }
+
+    /// A session for an object a playlist lists as a layer (§10.4): one request for
+    /// the whole object, at refinement class, verified against `cid` and delivered for
+    /// staged delivery. An object that is not a layer is refused (`not_a_layer`); a
+    /// response refused by §7.1, or abandoned at its deadline, leaves the layer
+    /// abandoned.
+    pub fn new_layer(cid: [u8; 32], frag: Fragment, policy: FetchPolicy, sel: Selector) -> Self {
+        let mut s = Self::empty(cid, frag, policy, sel, Stage::Layer);
+        s.queue(Want::Whole(Class::Refinement));
+        s
+    }
+
+    fn queue(&mut self, w: Want) {
+        let id = self.next_id;
+        self.next_id += 1;
+        self.queued.push((id, w));
+    }
+
+    /// The requests to make now, each with its id; each is returned once.
+    pub fn wants(&mut self) -> Vec<(u32, Want)> {
+        let out = std::mem::take(&mut self.queued);
+        for (id, w) in &out {
+            self.issued.insert(*id, w.clone());
+            self.requests += 1;
+        }
+        out
+    }
+
+    /// The outcome, once there is one: the delivery, or the refusal that ended it.
+    pub fn result(&self) -> Option<&Result<Fetched, RangeRefusal>> {
+        self.result.as_ref()
+    }
+
+    /// The delivery, once the session has one: the base and every refinement, applied,
+    /// abandoned or dropped.
+    pub fn done(&self) -> Option<&Fetched> {
+        self.result.as_ref().and_then(|r| r.as_ref().ok())
+    }
+
+    /// The base, as soon as it verified (§10.1): the picked component and the companions
+    /// that are not refinements, before any refinement has arrived or been abandoned. Its
+    /// `refinements` are empty; [`Self::done`] adds them. A layer, and an object fetched
+    /// whole, are ready when they are done.
+    pub fn base_ready(&self) -> Option<&Fetched> {
+        self.base.as_ref().map(|(f, _)| f).or_else(|| self.done())
+    }
+
+    /// The caller's clock when the base verified: the `now_ms` given with the response
+    /// that completed it ([`Self::on_response`]).
+    pub fn base_ready_at(&self) -> Option<u64> {
+        self.base.as_ref().map(|(_, t)| *t)
+    }
+
+    /// Tell the session the time on the caller's clock, in milliseconds. Once the base has
+    /// verified, the policy's `refinement_deadline_ms` runs from the time it did (§10.2):
+    /// when it has passed, every outstanding refinement request is abandoned, and their
+    /// ids are returned so the caller can cancel them. The session reads no clock of its
+    /// own; every response carries the caller's time, so a tick before the base verified
+    /// never moves the deadline's start. The arithmetic saturates: a clock that steps back
+    /// leaves the deadline not passed until the clock again reaches it, and a start near
+    /// the end of `u64` gives a deadline at `u64::MAX`.
+    pub fn tick(&mut self, now_ms: u64) -> Vec<u32> {
+        self.now_ms = now_ms;
+        let (Some(at), Some(d)) = (self.base_ready_at(), self.policy.refinement_deadline_ms) else { return Vec::new() };
+        if self.result.is_some() || now_ms < at.saturating_add(u64::from(d)) {
+            return Vec::new();
+        }
+        let ids = self.outstanding_of(Class::Refinement);
+        for &id in &ids {
+            self.on_deadline(id);
+        }
+        ids
+    }
+
+    /// Whether requests are still outstanding.
+    pub fn outstanding(&self) -> usize {
+        self.issued.len()
+    }
+
+    /// The ids of the outstanding requests of `class`.
+    pub fn outstanding_of(&self, class: Class) -> Vec<u32> {
+        self.issued.iter().filter(|(_, w)| w.class() == class).map(|(id, _)| *id).collect()
+    }
+
+    /// The request `id` will not be answered in time: a refinement's is abandoned
+    /// (§10.2), and the session finishes without it once the base is verified. A base
+    /// request is not abandoned: a deadline never applies to one.
+    pub fn on_deadline(&mut self, id: u32) {
+        if self.result.is_some() {
+            return;
+        }
+        if let Some(w) = self.issued.get(&id).cloned() {
+            if w.class() == Class::Refinement {
+                self.issued.remove(&id);
+                self.abandon(&w);
+                self.advance();
+            }
+        }
+    }
+
+    /// Record the refinements request `w` covered as abandoned.
+    fn abandon(&mut self, w: &Want) {
+        match (&self.stage, w) {
+            (Stage::Layer, _) | (Stage::Rest { class: Class::Refinement, .. }, _) => {
+                if !self.abandoned.contains(&0) {
+                    self.abandoned.push(0);
+                }
+            }
+            (Stage::Components { wanted, .. }, Want::Range(r, Class::Refinement)) => {
+                let Some(head) = &self.head else { return };
+                for &(i, class) in wanted {
+                    let c = head.components[i];
+                    if class == Class::Refinement && c.start < r.end() && r.first < c.start + c.len && !self.abandoned.contains(&i) {
+                        self.abandoned.push(i);
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    /// A response to request `id`, received at `now_ms` on the caller's clock (the time
+    /// the base is stamped with when this response completes it, §10.2). A refusal of a
+    /// base-class response ends the session (§7.1: the bytes are discarded) and is
+    /// returned; a refused refinement-class response is discarded and its refinement
+    /// abandoned (§10.2, §10.3). Of a refinement-class response, only the bytes of the
+    /// range requested are kept, whatever else a `200` carries: no refinement's response
+    /// touches its base's bytes.
+    pub fn on_response(&mut self, id: u32, meta: &ResponseMeta, body: &[u8], now_ms: u64) -> Result<(), RangeRefusal> {
+        self.now_ms = now_ms;
+        if let Some(Err(e)) = &self.result {
+            return Err(e.clone());
+        }
+        let Some(want) = self.issued.remove(&id) else { return Ok(()) };
+        if self.result.is_some() {
+            return Ok(());
+        }
+        self.body_bytes += body.len() as u64;
+        let r = self.take(want, meta, body).map(|()| self.advance());
+        if let Err(e) = &r {
+            self.finish(Err(e.clone()));
+        }
+        r
+    }
+
+    fn finish(&mut self, r: Result<Fetched, RangeRefusal>) {
+        self.stage = Stage::Done;
+        self.queued.clear();
+        self.result = Some(r);
+    }
+
+    fn envelope_len(&self) -> Option<u64> {
+        self.proof.as_ref().map(|p| p.envelope_len)
+    }
+
+    fn take(&mut self, want: Want, meta: &ResponseMeta, body: &[u8]) -> Result<(), RangeRefusal> {
+        match want.clone() {
+            Want::HeadProof => {
+                if meta.status != 200 {
+                    return Err(RangeRefusal::HttpStatusUnexpected(meta.status));
+                }
+                if let Some(c) = meta.content_encoding.as_deref().filter(|c| !c.trim().is_empty() && !c.trim().eq_ignore_ascii_case("identity")) {
+                    return Err(RangeRefusal::ContentCodingPresent(c.to_string()));
+                }
+                let p = HeadProof::from_bytes(body)?;
+                if p.cid != self.cid {
+                    return Err(RangeRefusal::HeadProofMalformed("the proof names another object"));
+                }
+                self.proof = Some(p);
+                for (w, m, b) in std::mem::take(&mut self.early) {
+                    self.take(w, &m, &b)?;
+                }
+                Ok(())
+            }
+            Want::Whole(class) => {
+                let n = body.len() as u64;
+                match check_response(None, meta, n, n) {
+                    Ok(_) => {}
+                    Err(_) if class == Class::Refinement => {
+                        self.abandon(&want);
+                        return Ok(());
+                    }
+                    Err(e) => return Err(e),
+                }
+                if super::content_hash(body) != self.cid {
+                    return Err(RangeRefusal::ObjectDigestMismatch);
+                }
+                if let Some(r) = ByteRange::from_len(0, n) {
+                    self.held.push((r, body.to_vec()));
+                }
+                Ok(())
+            }
+            Want::Range(r, class) | Want::Rest(r, class) => {
+                let Some(len) = self.envelope_len() else {
+                    // Checked once the proof gives the object's length (§6.3 check 1).
+                    self.early.push((want, meta.clone(), body.to_vec()));
+                    return Ok(());
+                };
+                match check_response(Some(r), meta, body.len() as u64, len) {
+                    Ok(got) if class == Class::Refinement => {
+                        // A refinement's response adds the bytes it was asked for and no
+                        // others: a `200` carrying the whole object is cut to the range.
+                        let (first, end) = (got.first.max(r.first), got.end().min(r.end()));
+                        if let Some(keep) = ByteRange::from_len(first, end.saturating_sub(first)) {
+                            let at = (first - got.first) as usize;
+                            self.held.push((keep, body[at..at + (end - first) as usize].to_vec()));
+                        }
+                        Ok(())
+                    }
+                    Ok(got) => {
+                        self.held.push((got, body.to_vec()));
+                        Ok(())
+                    }
+                    Err(_) if class == Class::Refinement => {
+                        self.abandon(&want);
+                        Ok(())
+                    }
+                    Err(e) => Err(e),
+                }
+            }
+        }
+    }
+
+    /// The bytes [first, end) if they are held contiguously.
+    fn bytes(&self, first: u64, end: u64) -> Option<Vec<u8>> {
+        let mut out = Vec::with_capacity(usize::try_from(end.checked_sub(first)?).ok()?);
+        let mut at = first;
+        while at < end {
+            let (r, b) = self.held.iter().filter(|(r, _)| r.first <= at && at < r.end()).max_by_key(|(r, _)| r.end())?;
+            let take_to = r.end().min(end);
+            out.extend_from_slice(&b[(at - r.first) as usize..(take_to - r.first) as usize]);
+            at = take_to;
+        }
+        Some(out)
+    }
+
+    /// Drop every byte held at or after `from` (§7 step 6: after a mismatch nothing
+    /// fetched past the covered head is reused).
+    fn drop_from(&mut self, from: u64) {
+        let mut kept = Vec::new();
+        for (r, b) in std::mem::take(&mut self.held) {
+            if r.first >= from {
+                continue;
+            }
+            if r.last >= from {
+                let keep = (from - r.first) as usize;
+                kept.push((ByteRange { first: r.first, last: from - 1 }, b[..keep].to_vec()));
+            } else {
+                kept.push((r, b));
+            }
+        }
+        self.held = kept;
+    }
+
+    /// The length of the prefix held contiguously from offset 0.
+    fn prefix_len(&self) -> u64 {
+        let mut at = 0;
+        loop {
+            match self.held.iter().filter(|(r, _)| r.first <= at && at < r.end()).map(|(r, _)| r.end()).max() {
+                Some(e) => at = e,
+                None => return at,
+            }
+        }
+    }
+
+    fn base_range_outstanding(&self) -> bool {
+        self.issued.values().chain(self.queued.iter().map(|(_, w)| w))
+            .any(|w| matches!(w, Want::Range(_, Class::Base) | Want::Rest(_, Class::Base)))
+    }
+
+    fn advance(&mut self) {
+        if self.result.is_some() {
+            return;
+        }
+        let r = match self.stage {
+            Stage::Head => self.advance_head(),
+            Stage::Components { .. } => self.advance_components(),
+            Stage::Rest { .. } | Stage::Layer => self.advance_rest(),
+            Stage::Done => Ok(()),
+        };
+        if let Err(e) = r {
+            self.finish(Err(e));
+        }
+    }
+
+    fn advance_head(&mut self) -> Result<(), RangeRefusal> {
+        let Some(proof) = self.proof.clone() else { return Ok(()) };
+        let have = self.prefix_len();
+        if have < proof.covered_len {
+            if !self.base_range_outstanding() {
+                if let Some(r) = ByteRange::from_len(have, proof.covered_len - have) {
+                    self.queue(Want::Range(r, Class::Base));
+                }
+            }
+            return Ok(());
+        }
+        let prefix = self.bytes(0, proof.covered_len).ok_or(RangeRefusal::HeadProofMalformed("covered_len is not addressable"))?;
+        proof.verify(&self.cid, &prefix)?;
+        let head = match parse_head(&prefix, proof.envelope_len)? {
+            HeadParse::Head(h) => h,
+            HeadParse::Need(_) => return Err(RangeRefusal::HeadMalformed("the covered bytes do not hold the head".into())),
+        };
+        if let Some(union) = &self.sel.declared {
+            check_declared(&head, union, self.sel.layer_base.as_ref()).map_err(RangeRefusal::Codecs)?;
+        }
+        self.head = Some(head.clone());
+        match head.version {
+            Version::Wai1 if head.is_layer() => {
+                // A layer goes to staged delivery, never to SPEC §4 (§10.4): the rest of
+                // it at refinement class, then the whole envelope against the cid.
+                self.to_rest(&head, WhyWhole::Layer, Class::Refinement);
+            }
+            Version::Wai1 => {
+                // Selection reads the manifest alone: decide before fetching the payload.
+                let w = Wai::new(head.manifest_v1()?, Vec::new());
+                self.sel.dispatch_wai1(&w)?;
+                self.to_rest(&head, WhyWhole::SingleComponent, Class::Base);
+            }
+            Version::Wai2 => {
+                let m = head.manifest_v2()?;
+                let (index, skipped) = self.sel.select(&m, |_, _| true).map_err(RangeRefusal::Selection)?;
+                let mut wanted = vec![(index, Class::Base)];
+                wanted.extend(self.sel.applied(&m, index));
+                let present: Vec<bool> = m.renditions.iter().map(|e| e.sha256.is_some()).collect();
+                let held: Vec<ByteRange> = self.held.iter().map(|(r, _)| *r).collect();
+                let plan: Plan = plan_components(&head, &wanted, &present, &held, &self.policy);
+                self.manifest = Some(m);
+                match plan.whole_rest {
+                    Some((_, why)) => self.to_rest(&head, why, Class::Base),
+                    None => {
+                        for (r, class) in plan.requests {
+                            self.queue(Want::Range(r, class));
+                        }
+                        let dropped: Vec<usize> = plan.dropped.iter().map(|(i, _)| *i).collect();
+                        self.dropped = plan.dropped;
+                        wanted.retain(|(i, _)| !dropped.contains(i));
+                        self.stage = Stage::Components { index, skipped, wanted };
+                    }
+                }
+            }
+        }
+        match self.stage {
+            Stage::Components { .. } => self.advance_components(),
+            Stage::Rest { .. } => self.advance_rest(),
+            _ => Ok(()),
+        }
+    }
+
+    /// Go to §7 step 7 at `class`: request the rest after the covered head unless it is
+    /// held.
+    fn to_rest(&mut self, head: &Head, why: WhyWhole, class: Class) {
+        self.stage = Stage::Rest { why, class };
+        if let Some(r) = rest_of(head) {
+            if self.bytes(r.first, r.end()).is_none() {
+                self.queue(Want::Rest(r, class));
+            }
+        }
+    }
+
+    fn advance_components(&mut self) -> Result<(), RangeRefusal> {
+        let (Stage::Components { index, skipped, wanted }, Some(head), Some(m)) = (&self.stage, &self.head, &self.manifest) else {
+            return Ok(());
+        };
+        let (index, skipped, wanted, head, m) = (*index, skipped.clone(), wanted.clone(), head.clone(), m.clone());
+        let mut parts: BTreeMap<usize, Vec<u8>> = BTreeMap::new();
+        let (mut pending, mut base_pending) = (false, false);
+        for &(i, class) in &wanted {
+            if self.abandoned.contains(&i) || self.dropped.iter().any(|(d, _)| *d == i) {
+                continue;
+            }
+            if let Some(b) = self.verified.get(&i) {
+                // Verified once; never read again (§10.1).
+                parts.insert(i, b.clone());
+                continue;
+            }
+            let c = head.components[i];
+            match self.bytes(c.start, c.start + c.len) {
+                Some(b) if check_component(&m, i, &b) => {
+                    self.verified.insert(i, b.clone());
+                    parts.insert(i, b);
+                }
+                Some(_) if class == Class::Refinement => {
+                    // A refinement that fails its digest is dropped alone; its base's path
+                    // does not change.
+                    self.dropped.push((i, WhyWhole::DigestMismatch { index: i }));
+                }
+                Some(_) => {
+                    // §7 step 6: discard every byte past the covered head, and decide on the
+                    // whole envelope.
+                    self.issued.clear();
+                    self.queued.clear();
+                    self.abandoned.clear();
+                    self.dropped.clear();
+                    self.verified.clear();
+                    self.drop_from(head.covered_len());
+                    self.to_rest(&head, WhyWhole::DigestMismatch { index: i }, Class::Base);
+                    return self.advance_rest();
+                }
+                None => {
+                    pending = true;
+                    base_pending |= class == Class::Base;
+                }
+            }
+        }
+        let classes: BTreeMap<usize, Class> = wanted.iter().copied().collect();
+        let assemble = |parts: &BTreeMap<usize, Vec<u8>>, only_base: bool, s: &Self| -> Fetched {
+            let (mut companions, mut refinements) = (Vec::new(), Vec::new());
+            for &(i, _) in &wanted[1..] {
+                if only_base && classes[&i] == Class::Refinement {
+                    continue;
+                }
+                if let Some(b) = parts.get(&i) {
+                    if m.renditions[i].is_companion() {
+                        companions.push((i, b.clone()));
+                    } else {
+                        refinements.push((i, b.clone()));
+                    }
+                }
+            }
+            Fetched {
+                role: Role::Base,
+                index, component: parts[&index].clone(), companions, refinements,
+                abandoned: s.abandoned.clone(),
+                dropped: s.dropped.clone(),
+                skipped: skipped.clone(), head: head.clone(),
+                verified_by: VerifiedBy::HeadProof,
+                why_whole: None,
+                envelope: None,
+                body_bytes: s.body_bytes,
+                requests: s.requests,
+            }
+        };
+        if !base_pending && self.base.is_none() {
+            // §10.1: the base is presentable now, whatever its refinements do.
+            self.base = Some((assemble(&parts, true, self), self.now_ms));
+        }
+        if pending {
+            return Ok(());
+        }
+        let fetched = assemble(&parts, false, self);
+        self.finish(Ok(fetched));
+        Ok(())
+    }
+
+    /// The layer's result once its request is abandoned.
+    fn layer_abandoned(&self) -> Option<Fetched> {
+        let head = self.head.clone().unwrap_or(Head {
+            version: Version::Wai1, head_len: 0, envelope_len: 0, manifest: 0..0, components: Vec::new(), bytes: Vec::new(),
+        });
+        Some(Fetched {
+            role: Role::Layer, index: 0, component: Vec::new(), companions: Vec::new(), refinements: Vec::new(),
+            abandoned: vec![0], dropped: Vec::new(), skipped: Vec::new(), head,
+            verified_by: VerifiedBy::WholeObject, why_whole: Some(WhyWhole::Layer), envelope: None,
+            body_bytes: self.body_bytes, requests: self.requests,
+        })
+    }
+
+    fn advance_rest(&mut self) -> Result<(), RangeRefusal> {
+        let (why, layer_listed) = match self.stage {
+            Stage::Rest { why, .. } => (why, false),
+            Stage::Layer => (WhyWhole::Layer, true),
+            _ => return Ok(()),
+        };
+        if self.abandoned.contains(&0) && (layer_listed || why == WhyWhole::Layer) {
+            let f = self.layer_abandoned().expect("a result");
+            self.finish(Ok(f));
+            return Ok(());
+        }
+        let n = match &self.proof {
+            Some(p) => p.envelope_len,
+            None => match self.held.first() {
+                Some((r, _)) if r.first == 0 => r.end(),
+                _ => return Ok(()),
+            },
+        };
+        let Some(envelope) = self.bytes(0, n) else { return Ok(()) };
+        if super::content_hash(&envelope) != self.cid {
+            return Err(RangeRefusal::ObjectDigestMismatch);
+        }
+        let head = match parse_head(&envelope, n)? {
+            HeadParse::Head(h) => h,
+            HeadParse::Need(_) => return Err(RangeRefusal::HeadMalformed("the object is shorter than its head".into())),
+        };
+        if let Some(union) = &self.sel.declared {
+            check_declared(&head, union, self.sel.layer_base.as_ref()).map_err(RangeRefusal::Codecs)?;
+        }
+        let (body_bytes, requests) = (self.body_bytes, self.requests);
+        let base = |index, component, companions, refinements, skipped, dropped, head, why| Fetched {
+            role: Role::Base, index, component, companions, refinements,
+            abandoned: Vec::new(), dropped, skipped, head,
+            verified_by: VerifiedBy::WholeObject, why_whole: Some(why), envelope: None,
+            body_bytes, requests,
+        };
+        let mut fetched = match head.version {
+            Version::Wai1 if head.is_layer() => {
+                let w = Wai::from_bytes(&envelope).map_err(|e| RangeRefusal::HeadMalformed(e.to_string()))?;
+                Fetched { role: Role::Layer, ..base(0, w.payload.clone(), Vec::new(), Vec::new(), Vec::new(), Vec::new(), head, WhyWhole::Layer) }
+            }
+            _ if layer_listed => return Err(RangeRefusal::NotALayer),
+            Version::Wai1 => {
+                let w = Wai::from_bytes(&envelope).map_err(|e| RangeRefusal::HeadMalformed(e.to_string()))?;
+                self.sel.dispatch_wai1(&w)?;
+                base(0, w.payload.clone(), Vec::new(), Vec::new(), Vec::new(), Vec::new(), head, why)
+            }
+            Version::Wai2 => {
+                let w = WaiMulti::from_bytes(&envelope).map_err(|e| RangeRefusal::HeadMalformed(e.to_string()))?;
+                let payloads = w.renditions.clone();
+                let digest_ok = |i: usize, e: &RenditionMeta| payloads.get(i).is_some_and(|p| e.payload_digest_matches(p));
+                let (index, skipped) = self.sel.select(&w.manifest, digest_ok).map_err(RangeRefusal::Selection)?;
+                let (mut companions, mut refinements, mut dropped) = (Vec::new(), Vec::new(), Vec::new());
+                for (i, class) in self.sel.applied(&w.manifest, index) {
+                    // A refinement that states no digest is dropped on this path as on the
+                    // range path (§7 step 5, §10.3).
+                    if class == Class::Refinement && w.manifest.renditions[i].sha256.is_none() {
+                        dropped.push((i, WhyWhole::DigestAbsent { index: i }));
+                        continue;
+                    }
+                    // One that does not match is not applied (SPEC §7.1).
+                    if !w.manifest.renditions[i].payload_digest_matches(&w.renditions[i]) {
+                        if class == Class::Refinement {
+                            dropped.push((i, WhyWhole::DigestMismatch { index: i }));
+                        }
+                        continue;
+                    }
+                    if w.manifest.renditions[i].is_companion() {
+                        companions.push((i, w.renditions[i].clone()));
+                    } else {
+                        refinements.push((i, w.renditions[i].clone()));
+                    }
+                }
+                base(index, w.renditions[index].clone(), companions, refinements, skipped, dropped, head, why)
+            }
+        };
+        fetched.envelope = Some(envelope);
+        self.finish(Ok(fetched));
+        Ok(())
+    }
+}
+
+/// Run `session` to its end: `answer` gives each request's response, or `None` for
+/// one that never arrives. A refinement's request that never arrives is abandoned at
+/// its deadline; a base's ends the session (`base_unanswered`). Returns the outcome.
+/// `drive` has no clock: every response is given the session's last known time, and a
+/// refinement is abandoned when nothing else can happen. A caller that keeps time calls
+/// [`FetchSession::on_response`] and [`FetchSession::tick`] itself.
+pub fn drive(
+    session: &mut FetchSession,
+    mut answer: impl FnMut(&Want) -> Option<(ResponseMeta, Vec<u8>)>,
+) -> Result<Fetched, RangeRefusal> {
+    loop {
+        if let Some(r) = session.result() {
+            return r.clone();
+        }
+        let wants = session.wants();
+        if wants.is_empty() {
+            for id in session.outstanding_of(Class::Refinement) {
+                session.on_deadline(id);
+            }
+            if session.result().is_some() {
+                continue;
+            }
+            if session.queued.is_empty() {
+                if session.outstanding() > 0 {
+                    return Err(RangeRefusal::BaseUnanswered);
+                }
+                return Err(RangeRefusal::HeadMalformed("the session wants nothing and has no outcome".into()));
+            }
+            continue;
+        }
+        for (id, w) in wants {
+            if let Some((meta, body)) = answer(&w) {
+                let now = session.now_ms;
+                session.on_response(id, &meta, &body, now)?;
+            }
+        }
+    }
+}
diff --git a/wai/wai-rs/src/http_binding/tests.rs b/wai/wai-rs/src/http_binding/tests.rs
new file mode 100644
index 000000000..a48747d94
--- /dev/null
+++ b/wai/wai-rs/src/http_binding/tests.rs
@@ -0,0 +1,1262 @@
+//! Unit tests of the HTTP binding: Appendix D's numbers, the head proof against
+//! whole-input hashing, plans, response checks, one pick on every path, the codecs
+//! grammar and the origin's Range answers.
+
+use super::codecs::{self, Element, Prefix};
+use super::head::{covered_len, parse_head, HeadParse, Version};
+use super::head_proof::HeadProof;
+use super::origin;
+use super::plan::{plan_components, plan_head, Class, FetchPolicy, WhyWhole};
+use super::session::{check_response, drive, FetchSession, ResponseMeta, Role, Selector, VerifiedBy, Want};
+use super::*;
+use crate::container::{Rendition, RenditionMeta, Skip, Wai, WaiMulti};
+
+fn pattern(len: usize, a: usize, b: usize) -> Vec<u8> {
+    (0..len).map(|i| ((a * i + b) % 256) as u8).collect()
+}
+
+/// Appendix D's envelope: `low` and `high` AV1 renditions and an HDR10+ companion
+/// bound to `high` by id.
+fn appendix_d() -> Vec<u8> {
+    WaiMulti::new("video", "replicate", serde_json::Value::Null, vec![
+        Rendition::media("wai.video.av1", "av1", pattern(3000, 7, 3)).with_id("low").with_payload_digest(),
+        Rendition::media("wai.video.av1", "av1", pattern(50_000, 13, 5)).with_id("high").with_payload_digest(),
+        Rendition::companion("wai.meta.hdr10plus", pattern(200, 31, 1), "wai.video.av1").with_id("hdr")
+            .with_payload_digest().with_companion_of_id("high"),
+    ]).to_bytes().unwrap()
+}
+
+fn head_of(env: &[u8]) -> head::Head {
+    match parse_head(env, env.len() as u64).unwrap() {
+        HeadParse::Head(h) => h,
+        HeadParse::Need(n) => panic!("needs {n}"),
+    }
+}
+
+/// An origin answering `want` from `object` and its proof, after `tamper` changes the
+/// served bytes, and `gzip` labels them coded.
+struct Served {
+    object: Vec<u8>,
+    proof: Vec<u8>,
+    gzip: bool,
+}
+
+impl Served {
+    fn new(object: &[u8]) -> Self {
+        Served { object: object.to_vec(), proof: HeadProof::build(object).unwrap().to_bytes(), gzip: false }
+    }
+    fn answer(&self, w: &Want) -> Option<(ResponseMeta, Vec<u8>)> {
+        let (range, body_of): (Option<String>, &[u8]) = match w {
+            Want::HeadProof => return Some((ResponseMeta { status: 200, ..Default::default() }, self.proof.clone())),
+            Want::Whole(_) => (None, &self.object),
+            Want::Range(r, _) => (Some(r.header()), &self.object),
+            Want::Rest(r, _) => (Some(format!("bytes={}-", r.first)), &self.object),
+        };
+        let s = origin::serve(body_of.len() as u64, range.as_deref());
+        let meta = ResponseMeta {
+            status: s.status,
+            content_range: s.content_range,
+            content_encoding: self.gzip.then(|| "gzip".to_string()),
+        };
+        Some((meta, body_of[s.body.start as usize..s.body.end as usize].to_vec()))
+    }
+}
+
+fn fetch(object: &[u8], frag: Fragment, sel: Selector) -> Result<session::Fetched, RangeRefusal> {
+    let served = Served::new(object);
+    let mut s = FetchSession::new(content_hash(object), frag, FetchPolicy::default(), sel);
+    drive(&mut s, |w| served.answer(w))
+}
+
+#[test]
+fn content_hash_is_reexport() {
+    let ours: fn(&[u8]) -> [u8; 32] = content_hash;
+    let theirs: fn(&[u8]) -> [u8; 32] = crate::jwp_hash::content_hash;
+    assert!(std::ptr::fn_addr_eq(ours, theirs));
+}
+
+#[test]
+fn head_parse_wai1_wai2() {
+    let d = appendix_d();
+    let h = head_of(&d);
+    assert_eq!((h.version, h.head_len, h.envelope_len), (Version::Wai2, 594, 53_794));
+    assert_eq!(h.manifest, 8..568);
+    let ranges: Vec<(u64, u64)> = h.components.iter().map(|c| (c.start, c.start + c.len - 1)).collect();
+    assert_eq!(ranges, [(594, 3593), (3594, 53593), (53594, 53793)]);
+    assert_eq!(hex(&d[568..594]), "030000000000b80b0000b80b000050c3000008cf0000c8000000");
+    let stream = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/vectors/int_mlicpp/stream.wai")).unwrap();
+    let h = head_of(&stream);
+    assert_eq!((h.version, h.envelope_len), (Version::Wai1, 859));
+    assert_eq!(h.components.len(), 1);
+    assert_eq!(h.components[0].start + h.components[0].len, 859);
+}
+
+#[test]
+fn head_parse_needs_more() {
+    let d = appendix_d();
+    // The count of renditions follows the manifest, so the head's end is known in two steps.
+    assert_eq!(parse_head(&d[..300], 53_794).unwrap(), HeadParse::Need(570));
+    assert_eq!(parse_head(&d[..580], 53_794).unwrap(), HeadParse::Need(594));
+    assert_eq!(parse_head(&d[..5], 53_794).unwrap(), HeadParse::Need(8));
+    assert!(matches!(parse_head(b"WAI3\0\0\0\0", 8), Err(RangeRefusal::HeadMalformed(_))));
+}
+
+#[test]
+fn object_length_rule() {
+    let d = appendix_d();
+    let mut long = d.clone();
+    long.push(0);
+    let e = parse_head(&long, long.len() as u64).unwrap_err();
+    assert_eq!(e.code(), "object_length_mismatch");
+    let e = parse_head(&d[..d.len() - 1], d.len() as u64 - 1).unwrap_err();
+    assert_eq!(e.code(), "object_length_mismatch");
+    assert!(HeadProof::build(&long).is_err());
+}
+
+#[test]
+fn covered_len_formula() {
+    assert_eq!(covered_len(594, 53_794), 1009);
+    // 15 + 1009 is one chunk exactly; one byte more needs a second.
+    assert_eq!(covered_len(1009, 1 << 20), 1009);
+    assert_eq!(covered_len(1010, 1 << 20), 2033);
+    assert_eq!(covered_len(12, 1 << 20), 1009);
+    assert_eq!(covered_len(594, 900), 900);
+}
+
+/// The left-subtree rule equals BLAKE3's own.
+#[test]
+fn left_len_is_blake3s() {
+    for n in (1025u64..70_000).step_by(97).chain([2048, 2049, 4096, 4097, 1 << 30, (1 << 30) + 1, u64::MAX / 2]) {
+        assert_eq!(head_proof::left_len_for_test(n), blake3::hazmat::left_subtree_len(n), "n = {n}");
+    }
+}
+
+/// A `WAI2` of `total` bytes with a small head: a manifest of one entry and padding.
+fn sized(total: usize) -> Vec<u8> {
+    let probe = WaiMulti::new("binary", "replicate", serde_json::Value::Null,
+        vec![Rendition::media("wai.text.zstd", "zstd", Vec::new())]).to_bytes().unwrap();
+    let payload = pattern(total - probe.len(), 11, 7);
+    let env = WaiMulti::new("binary", "replicate", serde_json::Value::Null,
+        vec![Rendition::media("wai.text.zstd", "zstd", payload)]).to_bytes().unwrap();
+    assert_eq!(env.len(), total);
+    env
+}
+
+/// A `WAI2` whose head spans several chunks: a long `target` member, so the covered
+/// prefix holds subtrees that start past the first chunk.
+fn large_head(total: usize) -> Vec<u8> {
+    let target = serde_json::json!({ "note": "x".repeat(5000) });
+    let build = |payload: Vec<u8>| WaiMulti::new("binary", "replicate", target.clone(),
+        vec![Rendition::media("wai.text.zstd", "zstd", payload)]).to_bytes().unwrap();
+    let probe = build(Vec::new());
+    let env = build(pattern(total - probe.len(), 11, 7));
+    assert!(head_of(&env).head_len > 4096);
+    env
+}
+
+#[test]
+fn head_proof_round_trip_and_tamper() {
+    let objects = [2048usize, 5000, 1 << 20, 64 << 20].map(sized).into_iter().chain([large_head(9000), large_head(1 << 20)]);
+    for env in objects {
+        let total = env.len();
+        let cid = content_hash(&env);
+        let p = HeadProof::build(&env).unwrap();
+        let bytes = p.to_bytes();
+        assert_eq!(bytes.len(), HeadProof::FIXED_LEN + 32 * p.cvs.len());
+        let back = HeadProof::from_bytes(&bytes).unwrap();
+        assert_eq!(back, p);
+        let prefix = &env[..p.covered_len as usize];
+        back.verify(&cid, prefix).unwrap();
+
+        // A flipped covered byte that leaves the head's length alone.
+        let mut bad = prefix.to_vec();
+        let last = bad.len() - 1;
+        bad[last] ^= 1;
+        assert_eq!(back.verify(&cid, &bad).unwrap_err(), RangeRefusal::HeadProofMismatch, "{total}");
+        // A flipped, a dropped and an extra chaining value.
+        let mut q = back.clone();
+        q.cvs[0][0] ^= 1;
+        assert_eq!(q.verify(&cid, prefix).unwrap_err(), RangeRefusal::HeadProofMismatch);
+        let mut q = back.clone();
+        q.cvs.pop();
+        assert_eq!(q.verify(&cid, prefix).unwrap_err(), RangeRefusal::HeadProofMismatch);
+        let mut q = back.clone();
+        q.cvs.push([0; 32]);
+        assert_eq!(q.verify(&cid, prefix).unwrap_err(), RangeRefusal::HeadProofMismatch);
+        // A wrong envelope_len. Where the tree changes shape the root does not match;
+        // where it keeps its shape the root does, and the verified head's lengths refuse it.
+        for delta in [1u64, 1024, 4096] {
+            let mut q = back.clone();
+            q.envelope_len += delta;
+            let code = q.verify(&cid, prefix).unwrap_err().code();
+            assert!(code == "head_proof_mismatch" || code == "head_proof_malformed", "{total} +{delta}: {code}");
+        }
+        // A covered_len that is not chunk-aligned, and one aligned but not the formula's.
+        let mut q = back.clone();
+        q.covered_len += 1;
+        assert_eq!(q.verify(&cid, &env).unwrap_err().code(), "head_proof_malformed");
+        let mut f = bytes.clone();
+        f[44..52].copy_from_slice(&(p.covered_len + 1).to_le_bytes());
+        assert_eq!(HeadProof::from_bytes(&f).unwrap_err().code(), "head_proof_malformed");
+        let aligned = HeadProof { covered_len: p.covered_len + 1024, cvs: Vec::new(), ..p.clone() };
+        let rebuilt = rebuild_cvs(&env, aligned.covered_len);
+        let wider = HeadProof { cvs: rebuilt, ..aligned };
+        if wider.covered_len < wider.envelope_len {
+            // The root still matches (the covered bytes are the object's), and check 3 refuses.
+            assert_eq!(wider.verify(&cid, &env).unwrap_err().code(), "head_proof_malformed", "{total}");
+        }
+        // Another object's cid.
+        assert_eq!(back.verify(&[0; 32], prefix).unwrap_err().code(), "head_proof_malformed");
+    }
+}
+
+/// The chaining values of a proof covering `covered` bytes, built by the same walk
+/// a producer makes but from an arbitrary aligned `covered`.
+fn rebuild_cvs(env: &[u8], covered: u64) -> Vec<[u8; 32]> {
+    use blake3::hazmat::HasherExt;
+    let mut x = crate::jwp_hash::DOMAIN_OBJECT.to_vec();
+    x.extend_from_slice(env);
+    fn walk(x: &[u8], start: u64, len: u64, c: u64, out: &mut Vec<[u8; 32]>) {
+        if start >= c {
+            let mut h = blake3::Hasher::new();
+            h.set_input_offset(start);
+            h.update(&x[start as usize..(start + len) as usize]);
+            out.push(h.finalize_non_root());
+        } else if start + len > c {
+            let l = blake3::hazmat::left_subtree_len(len);
+            walk(x, start, l, c, out);
+            walk(x, start + l, len - l, c, out);
+        }
+    }
+    let (n, c) = (x.len() as u64, DOMAIN_LEN + covered);
+    let l = blake3::hazmat::left_subtree_len(n);
+    let mut out = Vec::new();
+    walk(&x, 0, l, c, &mut out);
+    walk(&x, l, n - l, c, &mut out);
+    out
+}
+
+#[test]
+fn head_proof_matches_prototype() {
+    let d = appendix_d();
+    assert_eq!(d.len(), 53_794);
+    let cid = content_hash(&d);
+    assert_eq!(hex(&cid), "eecd29409ee510d39ef1b17653a3ae9a2a176c1d76c02dde3319f014a3ef3228");
+    let p = HeadProof::build(&d).unwrap();
+    assert_eq!((p.covered_len, p.cvs.len(), p.to_bytes().len()), (1009, 6, 245));
+    p.verify(&cid, &d[..1009]).unwrap();
+}
+
+#[test]
+fn whole_object_proof() {
+    let small = sized(900);
+    let cid = content_hash(&small);
+    let p = HeadProof::build(&small).unwrap();
+    assert_eq!((p.covered_len, p.cvs.len()), (900, 0));
+    p.verify(&cid, &small).unwrap();
+    let mut bad = small.clone();
+    let last = bad.len() - 1;
+    bad[last] ^= 1;
+    assert_eq!(p.verify(&cid, &bad).unwrap_err().code(), "head_proof_mismatch");
+}
+
+#[test]
+fn plan_appendix_d() {
+    let d = appendix_d();
+    let h = head_of(&d);
+    let policy = FetchPolicy::default();
+    assert_eq!(plan_head(&policy, &Fragment { h: Some(1009), ..Default::default() }), Some(ByteRange { first: 0, last: 1008 }));
+    assert_eq!(plan_head(&policy, &Fragment::default()), Some(ByteRange { first: 0, last: 16368 }));
+    assert_eq!(plan_head(&policy, &Fragment { n: Some(400), ..Default::default() }), None);
+    let held = [ByteRange { first: 0, last: 1008 }];
+    let all = [true, true, true];
+    // Plan 1: low.
+    let p = plan_components(&h, &[(0, Class::Base)], &all, &held, &policy);
+    assert_eq!(p.requests, vec![(ByteRange { first: 1009, last: 3593 }, Class::Base)]);
+    assert_eq!(p.whole_rest, None);
+    // Plan 2: high with hdr, 951 ‰ of the rest: the rest.
+    let p = plan_components(&h, &[(1, Class::Base), (2, Class::Base)], &all, &held, &policy);
+    assert_eq!(p.whole_rest, Some((ByteRange { first: 1009, last: 53793 }, WhyWhole::Threshold)));
+    assert!(p.requests.is_empty());
+}
+
+#[test]
+fn plan_classes_never_merge() {
+    let d = appendix_d();
+    let h = head_of(&d);
+    let held = [ByteRange { first: 0, last: 1008 }];
+    let all = [true, true, true];
+    let policy = FetchPolicy { full_threshold_permille: 1000, ..Default::default() };
+    // Adjacent ranges: low (base) and high (refinement here) stay two requests.
+    let p = plan_components(&h, &[(0, Class::Base), (1, Class::Refinement)], &all, &held, &policy);
+    assert_eq!(p.requests, vec![
+        (ByteRange { first: 1009, last: 3593 }, Class::Base),
+        (ByteRange { first: 3594, last: 53593 }, Class::Refinement),
+    ]);
+    // In one class they merge.
+    let p = plan_components(&h, &[(0, Class::Base), (1, Class::Base)], &all, &held, &policy);
+    assert_eq!(p.requests, vec![(ByteRange { first: 1009, last: 53593 }, Class::Base)]);
+}
+
+#[test]
+fn plan_no_digest_goes_whole() {
+    let d = appendix_d();
+    let h = head_of(&d);
+    let held = [ByteRange { first: 0, last: 1008 }];
+    let p = plan_components(&h, &[(0, Class::Base)], &[false, true, true], &held, &FetchPolicy::default());
+    assert_eq!(p.whole_rest, Some((ByteRange { first: 1009, last: 53793 }, WhyWhole::DigestAbsent { index: 0 })));
+}
+
+#[test]
+fn check_response_cases() {
+    let r = ByteRange { first: 1009, last: 3593 };
+    let ok = ResponseMeta { status: 206, content_range: Some("bytes 1009-3593/53794".into()), content_encoding: None };
+    assert_eq!(check_response(Some(r), &ok, 2585, 53_794), Ok(r));
+    let code = |m: &ResponseMeta, n: u64| check_response(Some(r), m, n, 53_794).unwrap_err().code();
+    assert_eq!(code(&ResponseMeta { content_range: Some("bytes 1009-3592/53794".into()), ..ok.clone() }, 2584), "content_range_mismatch");
+    assert_eq!(code(&ResponseMeta { content_encoding: Some("gzip".into()), ..ok.clone() }, 2585), "content_coding_present");
+    assert_eq!(code(&ResponseMeta { content_range: Some("bytes 1009-3593/53795".into()), ..ok.clone() }, 2585), "complete_length_mismatch");
+    assert_eq!(code(&ResponseMeta { content_range: Some("bytes 1009-3593/*".into()), ..ok.clone() }, 2585), "complete_length_mismatch");
+    assert_eq!(code(&ResponseMeta { status: 304, ..Default::default() }, 0), "http_status_unexpected");
+    assert_eq!(code(&ResponseMeta { status: 200, ..Default::default() }, 1000), "complete_length_mismatch");
+    assert_eq!(check_response(Some(r), &ResponseMeta { status: 200, ..Default::default() }, 53_794, 53_794).unwrap().len(), 53_794);
+    // A body shorter than its Content-Range claims.
+    assert_eq!(code(&ok, 2000), "content_range_mismatch");
+    // A head request past the end, answered to the end.
+    let head = ByteRange { first: 0, last: 16368 };
+    let m = ResponseMeta { status: 206, content_range: Some("bytes 0-899/900".into()), content_encoding: None };
+    assert_eq!(check_response(Some(head), &m, 900, 900), Ok(ByteRange { first: 0, last: 899 }));
+    // `identity` is no coding.
+    assert!(check_response(Some(r), &ResponseMeta { content_encoding: Some("identity".into()), ..ok }, 2585, 53_794).is_ok());
+}
+
+/// The sink of a test descriptor: what it advertises, the sets it holds by digest,
+/// and the capabilities it applies with a rendition.
+fn sink(adv: &'static [&'static str], applies: &'static [&'static str], order: Option<Vec<usize>>) -> Selector {
+    let mut s = Selector::new(move |c| adv.contains(&c));
+    s.applies = Box::new(move |e: &RenditionMeta| applies.contains(&e.capability.as_str()));
+    if let Some(o) = order {
+        s.order = Some(Box::new(move |_| o.clone()));
+    }
+    s
+}
+
+/// SPEC §7.1 on the whole envelope, in `order`.
+fn whole_pick(env: &[u8], adv: &[&str], order: &[usize]) -> Result<usize, Vec<(usize, Skip)>> {
+    let w = WaiMulti::from_bytes(env).unwrap();
+    let eligible = |_: usize, e: &RenditionMeta| if adv.contains(&e.capability.as_str()) { Ok(()) } else { Err(Skip::NotEligible) };
+    let digest_ok = |i: usize, e: &RenditionMeta| e.payload_digest_matches(&w.renditions[i]);
+    crate::container::select_entries(&w.manifest, order, eligible, digest_ok,
+        |c: &str, _: &crate::container::Prior| Err::<(), _>(crate::container::PinRefusal::NotHeld { capability: c.into() }))
+        .map(|(i, _, _)| i)
+}
+
+/// Envelopes for the both-paths test: Appendix D, one whose first entry lacks a
+/// digest, one whose first digest is wrong, and one whose companion's is.
+fn both_paths_envelopes() -> Vec<Vec<u8>> {
+    let mut v = vec![appendix_d()];
+    v.push(WaiMulti::new("video", "replicate", serde_json::Value::Null, vec![
+        Rendition::media("wai.video.av1", "av1", pattern(3000, 7, 3)).with_id("a"),
+        Rendition::media("wai.video.vp9", "vp9", pattern(4000, 5, 1)).with_id("b").with_payload_digest(),
+    ]).to_bytes().unwrap());
+    let mut bad = Rendition::media("wai.video.av1", "av1", pattern(3000, 7, 3)).with_id("a").with_payload_digest();
+    bad.meta.sha256 = Some(crate::pin::sha256_hex(b"not these bytes"));
+    v.push(WaiMulti::new("video", "replicate", serde_json::Value::Null, vec![
+        bad,
+        Rendition::media("wai.video.vp9", "vp9", pattern(4000, 5, 1)).with_id("b").with_payload_digest(),
+    ]).to_bytes().unwrap());
+    let mut hdr = Rendition::companion("wai.meta.hdr10plus", pattern(200, 31, 1), "wai.video.av1").with_id("hdr").with_payload_digest();
+    hdr.meta.sha256 = Some(crate::pin::sha256_hex(b"another descriptor"));
+    v.push(WaiMulti::new("video", "replicate", serde_json::Value::Null, vec![
+        Rendition::media("wai.video.av1", "av1", pattern(9000, 3, 9)).with_id("a").with_payload_digest(),
+        hdr,
+    ]).to_bytes().unwrap());
+    v
+}
+
+#[test]
+fn same_pick_both_paths() {
+    const ADV: [&[&str]; 8] = [
+        &["wai.video.av1"], &["wai.video.vp9"], &["wai.video.av1", "wai.video.vp9"], &[],
+        &["wai.video.av1", "wai.meta.hdr10plus"], &["wai.image.png"], &["wai.video.vp9", "wai.video.av1"], &["wai.video.int_hyper"],
+    ];
+    for env in both_paths_envelopes() {
+        let n = WaiMulti::from_bytes(&env).unwrap().manifest.renditions.len();
+        let orders: Vec<Vec<usize>> = vec![(0..n).collect(), (0..n).rev().collect(), (1..n).chain([0]).collect()];
+        for adv in ADV {
+            for order in &orders {
+                let want = whole_pick(&env, adv, order);
+                for frag in [Fragment::default(), Fragment { h: Some(1009), n: Some(env.len() as u64), ..Default::default() }] {
+                    let got = fetch(&env, frag, sink(adv, &["wai.meta.hdr10plus"], Some(order.clone())));
+                    match (&want, &got) {
+                        (Ok(i), Ok(f)) => assert_eq!(*i, f.index, "{adv:?} {order:?}"),
+                        (Err(_), Err(RangeRefusal::Selection(_))) => {}
+                        _ => panic!("paths differ: whole {want:?}, range {got:?} ({adv:?} {order:?})"),
+                    }
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn mismatch_goes_whole() {
+    let envs = both_paths_envelopes();
+    // A producer's wrong digest: the range path tries it, finds the bytes do not match,
+    // and decides on the whole envelope, as the whole path does: skip, next entry.
+    let f = fetch(&envs[2], Fragment::default(), sink(&["wai.video.av1", "wai.video.vp9"], &[], None)).unwrap();
+    assert_eq!(f.index, 1);
+    assert_eq!(f.skipped, vec![(0, Skip::ComponentDigest)]);
+    assert_eq!((f.verified_by, f.why_whole), (VerifiedBy::WholeObject, Some(WhyWhole::DigestMismatch { index: 0 })));
+    assert_eq!(whole_pick(&envs[2], &["wai.video.av1", "wai.video.vp9"], &[0, 1]), Ok(1));
+    // A companion with a wrong digest is not applied, on either path.
+    let f = fetch(&envs[3], Fragment::default(), sink(&["wai.video.av1"], &["wai.meta.hdr10plus"], None)).unwrap();
+    assert_eq!((f.index, f.companions.len()), (0, 0));
+    // A transport tamper: bytes changed under the same name.
+    let env = appendix_d();
+    let mut served = Served::new(&env);
+    served.object[2000] ^= 1;
+    let mut s = FetchSession::new(content_hash(&env), Fragment::default(), FetchPolicy::default(), sink(&["wai.video.av1"], &[], None));
+    let e = drive(&mut s, |w| served.answer(w)).unwrap_err();
+    assert_eq!(e.code(), "object_digest_mismatch");
+    // A head byte changed under the same name.
+    let mut served = Served::new(&env);
+    served.object[100] ^= 1;
+    let mut s = FetchSession::new(content_hash(&env), Fragment::default(), FetchPolicy::default(), sink(&["wai.video.av1"], &[], None));
+    assert_eq!(drive(&mut s, |w| served.answer(w)).unwrap_err().code(), "head_proof_mismatch");
+    // A content coding.
+    let mut served = Served::new(&env);
+    served.gzip = true;
+    let mut s = FetchSession::new(content_hash(&env), Fragment::default(), FetchPolicy::default(), sink(&["wai.video.av1"], &[], None));
+    assert_eq!(drive(&mut s, |w| served.answer(w)).unwrap_err().code(), "content_coding_present");
+}
+
+#[test]
+fn range_fetch_counts_appendix_d() {
+    let env = appendix_d();
+    let frag = Fragment { h: Some(1009), n: Some(53_794), ..Default::default() };
+    let f = fetch(&env, frag.clone(), sink(&["wai.video.av1"], &["wai.meta.hdr10plus"], None)).unwrap();
+    assert_eq!((f.index, f.verified_by, f.why_whole), (0, VerifiedBy::HeadProof, None));
+    assert_eq!((f.body_bytes, f.requests), (1009 + 245 + 2585, 3));
+    assert_eq!(f.component, pattern(3000, 7, 3));
+    // `high` first: the rest of the object, verified whole, with hdr applied.
+    let f = fetch(&env, frag, sink(&["wai.video.av1"], &["wai.meta.hdr10plus"], Some(vec![1, 0, 2]))).unwrap();
+    assert_eq!((f.index, f.verified_by, f.why_whole), (1, VerifiedBy::WholeObject, Some(WhyWhole::Threshold)));
+    assert_eq!(f.companions, vec![(2, pattern(200, 31, 1))]);
+    assert_eq!((f.body_bytes, f.requests), (53_794 + 245, 3));
+}
+
+#[test]
+fn deadline_never_blocks_base() {
+    // An AVC base and an enhancement layer bound to it: the layer is a refinement.
+    let env = WaiMulti::new("video", "replicate", serde_json::Value::Null, vec![
+        Rendition::media("wai.video.avc", "avc", pattern(6000, 3, 1)).with_id("base").with_payload_digest(),
+        Rendition::from_meta(RenditionMeta::new("wai.video.lcevc", "lcevc").companion_to("wai.video.avc"), pattern(40_000, 9, 2))
+            .with_id("enh").with_payload_digest().with_companion_of_id("base"),
+    ]).to_bytes().unwrap();
+    // No other rendition pads the object: the base and its refinement are all of the
+    // bytes after the head, and the refinement's still do not count toward the threshold.
+    WaiMulti::from_bytes(&env).unwrap().check_component_roles().unwrap();
+    let served = Served::new(&env);
+    let policy = FetchPolicy::default();
+    let mut s = FetchSession::new(content_hash(&env), Fragment::default(), policy, sink(&["wai.video.avc"], &["wai.video.lcevc"], None));
+    // The refinement's response never arrives.
+    let f = drive(&mut s, |w| if w.class() == Class::Refinement { None } else { served.answer(w) }).unwrap();
+    assert_eq!((f.index, f.abandoned.clone(), f.companions.len()), (0, vec![1], 0));
+    assert_eq!(f.verified_by, VerifiedBy::HeadProof);
+    // Answered, it is applied, in its own request.
+    let h = head_of(&env);
+    let frag = Fragment { h: Some(h.covered_len()), ..Default::default() };
+    let mut s = FetchSession::new(content_hash(&env), frag, policy, sink(&["wai.video.avc"], &["wai.video.lcevc"], None));
+    let mut classes = Vec::new();
+    let f = drive(&mut s, |w| {
+        if let Want::Range(r, c) = w {
+            classes.push((*r, *c));
+        }
+        served.answer(w)
+    }).unwrap();
+    assert_eq!(f.companions.len(), 1);
+    let (base, enh) = (h.components[0], h.components[1]);
+    let covered = h.covered_len();
+    assert_eq!(classes, vec![
+        (ByteRange { first: 0, last: covered - 1 }, Class::Base),
+        (ByteRange { first: covered, last: base.start + base.len - 1 }, Class::Base),
+        (ByteRange { first: enh.start, last: enh.start + enh.len - 1 }, Class::Refinement),
+    ]);
+}
+
+#[test]
+fn small_objects_whole() {
+    let small = sized(400);
+    let f = fetch(&small, Fragment { n: Some(400), ..Default::default() }, sink(&["wai.text.zstd"], &[], None)).unwrap();
+    assert_eq!((f.verified_by, f.why_whole, f.requests), (VerifiedBy::WholeObject, Some(WhyWhole::BelowOneChunk), 1));
+    // Without `n`: the head request returns the whole object, and its proof covers it.
+    let f = fetch(&small, Fragment::default(), sink(&["wai.text.zstd"], &[], None)).unwrap();
+    assert_eq!(f.index, 0);
+    let stream = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/vectors/int_mlicpp/stream.wai")).unwrap();
+    let mut s = sink(&["wai.neural.int_mlicpp"], &[], None);
+    s.verify_pin = Box::new(|_, _| Ok(()));
+    let f = fetch(&stream, Fragment::default(), s).unwrap();
+    assert_eq!((f.index, f.component.len()), (0, stream.len() - head_of(&stream).head_len as usize));
+}
+
+fn el(s: &str) -> Element {
+    codecs::parse_element(s).unwrap()
+}
+
+#[test]
+fn codecs_grammar() {
+    for ok in ["wai2.video.av1+meta.hdr10plus|video.int_hyper", "wai1.video.av1", "wai2.image.avif|neural.int_mlicpp",
+               "wai2.video.avc+video.lcevc", "wai2.video.int_motion+video.int_refine"] {
+        assert_eq!(codecs::render(&el(ok)), ok);
+    }
+    for (bad, code) in [
+        ("wai1.Video.av1", "codecs_malformed"), ("wai1.video..av1", "codecs_malformed"), ("wai3.video.av1", "codecs_malformed"),
+        ("wai1.video.av1+video.vp9", "codecs_malformed"), ("wai1.meta.hdr10plus", "codecs_malformed"),
+        ("wai1.derive.crop", "codecs_not_media"), ("wai1.splat.sog", "codecs_candidate"), ("wai1.video", "codecs_malformed"),
+        ("wai1.video.manifest", "codecs_not_media"), ("wai1.video.int_refine", "codecs_malformed"),
+    ] {
+        let e = codecs::parse(bad).unwrap_err();
+        assert_eq!(e.code(), code, "{bad}");
+    }
+    let v = codecs::parse("mp4a.40.2, wai1.video.av1,avc1.42E01E").unwrap();
+    assert_eq!((v[0].is_none(), v[1].is_some(), v[2].is_none()), (true, true, true));
+}
+
+#[test]
+fn every_registered_media_capability_has_an_element() {
+    use crate::codecs::registry::{registrations, Kind, RegistrationStatus};
+    for r in registrations() {
+        if r.status != RegistrationStatus::Registered {
+            continue;
+        }
+        let cap = r.capability.strip_prefix("wai.").expect("wai.");
+        let text = match r.kind {
+            Kind::Payload => format!("wai1.{cap}"),
+            Kind::Companion => format!("wai2.video.av1+{cap}"),
+            Kind::Refinement => format!("wai2.video.int_motion+{cap}"),
+            Kind::Derivation | Kind::Record => continue,
+        };
+        assert_eq!(codecs::render(&el(&text)), text, "{}", r.capability);
+    }
+}
+
+fn seq(rends: Vec<Rendition>) -> codecs::SeqObject {
+    codecs::SeqObject::from_envelope(&WaiMulti::new("video", "replicate", serde_json::Value::Null, rends).to_bytes().unwrap()).unwrap()
+}
+
+fn obj(rends: Vec<Rendition>) -> head::Head {
+    head_of(&WaiMulti::new("video", "replicate", serde_json::Value::Null, rends).to_bytes().unwrap())
+}
+
+#[test]
+fn union_and_floor() {
+    let a = seq(vec![Rendition::media("wai.video.av1", "av1", vec![1]), Rendition::media("wai.video.int_hyper", "int_hyper", vec![2])]);
+    let b = seq(vec![Rendition::media("wai.video.av1", "av1", vec![3])]);
+    let hs = [a.clone(), b.clone(), b.clone()];
+    assert_eq!(codecs::render(&codecs::union_of(&hs).unwrap()), "wai2.video.av1|video.int_hyper");
+    assert_eq!(codecs::render(&codecs::floor_of(&hs).unwrap()), "wai2.video.av1");
+    let c = seq(vec![Rendition::media("wai.video.vp9", "vp9", vec![3])]);
+    assert_eq!(codecs::floor_of(&[b.clone(), c]).unwrap_err().code(), "codecs_no_common_capability");
+    // Appendix D.
+    let d = codecs::SeqObject::from_envelope(&appendix_d()).unwrap();
+    assert_eq!(codecs::render(&codecs::union_of(std::slice::from_ref(&d)).unwrap()), "wai2.video.av1+meta.hdr10plus");
+    assert_eq!(codecs::render(&codecs::floor_of(&[d]).unwrap()), "wai2.video.av1+meta.hdr10plus");
+}
+
+#[test]
+fn undeclared_refused() {
+    let h = obj(vec![Rendition::media("wai.video.vp9", "vp9", vec![1])]);
+    assert_eq!(codecs::check_declared(&h, &el("wai2.video.av1"), None).unwrap_err().code(), "codecs_undeclared");
+    assert!(codecs::check_declared(&h, &el("wai2.video.av1|video.vp9"), None).is_ok());
+    // A WAI2 under a wai1 element.
+    assert_eq!(codecs::check_declared(&h, &el("wai1.video.vp9"), None).unwrap_err().code(), "codecs_undeclared");
+    // A companion the union does not list.
+    let d = head_of(&appendix_d());
+    assert_eq!(codecs::check_declared(&d, &el("wai2.video.av1"), None).unwrap_err().code(), "codecs_undeclared");
+    // And a session refuses such an object at step 3.
+    let mut s = sink(&["wai.video.av1"], &[], None);
+    s.declared = Some(el("wai2.video.vp9"));
+    assert_eq!(fetch(&appendix_d(), Fragment::default(), s).unwrap_err().code(), "codecs_undeclared");
+}
+
+#[test]
+fn container_gate() {
+    let only1 = [Prefix::Wai1];
+    let has = |c: &str| c == "wai.video.av1";
+    assert!(!codecs::supports(&el("wai2.video.av1"), &only1, has));
+    assert!(codecs::supports(&el("wai1.video.av1"), &only1, has));
+    assert!(codecs::supports(&el("wai2.video.av1"), &[Prefix::Wai1, Prefix::Wai2], has));
+}
+
+#[test]
+fn supports_floor_only() {
+    let both = [Prefix::Wai1, Prefix::Wai2];
+    let floor = el("wai2.video.av1");
+    assert!(!codecs::supports(&floor, &both, |c| c == "wai.video.int_hyper"));
+    assert!(codecs::supports(&floor, &both, |c| c == "wai.video.av1"));
+    // Companions never affect support.
+    assert!(codecs::supports(&el("wai2.video.av1+meta.hdr10plus"), &both, |c| c == "wai.video.av1"));
+}
+
+#[test]
+fn origin_serve() {
+    let s = origin::serve(1000, None);
+    assert_eq!((s.status, s.body.clone()), (200, 0..1000));
+    let s = origin::serve(1000, Some("bytes=10-19"));
+    assert_eq!((s.status, s.content_range.as_deref(), s.body.clone()), (206, Some("bytes 10-19/1000"), 10..20));
+    let s = origin::serve(1000, Some("bytes=-100"));
+    assert_eq!((s.status, s.content_range.as_deref()), (206, Some("bytes 900-999/1000")));
+    let s = origin::serve(1000, Some("bytes=990-"));
+    assert_eq!((s.status, s.content_range.as_deref()), (206, Some("bytes 990-999/1000")));
+    let s = origin::serve(1000, Some("bytes=0-99999"));
+    assert_eq!(s.content_range.as_deref(), Some("bytes 0-999/1000"));
+    let s = origin::serve(1000, Some("bytes=1000-"));
+    assert_eq!((s.status, s.content_range.as_deref(), s.body.clone()), (416, Some("bytes */1000"), 0..0));
+    let s = origin::serve(1000, Some("bytes=0-1,5-6"));
+    assert_eq!(s.status, 200);
+    let h = origin::object_headers(&[0xab; 32], Some("wai2.video.av1"));
+    let get = |k: &str| h.iter().find(|(n, _)| *n == k).map(|(_, v)| v.clone());
+    assert_eq!(get("Access-Control-Allow-Origin").as_deref(), Some("*"));
+    assert_eq!(get("ETag"), Some(format!("\"{}\"", "ab".repeat(32))));
+    assert_eq!(get("Content-Type").as_deref(), Some("application/wai; codecs=\"wai2.video.av1\""));
+    assert!(get("Vary").is_none() && get("Content-Encoding").is_none());
+    let p = origin::preflight_headers();
+    assert!(p.iter().any(|(n, v)| *n == "Access-Control-Allow-Headers" && v == "Range, Priority"));
+    assert!(p.iter().any(|(n, _)| *n == "Access-Control-Max-Age"));
+}
+
+#[test]
+fn fragment_parse() {
+    let cid = "ee".repeat(32);
+    let (base, f) = parse_fragment(&format!("live/1.wai#cid={cid}&n=53794&h=1009&c=low&x=1"));
+    assert_eq!(base, "live/1.wai");
+    assert_eq!(f, Fragment { cid: Some([0xee; 32]), n: Some(53_794), h: Some(1009), c: Some("low".into()) });
+    assert_eq!(parse_fragment("a.wai").1, Fragment::default());
+    assert_eq!(parse_fragment("a.wai#n=x&cid=zz").1, Fragment::default());
+    assert_eq!(object_name(&[0xee; 32]), format!("{cid}.wai"));
+}
+
+// ------------------------------------------------------------------ fix round
+
+/// splitmix64, for the seeded inputs below.
+fn next(s: &mut u64) -> u64 {
+    *s = s.wrapping_add(0x9E37_79B9_7F4A_7C15);
+    let mut z = *s;
+    z = (z ^ (z >> 30)).wrapping_mul(0xBF58_476D_1CE4_E5B9);
+    z = (z ^ (z >> 27)).wrapping_mul(0x94D0_49BB_1331_11EB);
+    z ^ (z >> 31)
+}
+
+/// A random string from pieces that parsers of this binding read, mixed with ASCII
+/// punctuation, controls and characters of several scripts.
+fn text(s: &mut u64, pieces: &[&str]) -> String {
+    const ATOMS: &[&str] = &["é", "١", "\u{0}", "\u{1f600}", "ß", " ", "\t", "+", "-", "_", ",", ".", "|", "\"", "=", "/", "*", "%", "\u{feff}", "WAI", "wai", "Wai", "0", "9"];
+    let n = next(s) % 8;
+    let mut out = String::new();
+    for _ in 0..n {
+        match next(s) % 3 {
+            0 => out.push_str(pieces[(next(s) % pieces.len() as u64) as usize]),
+            1 => out.push_str(ATOMS[(next(s) % ATOMS.len() as u64) as usize]),
+            _ => out.push(char::from_u32((next(s) % 0x2FFF) as u32).unwrap_or('x')),
+        }
+    }
+    out
+}
+
+/// Item 1: every parser of untrusted text or bytes in this binding returns, and never
+/// panics, over thousands of seeded inputs, non-ASCII ones included.
+#[test]
+fn untrusted_input_never_panics() {
+    let mut s = 0x5eed_u64;
+    let codec_pieces = ["wai1.", "wai2.", "video.av1", "+meta.hdr10plus", "|video.int_hyper", "wai١.video.av1", "mp4a.40.2", "WAI2.video.av1", "wai2.videó.av1"];
+    for _ in 0..4000 {
+        let _ = codecs::parse(&text(&mut s, &codec_pieces));
+        let _ = codecs::parse_element(&text(&mut s, &codec_pieces));
+    }
+    let cr_pieces = ["bytes ", "0", "1008", "-", "/", "53794", "+0", "*", "١٢", "1_0", " "];
+    for _ in 0..4000 {
+        let m = ResponseMeta { status: [200, 206, 304, 416][(next(&mut s) % 4) as usize], content_range: Some(text(&mut s, &cr_pieces)),
+            content_encoding: Some(text(&mut s, &["gzip", "identity", "br"])) };
+        let first = next(&mut s) % 4;
+        let r = ByteRange::from_len(first, next(&mut s) % 70_000 + 1);
+        let _ = check_response(r, &m, next(&mut s) % 70_000, next(&mut s) % 70_000);
+        let _ = check_response(r, &m, next(&mut s), next(&mut s));
+    }
+    let tag_pieces = ["#WAI-LAYER:", "N=", "1", "255", "256", ",", "URI=", "\"", "a.wai#n=5", "X-Y=", "N=2,N=3"];
+    for _ in 0..4000 {
+        let _ = super::playlist::parse_layer_tag(&text(&mut s, &tag_pieces));
+        let _ = parse_fragment(&text(&mut s, &["a.wai", "#", "cid=", "n=", "h=", "c=", "&", "é"]));
+    }
+    // Head proofs: random files, and a real one with every length field set to an
+    // extreme, against prefixes of every size.
+    let d = appendix_d();
+    let real = HeadProof::build(&d).unwrap();
+    for i in 0..4000 {
+        let mut b = real.to_bytes();
+        let at = (next(&mut s) % b.len() as u64) as usize;
+        b[at] = next(&mut s) as u8;
+        if i % 3 == 0 {
+            let v = [u64::MAX, u64::MAX - 1, u64::MAX - 15, u64::MAX - 14, 0, 1, 1009][(next(&mut s) % 7) as usize];
+            let field = if next(&mut s) % 2 == 0 { 36 } else { 44 };
+            b[field..field + 8].copy_from_slice(&v.to_le_bytes());
+        }
+        if i % 5 == 0 {
+            b.truncate((next(&mut s) % 300) as usize);
+        }
+        if let Ok(p) = HeadProof::from_bytes(&b) {
+            let cut = (next(&mut s) % 2000) as usize;
+            let _ = p.verify(&real.cid, &d[..cut.min(d.len())]);
+            let _ = p.verify(&real.cid, &d);
+        }
+    }
+    // Heads and manifests: random bytes, and real heads with bytes changed.
+    let stream = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/vectors/int_mlicpp/stream.wai")).unwrap();
+    for i in 0..4000 {
+        let base = if i % 2 == 0 { &d } else { &stream };
+        let mut b = base[..(600 + (next(&mut s) % 400) as usize).min(base.len())].to_vec();
+        for _ in 0..1 + next(&mut s) % 4 {
+            let at = (next(&mut s) % b.len() as u64) as usize;
+            b[at] = [b'"', b'\\', 0xc3, 0xa9, 0xff, b'{', b'}', b'0', b'-', next(&mut s) as u8][(next(&mut s) % 10) as usize];
+        }
+        let n = if i % 7 == 0 { next(&mut s) } else { base.len() as u64 };
+        if let Ok(HeadParse::Head(h)) = parse_head(&b, n) {
+            let _ = codecs::element_of(&h);
+            let _ = h.is_layer();
+        }
+    }
+}
+
+/// Item 7: an untrusted head proof whose lengths run to the end of u64 is refused,
+/// in `from_bytes`, in `verify` and in a session, without arithmetic overflow.
+#[test]
+fn untrusted_proof_lengths_refused() {
+    let d = appendix_d();
+    let real = HeadProof::build(&d).unwrap();
+    for (env_len, cov) in [(u64::MAX, real.covered_len), (u64::MAX - 14, real.covered_len), (u64::MAX, u64::MAX - 1), (2000, 3000)] {
+        let p = HeadProof { envelope_len: env_len, covered_len: cov, ..real.clone() };
+        assert_eq!(HeadProof::from_bytes(&p.to_bytes()).unwrap_err().code(), "head_proof_malformed", "{env_len} {cov}");
+        assert_eq!(p.verify(&real.cid, &d).unwrap_err().code(), "head_proof_malformed", "{env_len} {cov}");
+    }
+    // A cache that rewrites every complete length and a proof to match.
+    let bad = HeadProof { envelope_len: u64::MAX, ..real.clone() }.to_bytes();
+    let mut s = FetchSession::new(real.cid, Fragment::default(), FetchPolicy::default(), sink(&["wai.video.av1"], &[], None));
+    let served = Served::new(&d);
+    let e = drive(&mut s, |w| {
+        if matches!(w, Want::HeadProof) {
+            return Some((ResponseMeta { status: 200, ..Default::default() }, bad.clone()));
+        }
+        let (mut m, b) = served.answer(w)?;
+        m.content_range = m.content_range.map(|cr| cr.replace(&format!("/{}", d.len()), &format!("/{}", u64::MAX)));
+        Some((m, b))
+    }).unwrap_err();
+    assert_eq!(e.code(), "head_proof_malformed");
+}
+
+/// Item 6: Content-Range numbers are ASCII digits, as RFC 9110 writes them.
+#[test]
+fn content_range_digits_only() {
+    let want = ByteRange { first: 0, last: 1008 };
+    for cr in ["bytes +0-1008/53794", "bytes 0-+1008/53794", "bytes 0-1_008/53794", "bytes 0- 1008/53794", "bytes ٠-1008/53794", "bytes 0-1008/+53794", "bytes 0-1008/5_3794"] {
+        let m = ResponseMeta { status: 206, content_range: Some(cr.into()), content_encoding: None };
+        assert!(check_response(Some(want), &m, 1009, 53_794).is_err(), "{cr}");
+    }
+    let m = ResponseMeta { status: 206, content_range: Some(" bytes 0-1008/53794\t".into()), content_encoding: None };
+    assert!(check_response(Some(want), &m, 1009, 53_794).is_ok());
+}
+
+/// Item 11: a base request never answered ends the fetch with its own reason.
+#[test]
+fn unanswered_base() {
+    let d = appendix_d();
+    let served = Served::new(&d);
+    for never in [Want::HeadProof, Want::Range(ByteRange { first: 0, last: 16368 }, Class::Base)] {
+        let mut s = FetchSession::new(content_hash(&d), Fragment::default(), FetchPolicy::default(), sink(&["wai.video.av1"], &[], None));
+        let e = drive(&mut s, |w| if *w == never { None } else { served.answer(w) }).unwrap_err();
+        assert_eq!(e.code(), "base_unanswered");
+    }
+}
+
+/// An AVC base and an LCEVC enhancement bound to it: the review's shape for a
+/// refinement whose bytes are most of the object.
+fn base_and_enhancement(base: usize, enh: usize, enh_digest: Option<&str>) -> Vec<u8> {
+    let mut e = Rendition::from_meta(RenditionMeta::new("wai.video.lcevc", "lcevc").companion_to("wai.video.avc"), pattern(enh, 13, 3))
+        .with_id("enh").with_companion_of_id("base");
+    match enh_digest {
+        Some("right") => e = e.with_payload_digest(),
+        Some(other) => e.meta.sha256 = Some(crate::pin::sha256_hex(other.as_bytes())),
+        None => {}
+    }
+    WaiMulti::new("video", "replicate", serde_json::Value::Null, vec![
+        Rendition::media("wai.video.avc", "avc", pattern(base, 7, 11)).with_id("base").with_payload_digest(),
+        e,
+    ]).to_bytes().unwrap()
+}
+
+/// Item 3: a refinement never sends its base to the rest of the object, so a
+/// refinement whose bytes never arrive cannot stall the base (`threshold-stall`).
+#[test]
+fn threshold_stall() {
+    let d = base_and_enhancement(8000, 30_000, Some("right"));
+    let h = head_of(&d);
+    let enh = h.components[1];
+    let served = Served::new(&d);
+    for permille in [900u16, 1001] {
+        let policy = FetchPolicy { full_threshold_permille: permille, ..Default::default() };
+        let mut s = FetchSession::new(content_hash(&d), Fragment { h: Some(1009), ..Default::default() }, policy,
+            sink(&["wai.video.avc"], &["wai.video.lcevc"], None));
+        let f = drive(&mut s, |w| {
+            let r = match w { Want::Range(r, _) | Want::Rest(r, _) => Some(*r), _ => None };
+            if r.is_some_and(|r| r.first < enh.start + enh.len && enh.start < r.end() && r.first >= 1009) {
+                return None;
+            }
+            served.answer(w)
+        }).unwrap();
+        assert_eq!((f.index, f.abandoned.clone(), f.why_whole, f.verified_by), (0, vec![1], None, VerifiedBy::HeadProof), "{permille}");
+    }
+    // The base alone past the threshold still goes whole; its refinement's bytes do not
+    // count toward it.
+    let p = plan_components(&h, &[(0, Class::Base), (1, Class::Refinement)], &[true, true], &[ByteRange { first: 0, last: 1008 }], &FetchPolicy::default());
+    assert_eq!(p.whole_rest, None);
+    assert_eq!(p.requests.iter().map(|(_, c)| *c).collect::<Vec<_>>(), vec![Class::Base, Class::Refinement]);
+}
+
+/// Item 3: a refinement that states no digest, or fails it, is dropped alone; the
+/// base's path is the one it takes without the refinement.
+#[test]
+fn refinement_digest_problems_are_its_own() {
+    let control = {
+        let d = base_and_enhancement(8000, 30_000, Some("right"));
+        fetch(&d, Fragment { h: Some(1009), ..Default::default() }, sink(&["wai.video.avc"], &[], None)).unwrap()
+    };
+    for (digest, why) in [(None, "component_digest_absent"), (Some("wrong"), "component_digest_mismatch")] {
+        let d = base_and_enhancement(8000, 30_000, digest);
+        let f = fetch(&d, Fragment { h: Some(1009), ..Default::default() }, sink(&["wai.video.avc"], &["wai.video.lcevc"], None)).unwrap();
+        assert_eq!((f.index, f.verified_by, f.why_whole), (control.index, control.verified_by, control.why_whole), "{why}");
+        assert_eq!(f.companions.len(), 0);
+        assert_eq!(f.dropped.iter().map(|(i, w)| (*i, w.code())).collect::<Vec<_>>(), vec![(1, why)]);
+    }
+}
+
+/// Item 4: a refinement-class response that §7.1 refuses is discarded and the
+/// refinement abandoned; the base is delivered. A base-class refusal still ends it.
+#[test]
+fn refused_refinement_responses() {
+    let d = base_and_enhancement(8000, 20_000, Some("right"));
+    let served = Served::new(&d);
+    let rows: [(&str, &dyn Fn(ByteRange, ResponseMeta, Vec<u8>) -> (ResponseMeta, Vec<u8>)); 6] = [
+        ("content_range_mismatch", &|r, mut m, b| { m.content_range = Some(format!("bytes {}-{}/{}", r.first + 1, r.last + 1, 28_000)); (m, b) }),
+        ("content_coding_present", &|_, mut m, b| { m.content_encoding = Some("gzip".into()); (m, b) }),
+        ("http_status_unexpected", &|_, _, _| (ResponseMeta { status: 416, content_range: Some("bytes */1".into()), content_encoding: None }, Vec::new())),
+        ("complete_length_mismatch", &|r, mut m, b| { m.content_range = Some(format!("bytes {}-{}/{}", r.first, r.last, 1)); (m, b) }),
+        ("short_200", &|_, _, b| (ResponseMeta { status: 200, ..Default::default() }, b)),
+        ("plus_sign", &|r, mut m, b| { m.content_range = m.content_range.map(|cr| cr.replacen("bytes ", "bytes +", 1)); let _ = r; (m, b) }),
+    ];
+    for (row, mutate) in rows {
+        let mut s = FetchSession::new(content_hash(&d), Fragment { h: Some(1009), ..Default::default() }, FetchPolicy::default(),
+            sink(&["wai.video.avc"], &["wai.video.lcevc"], None));
+        let f = drive(&mut s, |w| {
+            let (m, b) = served.answer(w)?;
+            match w {
+                Want::Range(r, Class::Refinement) => Some(mutate(*r, m, b)),
+                _ => Some((m, b)),
+            }
+        }).unwrap();
+        assert_eq!((f.index, f.abandoned.clone(), f.companions.len(), f.verified_by), (0, vec![1], 0, VerifiedBy::HeadProof), "{row}");
+    }
+    // The same refusal on the base's own range ends the fetch.
+    let mut s = FetchSession::new(content_hash(&d), Fragment { h: Some(1009), ..Default::default() }, FetchPolicy::default(),
+        sink(&["wai.video.avc"], &["wai.video.lcevc"], None));
+    let e = drive(&mut s, |w| {
+        let (mut m, b) = served.answer(w)?;
+        if let Want::Range(r, Class::Base) = w {
+            if r.first == 1009 {
+                m.content_encoding = Some("gzip".into());
+            }
+        }
+        Some((m, b))
+    }).unwrap_err();
+    assert_eq!(e.code(), "content_coding_present");
+}
+
+/// Item 5: one byte of the first response changed in transit past the covered head.
+/// The mismatch discards every byte past the head and fetches the rest again, so the
+/// fetch ends on the origin's bytes (`stale`, and `stale-small` where the first request
+/// held the whole object).
+#[test]
+fn stale_bytes_are_not_reused() {
+    let small = WaiMulti::new("video", "replicate", serde_json::Value::Null, vec![
+        Rendition::media("wai.video.av1", "av1", pattern(3000, 7, 3)).with_id("low").with_payload_digest(),
+        Rendition::media("wai.video.av1", "av1", pattern(9000, 13, 5)).with_id("high").with_payload_digest(),
+    ]).to_bytes().unwrap();
+    for (name, d) in [("stale", appendix_d()), ("stale-small", small)] {
+        let served = Served::new(&d);
+        let mut first = true;
+        let mut s = FetchSession::new(content_hash(&d), Fragment::default(), FetchPolicy::default(), sink(&["wai.video.av1"], &[], None));
+        let mut rest_asked = None;
+        let f = drive(&mut s, |w| {
+            let (m, mut b) = served.answer(w)?;
+            if let Want::Rest(r, _) = w {
+                rest_asked = Some(*r);
+            }
+            if first && matches!(w, Want::Range(..)) {
+                first = false;
+                b[2000] ^= 1;
+            }
+            Some((m, b))
+        }).unwrap();
+        assert_eq!((f.index, f.verified_by, f.why_whole), (0, VerifiedBy::WholeObject, Some(WhyWhole::DigestMismatch { index: 0 })), "{name}");
+        assert_eq!(f.component, pattern(3000, 7, 3), "{name}");
+        assert_eq!(rest_asked, Some(ByteRange { first: 1009, last: d.len() as u64 - 1 }), "{name}");
+    }
+}
+
+fn staged(name: &str) -> Vec<u8> {
+    std::fs::read(format!("{}/../staged-conformance/cases/audio_flac_rate_ladder/{name}.wai", env!("CARGO_MANIFEST_DIR"))).unwrap()
+}
+
+/// Item 2: a layer object is fetched whole at refinement class, verified, and
+/// delivered for staged delivery, never dispatched, whether its head shows it or a
+/// playlist lists it; an object listed as a layer that is not one is refused.
+#[test]
+fn layers_are_fetched_for_staged_delivery() {
+    let l1 = staged("L1");
+    assert!(head_of(&l1).is_layer() && !head_of(&staged("base")).is_layer());
+    // The sink advertises nothing: SPEC §4 is not run.
+    let served = Served::new(&l1);
+    let mut classes = Vec::new();
+    let mut s = FetchSession::new(content_hash(&l1), Fragment { h: Some(1009), ..Default::default() }, FetchPolicy::default(), sink(&[], &[], None));
+    let f = drive(&mut s, |w| { classes.push(w.class()); served.answer(w) }).unwrap();
+    assert_eq!((f.role, f.why_whole, f.verified_by), (Role::Layer, Some(WhyWhole::Layer), VerifiedBy::WholeObject));
+    assert_eq!(f.envelope.as_deref(), Some(&l1[..]));
+    assert_eq!(classes.last(), Some(&Class::Refinement));
+    // Listed as a layer: one whole request at refinement class.
+    let mut s = FetchSession::new_layer(content_hash(&l1), Fragment::default(), FetchPolicy::default(), sink(&[], &[], None));
+    let mut wants = Vec::new();
+    let f = drive(&mut s, |w| { wants.push(w.clone()); served.answer(w) }).unwrap();
+    assert_eq!((f.role, f.envelope.as_deref()), (Role::Layer, Some(&l1[..])));
+    assert_eq!(wants, vec![Want::Whole(Class::Refinement)]);
+    // Abandoned at its deadline: delivered as abandoned, not an error.
+    let mut s = FetchSession::new_layer(content_hash(&l1), Fragment::default(), FetchPolicy::default(), sink(&[], &[], None));
+    let f = drive(&mut s, |_| None).unwrap();
+    assert_eq!((f.role, f.abandoned.clone(), f.envelope.is_none()), (Role::Layer, vec![0], true));
+    // A refused response at refinement class abandons it too.
+    let mut s = FetchSession::new_layer(content_hash(&l1), Fragment::default(), FetchPolicy::default(), sink(&[], &[], None));
+    let f = drive(&mut s, |w| served.answer(w).map(|(mut m, b)| { m.content_encoding = Some("gzip".into()); (m, b) })).unwrap();
+    assert_eq!(f.abandoned, vec![0]);
+    // Listed as a layer, and not one.
+    let base = staged("base");
+    let served = Served::new(&base);
+    let mut s = FetchSession::new_layer(content_hash(&base), Fragment::default(), FetchPolicy::default(), sink(&[], &[], None));
+    assert_eq!(drive(&mut s, |w| served.answer(w)).unwrap_err().code(), "not_a_layer");
+}
+
+/// Item 2: a layer joins the union, and the floor where every base has it, after `+`
+/// in the alt of the base its `refines.base` names; `check_declared` accepts it so.
+#[test]
+fn layers_in_the_union() {
+    let objs: Vec<codecs::SeqObject> = ["base", "L1", "L2"].iter().map(|n| codecs::SeqObject::from_envelope(&staged(n)).unwrap()).collect();
+    assert_eq!(codecs::render(&codecs::union_of(&objs).unwrap()), "wai1.audio.flac+audio.int_refine");
+    assert_eq!(codecs::render(&codecs::floor_of(&objs).unwrap()), "wai1.audio.flac+audio.int_refine");
+    let union = codecs::parse_element("wai1.audio.flac+audio.int_refine").unwrap();
+    assert!(codecs::check_declared(&head_of(&staged("L1")), &union, Some(&objs[0])).is_ok());
+    let bare = codecs::parse_element("wai1.audio.flac").unwrap();
+    assert_eq!(codecs::check_declared(&head_of(&staged("L1")), &bare, Some(&objs[0])).unwrap_err().code(), "codecs_undeclared");
+    // Only in its own base's alt, as union_of puts it: another alt listing the same
+    // capability after + does not declare it, and neither does a union read with no base
+    // or with an object that is not its base.
+    let elsewhere = codecs::parse_element("wai1.audio.flac|audio.int_codec+audio.int_refine").unwrap();
+    assert_eq!(codecs::check_declared(&head_of(&staged("L1")), &elsewhere, Some(&objs[0])).unwrap_err().code(), "codecs_undeclared");
+    assert_eq!(codecs::check_declared(&head_of(&staged("L1")), &union, None).unwrap_err().code(), "codecs_undeclared");
+    assert_eq!(codecs::check_declared(&head_of(&staged("L1")), &union, Some(&objs[2])).unwrap_err().code(), "codecs_undeclared");
+    // Without its base in the sequence, a layer cannot be described.
+    assert_eq!(codecs::union_of(&objs[1..]).unwrap_err().code(), "codecs_layer_unbound");
+    // A layer over a WAI2 component, by the component's exploded envelope.
+    let w2 = WaiMulti::new("audio", "replicate", serde_json::Value::Null, vec![
+        Rendition::media("wai.audio.flac", "flac", Wai::from_bytes(&staged("base")).unwrap().payload).with_id("b").with_payload_digest(),
+    ]).to_bytes().unwrap();
+    let w2o = codecs::SeqObject::from_envelope(&w2).unwrap();
+    let comp = w2o.components[0].unwrap();
+    let mut l = Wai::from_bytes(&staged("L1")).unwrap();
+    let base_hex = hex(&comp);
+    l.manifest.refines = Some(serde_json::json!({ "base": base_hex, "prev": base_hex, "layer": 1 }));
+    let lo = codecs::SeqObject::from_envelope(&l.to_bytes().unwrap()).unwrap();
+    assert_eq!(codecs::render(&codecs::union_of(&[w2o, lo]).unwrap()), "wai2.audio.flac+audio.int_refine");
+}
+
+/// Item 10: a WAI1 whose capability SPEC §4 never dispatches (a record) beside a
+/// payload fallback is described by the fallback alone.
+#[test]
+fn record_capability_with_payload_fallback() {
+    let w = Wai::new(
+        crate::container::Manifest::new("text", "replicate",
+            crate::container::ModelRequirement::new("wai.video.manifest").with_fallback("wai.text.zstd"),
+            crate::container::Conditioning::new("zstd")),
+        pattern(5000, 3, 1),
+    ).to_bytes().unwrap();
+    let o = codecs::SeqObject::from_envelope(&w).unwrap();
+    assert_eq!(codecs::render(&codecs::union_of(std::slice::from_ref(&o)).unwrap()), "wai1.text.zstd");
+    let only_record = Wai::new(
+        crate::container::Manifest::new("text", "replicate", crate::container::ModelRequirement::new("wai.video.manifest"), crate::container::Conditioning::new("x")),
+        pattern(10, 3, 1),
+    ).to_bytes().unwrap();
+    assert_eq!(codecs::union_of(&[codecs::SeqObject::from_envelope(&only_record).unwrap()]).unwrap_err().code(), "codecs_not_media");
+}
+
+/// Item 9: a capability named twice, and an empty element, are malformed.
+#[test]
+fn codecs_duplicates_and_empty_elements() {
+    for bad in ["wai2.video.av1|video.av1", "wai2.video.av1+meta.hdr10plus+meta.hdr10plus", "wai2.video.av1,,mp4a.40.2", "wai2.video.av1,", ",wai2.video.av1", "", " ",
+                "waiting.for.godot", "Wai2.video.av1", "WAI2.video.av1", "wai2.video.av1+video.av1"] {
+        assert_eq!(codecs::parse(bad).unwrap_err().code(), "codecs_malformed", "{bad:?}");
+    }
+    // One companion beside two alts is no repetition.
+    assert!(codecs::parse("wai2.video.av1+meta.hdr10plus|video.vp9+meta.hdr10plus").is_ok());
+}
+
+/// The `#WAI-LAYER` line (§10.4).
+#[test]
+fn layer_tag() {
+    use super::playlist::{parse_layer_tag, LayerTag};
+    assert_eq!(parse_layer_tag("#WAI-LAYER:N=1,URI=\"objects/ab.wai#n=5,6\"").unwrap(), LayerTag { n: 1, uri: "objects/ab.wai#n=5,6".into() });
+    assert_eq!(parse_layer_tag("#WAI-LAYER:URI=\"x.wai\",N=255,X-FUTURE=ENUM").unwrap().n, 255);
+    for bad in ["#WAI-LAYER:N=0,URI=\"x\"", "#WAI-LAYER:N=256,URI=\"x\"", "#WAI-LAYER:N=1", "#WAI-LAYER:N=1,URI=x", "#WAI-LAYER:N=1,N=2,URI=\"x\"",
+                "#WAI-LAYER:N=+1,URI=\"x\"", "#WAI-LAYER:N=١,URI=\"x\"", "#WAI-LAYER:n=1,URI=\"x\"", "#WAI-LAYER:N=1,URI=\"x", "#EXT-X-PART:N=1"] {
+        assert_eq!(parse_layer_tag(bad).unwrap_err().code(), "layer_tag_malformed", "{bad}");
+    }
+}
+
+// ------------------------------------------------------------------ round 3
+
+/// A WAI1 of a payload capability with `refines` written in it.
+fn payload_with_refines(refines: serde_json::Value) -> Vec<u8> {
+    let mut w = Wai::new(
+        crate::container::Manifest::new("text", "replicate", crate::container::ModelRequirement::new("wai.text.zstd"), crate::container::Conditioning::new("zstd")),
+        pattern(5000, 3, 1),
+    );
+    w.manifest.refines = Some(refines);
+    w.to_bytes().unwrap()
+}
+
+/// N2: only a refinement-only capability makes a layer. A payload capability that
+/// carries `refines` (false, an empty object, or a well-formed one) is dispatched by
+/// SPEC §4, described as itself, and refused when a playlist lists it as a layer.
+#[test]
+fn refines_on_a_payload_capability_is_not_a_layer() {
+    let good = serde_json::json!({ "base": "1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8",
+                                   "prev": "1eb764beb4a8a739054341df8b5b7d065e490032b187a93787be15f1478080a8", "layer": 1 });
+    for r in [serde_json::json!(false), serde_json::json!({}), good] {
+        let env = payload_with_refines(r.clone());
+        assert!(!head_of(&env).is_layer(), "{r}");
+        let f = fetch(&env, Fragment::default(), sink(&["wai.text.zstd"], &[], None)).unwrap();
+        assert_eq!((f.role, f.index, f.verified_by), (Role::Base, 0, VerifiedBy::WholeObject), "{r}");
+        let served = Served::new(&env);
+        let mut s = FetchSession::new_layer(content_hash(&env), Fragment::default(), FetchPolicy::default(), sink(&[], &[], None));
+        assert_eq!(drive(&mut s, |w| served.answer(w)).unwrap_err().code(), "not_a_layer", "{r}");
+        let o = codecs::SeqObject::from_envelope(&env).unwrap();
+        assert_eq!(codecs::render(&codecs::union_of(&[o]).unwrap()), "wai1.text.zstd", "{r}");
+    }
+}
+
+/// N3 (`base-waits`): the base is ready as soon as its bytes verify, while its
+/// refinement is still held back; the refinement deadline runs from that moment on the
+/// caller's clock.
+#[test]
+fn base_ready_before_refinements() {
+    let d = base_and_enhancement(8000, 30_000, Some("right"));
+    let served = Served::new(&d);
+    let policy = FetchPolicy { refinement_deadline_ms: Some(50), ..Default::default() };
+    let mut s = FetchSession::new(content_hash(&d), Fragment { h: Some(1009), ..Default::default() }, policy,
+        sink(&["wai.video.avc"], &["wai.video.lcevc"], None));
+    let mut held = Vec::new();
+    let mut now = 1_000u64;
+    for _ in 0..6 {
+        let wants = s.wants();
+        if wants.is_empty() {
+            break;
+        }
+        for (id, w) in wants {
+            now += 7;
+            s.tick(now);
+            if w.class() == Class::Refinement {
+                held.push(id);
+                continue;
+            }
+            let (m, b) = served.answer(&w).unwrap();
+            s.on_response(id, &m, &b, now).unwrap();
+        }
+    }
+    assert!(s.result().is_none() && s.done().is_none() && !held.is_empty());
+    let base = s.base_ready().expect("the base is ready while its refinement is held back").clone();
+    assert_eq!((base.index, base.refinements.len(), base.companions.len(), base.verified_by), (0, 0, 0, VerifiedBy::HeadProof));
+    assert_eq!(base.component, pattern(8000, 7, 11));
+    let at = s.base_ready_at().unwrap();
+    assert!(s.tick(at + 49).is_empty() && s.result().is_none());
+    assert_eq!(s.tick(at + 50), held);
+    let f = s.done().unwrap();
+    assert_eq!((f.abandoned.clone(), f.companions.len()), (vec![1], 0));
+    // With no deadline the refinement is applied when it arrives, after the base.
+    let mut s = FetchSession::new(content_hash(&d), Fragment { h: Some(1009), ..Default::default() }, FetchPolicy::default(),
+        sink(&["wai.video.avc"], &["wai.video.lcevc"], None));
+    let mut base_first = false;
+    loop {
+        let wants = s.wants();
+        if wants.is_empty() {
+            break;
+        }
+        for (id, w) in wants {
+            let (m, b) = served.answer(&w).unwrap();
+            if w.class() == Class::Refinement {
+                base_first = s.base_ready().is_some() && s.done().is_none();
+            }
+            s.on_response(id, &m, &b, 0).unwrap();
+        }
+    }
+    assert!(base_first);
+    assert_eq!(s.done().unwrap().companions.len(), 1);
+}
+
+/// N4: a refinement with no `sha256` is dropped on the whole path as on the range path.
+#[test]
+fn refinement_without_digest_dropped_on_every_path() {
+    let (b, r) = (pattern(20_000, 7, 3), pattern(2000, 5, 1));
+    let mut rm = RenditionMeta::new("wai.video.int_refine", "wir1").with_role("refinement").with_id("r");
+    rm.refines = Some(serde_json::json!({ "base": "b", "prev": "b", "layer": 1 }));
+    let d = WaiMulti::from_parts(
+        crate::container::ManifestV2::new("video", "replicate", vec![RenditionMeta::new("wai.video.int_motion", "int_motion").with_id("b").with_sha256(crate::pin::sha256_hex(&b)), rm]),
+        vec![b, r],
+    ).unwrap().to_bytes().unwrap();
+    for (permille, why) in [(900u16, Some(WhyWhole::Threshold)), (1001, None)] {
+        let served = Served::new(&d);
+        let policy = FetchPolicy { full_threshold_permille: permille, ..Default::default() };
+        let mut s = FetchSession::new(content_hash(&d), Fragment { h: Some(1009), ..Default::default() }, policy,
+            sink(&["wai.video.int_motion"], &["wai.video.int_refine"], None));
+        let f = drive(&mut s, |w| served.answer(w)).unwrap();
+        assert_eq!(f.why_whole, why, "{permille}");
+        assert_eq!(f.dropped.iter().map(|(i, w)| (*i, w.code())).collect::<Vec<_>>(), vec![(1, "component_digest_absent")], "{permille}");
+        assert!(f.refinements.is_empty());
+    }
+}
+
+/// Answer every base-class request at `now` until none is left; return the refinement
+/// requests, held back.
+fn base_only(s: &mut FetchSession, served: &Served, now: u64) -> Vec<(u32, Want)> {
+    let mut held = Vec::new();
+    loop {
+        let wants = s.wants();
+        if wants.is_empty() {
+            return held;
+        }
+        for (id, w) in wants {
+            if w.class() == Class::Refinement {
+                held.push((id, w));
+                continue;
+            }
+            let (m, b) = served.answer(&w).unwrap();
+            s.on_response(id, &m, &b, now).unwrap();
+        }
+    }
+}
+
+fn avc_lcevc_session(d: &[u8], deadline: Option<u32>) -> FetchSession {
+    let policy = FetchPolicy { refinement_deadline_ms: deadline, ..Default::default() };
+    FetchSession::new(content_hash(d), Fragment { h: Some(1009), ..Default::default() }, policy,
+        sink(&["wai.video.avc"], &["wai.video.lcevc"], None))
+}
+
+/// R3-1 (`ready-then-200`): a refinement's request answered `200` with the whole object,
+/// one byte changed, adds only the range it asked for. Once the base is ready nothing
+/// changes it; before, the changed byte never reaches it either.
+#[test]
+fn a_refinement_200_never_touches_its_base() {
+    let d = base_and_enhancement(8000, 30_000, Some("right"));
+    let h = head_of(&d);
+    let (base_c, enh_c) = (h.components[0], h.components[1]);
+    let served = Served::new(&d);
+    let whole_with = |at: u64| {
+        let mut w = d.clone();
+        w[at as usize] ^= 1;
+        (ResponseMeta { status: 200, ..Default::default() }, w)
+    };
+    // After the base is ready, a byte of the base flipped: the refinement applies, the
+    // base stays as it was handed out.
+    let mut s = avc_lcevc_session(&d, None);
+    let held = base_only(&mut s, &served, 10);
+    let ready = s.base_ready().unwrap().clone();
+    let (m, b) = whole_with(base_c.start + 100);
+    s.on_response(held[0].0, &m, &b, 20).unwrap();
+    assert!(s.wants().is_empty());
+    let f = s.done().expect("the fetch ends on the head-proof path");
+    assert_eq!((f.verified_by, f.why_whole, f.companions.len(), f.dropped.len()), (VerifiedBy::HeadProof, None, 1, 0));
+    assert_eq!((f.component.clone(), s.base_ready().unwrap().component.clone()), (ready.component.clone(), ready.component));
+    // A byte of the enhancement flipped: the enhancement alone is dropped.
+    let mut s = avc_lcevc_session(&d, None);
+    let held = base_only(&mut s, &served, 10);
+    let (m, b) = whole_with(enh_c.start + 100);
+    s.on_response(held[0].0, &m, &b, 20).unwrap();
+    let f = s.done().unwrap();
+    assert_eq!((f.verified_by, f.companions.len()), (VerifiedBy::HeadProof, 0));
+    assert_eq!(f.dropped.iter().map(|(i, w)| (*i, w.code())).collect::<Vec<_>>(), vec![(1, "component_digest_mismatch")]);
+    // The refinement's 200 before the base's own response: the base still verifies from
+    // its own bytes.
+    let mut s = avc_lcevc_session(&d, None);
+    let mut base_wants = Vec::new();
+    let mut refinement = None;
+    while refinement.is_none() {
+        let wants = s.wants();
+        assert!(!wants.is_empty());
+        if wants.iter().any(|(_, w)| w.class() == Class::Refinement) {
+            for (id, w) in wants {
+                if w.class() == Class::Refinement { refinement = Some(id) } else { base_wants.push((id, w)) }
+            }
+        } else {
+            for (id, w) in wants {
+                let (m, b) = served.answer(&w).unwrap();
+                s.on_response(id, &m, &b, 1).unwrap();
+            }
+        }
+    }
+    assert!(!base_wants.is_empty(), "the base's range is still to come");
+    let (m, b) = whole_with(base_c.start + 100);
+    s.on_response(refinement.expect("a refinement request"), &m, &b, 2).unwrap();
+    assert!(s.base_ready().is_none() && s.result().is_none());
+    for (id, w) in base_wants {
+        let (m, b) = served.answer(&w).unwrap();
+        s.on_response(id, &m, &b, 3).unwrap();
+    }
+    let f = s.done().unwrap();
+    assert_eq!((f.verified_by, f.why_whole, f.companions.len(), f.component.len()), (VerifiedBy::HeadProof, None, 1, 8000));
+}
+
+/// R3-2 (`tick-clock`): the deadline runs from the response that verified the base,
+/// whatever the clock said before it: never told the time, told 0 long before, or
+/// stepped back. A clock that steps back after verification, or a start near the end
+/// of `u64`, saturates.
+#[test]
+fn the_deadline_runs_from_the_verifying_response() {
+    let d = base_and_enhancement(8000, 30_000, Some("right"));
+    let served = Served::new(&d);
+    let deadline = 2000u64;
+    let cases: [(&str, &[u64], u64); 4] = [
+        ("never ticked", &[], 1_759_680_000_000),
+        ("ticked 0, verified at 5000", &[0], 5000),
+        ("stepped back before verification", &[10_000, 5], 6),
+        ("near the end of u64", &[], u64::MAX - 10),
+    ];
+    for (label, ticks, at) in cases {
+        let mut s = avc_lcevc_session(&d, Some(deadline as u32));
+        for &t in ticks {
+            assert!(s.tick(t).is_empty(), "{label}");
+        }
+        let held = base_only(&mut s, &served, at);
+        assert_eq!(s.base_ready_at(), Some(at), "{label}");
+        let due = at.saturating_add(deadline);
+        assert!(s.tick(at).is_empty() && s.tick(due - 1).is_empty() && s.result().is_none(), "{label}");
+        if label == "ticked 0, verified at 5000" {
+            // Backwards after verification: not passed.
+            assert!(s.tick(4000).is_empty() && s.tick(0).is_empty(), "{label}");
+        }
+        assert_eq!(s.tick(due), held.iter().map(|(id, _)| *id).collect::<Vec<_>>(), "{label}");
+        assert_eq!(s.done().unwrap().abandoned, vec![1], "{label}");
+    }
+}
diff --git a/wai/wai-rs/src/lib.rs b/wai/wai-rs/src/lib.rs
index b52d96750..2fae3496b 100644
--- a/wai/wai-rs/src/lib.rs
+++ b/wai/wai-rs/src/lib.rs
@@ -331,6 +331,10 @@ mod container_explode;
 // WIR1, its predictors, the per-unit application algorithm and the live schedule.
 #[cfg(feature = "staged")]
 pub mod staged;
+// HTTP delivery (extensions/http-delivery.md): the head proof, verified component range
+// fetch, the codecs union and floor, and an origin's responses.
+#[cfg(feature = "http")]
+pub mod http_binding;
 
 // Staged-delivery measurement (extensions/staged-measurement.md): the output tree
 // (Appendix C), the counted bytes of an envelope (§3), and the evaluation of a staged
diff --git a/wai/wai-rs/tests/cli_http.rs b/wai/wai-rs/tests/cli_http.rs
new file mode 100644
index 000000000..ababcbebf
--- /dev/null
+++ b/wai/wai-rs/tests/cli_http.rs
@@ -0,0 +1,420 @@
+//! The `wai http` commands run as a user runs them (`--features http --test cli_http`):
+//!
+//! - `wai http publish` writes `<cid>.wai`, its head proof and its ETag sidecar, named by
+//!   the content hash, and refuses an envelope with a byte after it (§5.1);
+//! - `wai http codecs` prints a sequence's union and floor (§4.2);
+//! - `wai http origin` serves an object with §5.3's headers, byte ranges and `If-Range`,
+//!   and `wai http bench` fetches it through the byte-range procedure (§7) and writes a
+//!   record with the pick, the bytes by category and energy stated as not measured;
+//! - the origin reads at most 16 KiB of a request head, gives a whole head one deadline
+//!   from the accept and a whole connection one lifetime, caps the connections it serves
+//!   at once (and those of one peer only when asked), percent-decodes `/__hits` as bytes,
+//!   and refuses a path segment with `\`, `:`, NUL or a control byte. Every origin a test
+//!   starts is stopped when the test ends, whether or not it passed.
+
+use std::io::{BufRead, BufReader, Read, Write};
+use std::net::TcpStream;
+use std::path::{Path, PathBuf};
+use std::process::{Command, Output, Stdio};
+
+use wai::http_binding::head_proof::HeadProof;
+use wai::http_binding::{content_hash, hex};
+
+fn wai(args: &[&str]) -> Output {
+    Command::new(env!("CARGO_BIN_EXE_wai")).args(args).output().expect("run wai")
+}
+
+fn corpus() -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR")).join("../http-conformance")
+}
+
+fn object(id: &str) -> PathBuf {
+    let listing: serde_json::Value = serde_json::from_slice(&std::fs::read(corpus().join("objects.json")).unwrap()).unwrap();
+    corpus().join(listing[id]["path"].as_str().unwrap())
+}
+
+fn scratch(name: &str) -> PathBuf {
+    let d = Path::new(env!("CARGO_TARGET_TMPDIR")).join("cli_http").join(name);
+    let _ = std::fs::remove_dir_all(&d);
+    std::fs::create_dir_all(&d).unwrap();
+    d
+}
+
+#[test]
+fn publish_names_by_content_hash() {
+    let out = scratch("publish");
+    let src = object("O3");
+    let run = wai(&["http", "publish", src.to_str().unwrap(), "--out", out.to_str().unwrap()]);
+    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
+    let env = std::fs::read(&src).unwrap();
+    let cid = hex(&content_hash(&env));
+    assert_eq!(std::fs::read(out.join(format!("{cid}.wai"))).unwrap(), env);
+    assert_eq!(std::fs::read(out.join(format!("{cid}.wai.hp"))).unwrap(), HeadProof::build(&env).unwrap().to_bytes());
+    assert_eq!(std::fs::read_to_string(out.join(format!("{cid}.wai.etag"))).unwrap(), format!("\"{cid}\"\n"));
+    let line = String::from_utf8_lossy(&run.stdout);
+    assert!(line.starts_with(&cid) && line.contains(&format!("n={}", env.len())) && line.contains("wai2.video.av1+meta.hdr10plus"), "{line}");
+    // One byte after the envelope: not an object.
+    let bad = corpus().join("bad/O6.wai");
+    let run = wai(&["http", "publish", bad.to_str().unwrap(), "--out", out.to_str().unwrap()]);
+    assert!(!run.status.success());
+    assert!(String::from_utf8_lossy(&run.stderr).contains("object_length_mismatch"));
+}
+
+#[test]
+fn codecs_prints_union_and_floor() {
+    let run = wai(&["http", "codecs", object("O9a").to_str().unwrap(), object("O9b").to_str().unwrap(), object("O9c").to_str().unwrap()]);
+    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
+    assert_eq!(String::from_utf8_lossy(&run.stdout), "union\twai2.video.av1|video.int_hyper\nfloor\twai2.video.av1\n");
+}
+
+/// A running `wai http origin`, stopped when dropped, so a failing assertion never leaves
+/// it running.
+struct Origin {
+    child: std::process::Child,
+    port: u16,
+}
+
+impl Origin {
+    fn start(root: &Path, extra: &[&str]) -> Origin {
+        let mut child = Command::new(env!("CARGO_BIN_EXE_wai"))
+            .args(["http", "origin", "--root", root.to_str().unwrap(), "--port", "0"])
+            .args(extra)
+            .stdout(Stdio::piped())
+            .spawn()
+            .unwrap();
+        let mut first = String::new();
+        BufReader::new(child.stdout.take().unwrap()).read_line(&mut first).unwrap();
+        let port: u16 = first.trim().rsplit(':').next().unwrap().trim_end_matches('/').parse().unwrap();
+        Origin { child, port }
+    }
+}
+
+impl Drop for Origin {
+    fn drop(&mut self) {
+        let _ = self.child.kill();
+        let _ = self.child.wait();
+    }
+}
+
+/// Send raw request bytes; return what the origin answered before closing.
+fn raw(port: u16, request: &[u8]) -> String {
+    let mut s = TcpStream::connect(("127.0.0.1", port)).unwrap();
+    s.set_read_timeout(Some(std::time::Duration::from_secs(10))).unwrap();
+    s.write_all(request).unwrap();
+    let mut out = Vec::new();
+    let _ = s.read_to_end(&mut out);
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+/// One request to the origin: status line and headers, and the body.
+fn get(port: u16, path: &str, extra: &[(&str, &str)]) -> (String, Vec<u8>) {
+    let mut s = TcpStream::connect(("127.0.0.1", port)).unwrap();
+    let mut req = format!("GET {path} HTTP/1.1\r\nHost: 127.0.0.1\r\nConnection: close\r\n");
+    for (k, v) in extra {
+        req.push_str(&format!("{k}: {v}\r\n"));
+    }
+    req.push_str("\r\n");
+    s.write_all(req.as_bytes()).unwrap();
+    let mut raw = Vec::new();
+    s.read_to_end(&mut raw).unwrap();
+    let end = raw.windows(4).position(|w| w == b"\r\n\r\n").unwrap() + 4;
+    (String::from_utf8_lossy(&raw[..end]).into_owned(), raw[end..].to_vec())
+}
+
+#[test]
+fn origin_serves_and_bench_fetches() {
+    let root = scratch("origin");
+    let src = object("OD");
+    let env = std::fs::read(&src).unwrap();
+    let pubd = wai(&["http", "publish", src.to_str().unwrap(), "--out", root.to_str().unwrap()]);
+    assert!(pubd.status.success());
+    let cid = hex(&content_hash(&env));
+    let origin = Origin::start(&root, &[]);
+    let port = origin.port;
+    let path = format!("/{cid}.wai");
+
+    let (h, body) = get(port, &path, &[]);
+    assert!(h.starts_with("HTTP/1.1 200") && body == env, "{h}");
+    for want in ["Cache-Control: public, max-age=31536000, immutable, no-transform", &format!("ETag: \"{cid}\""), "Accept-Ranges: bytes", "Access-Control-Allow-Origin: *"] {
+        assert!(h.contains(want), "{want} missing from {h}");
+    }
+    assert!(!h.contains("Vary") && !h.contains("Content-Encoding"), "{h}");
+    let (h, body) = get(port, &path, &[("Range", "bytes=1009-3593")]);
+    assert!(h.starts_with("HTTP/1.1 206") && h.contains("Content-Range: bytes 1009-3593/53794") && body == env[1009..3594], "{h}");
+    let (h, _) = get(port, &path, &[("Range", "bytes=1009-3593"), ("If-Range", "\"not-this\"")]);
+    assert!(h.starts_with("HTTP/1.1 200"), "{h}");
+    let (h, _) = get(port, &path, &[("Range", "bytes=53794-")]);
+    assert!(h.starts_with("HTTP/1.1 416") && h.contains("Content-Range: bytes */53794"), "{h}");
+
+    let rec = root.join("bench.json");
+    let url = format!("http://127.0.0.1:{port}{path}#h=1009&n=53794");
+    let run = wai(&["http", "bench", "--url", &url, "--runs", "3", "--advertise", "wai.video.av1", "--out", rec.to_str().unwrap()]);
+    drop(origin);
+    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
+    let r: serde_json::Value = serde_json::from_slice(&std::fs::read(&rec).unwrap()).unwrap();
+    // Appendix D's plan 1: the head, the proof and `low`'s rest.
+    assert_eq!(r["pick"], 0);
+    assert_eq!(r["body_bytes_media"]["median"], 1009.0 + 2585.0);
+    assert_eq!(r["body_bytes_proof"]["median"], 245.0);
+    assert_eq!(r["requests"], 3);
+    assert_eq!(r["energy"], "omitted: not measured");
+    assert_eq!(r["envelope_len"], 53_794);
+}
+
+
+/// The origin reads at most 16 KiB of a request head: a 400 MiB header is answered 431
+/// and the connection closed long before it is sent.
+#[test]
+fn origin_refuses_an_oversized_head() {
+    let root = scratch("origin-big");
+    std::fs::write(root.join("x.json"), b"{}").unwrap();
+    let origin = Origin::start(&root, &[]);
+    let mut s = TcpStream::connect(("127.0.0.1", origin.port)).unwrap();
+    s.set_read_timeout(Some(std::time::Duration::from_secs(20))).unwrap();
+    let mut w = s.try_clone().unwrap();
+    let t0 = std::time::Instant::now();
+    let writer = std::thread::spawn(move || {
+        let _ = w.write_all(b"GET /x.json HTTP/1.1\r\nHost: a\r\nX-Fill: ");
+        let chunk = vec![b'a'; 1 << 20];
+        let mut sent = 0usize;
+        while sent < 400 << 20 {
+            if w.write_all(&chunk).is_err() {
+                break;
+            }
+            sent += chunk.len();
+        }
+        sent
+    });
+    let mut head = [0u8; 64];
+    let n = s.read(&mut head).unwrap_or(0);
+    let answer = String::from_utf8_lossy(&head[..n]).into_owned();
+    drop(s);
+    let sent = writer.join().unwrap();
+    assert!(answer.starts_with("HTTP/1.1 431"), "{answer:?}");
+    assert!(sent < 400 << 20, "the origin read the whole 400 MiB");
+    assert!(t0.elapsed() < std::time::Duration::from_secs(30));
+    // And it still serves.
+    assert!(raw(origin.port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n").starts_with("HTTP/1.1 200"));
+}
+
+/// `/__hits?path=` is percent-decoded as bytes: an escape before a non-ASCII character, or
+/// an invalid UTF-8 sequence, is answered, not a panic.
+#[test]
+fn origin_decodes_hits_as_bytes() {
+    let root = scratch("origin-hits");
+    std::fs::write(root.join("x.json"), b"{}").unwrap();
+    let origin = Origin::start(&root, &["--count-hits"]);
+    for q in ["%aé", "%ff%fe", "%", "%4", "%e9%"] {
+        let r = raw(origin.port, format!("GET /__hits?path={q} HTTP/1.1\r\nHost: a\r\n\r\n").as_bytes());
+        assert!(r.starts_with("HTTP/1.1 200"), "{q}: {r:?}");
+    }
+    let _ = raw(origin.port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n");
+    let r = raw(origin.port, b"GET /__hits?path=%2Fx.json HTTP/1.1\r\nHost: a\r\n\r\n");
+    assert!(r.ends_with("\r\n\r\n1"), "{r:?}");
+}
+
+/// A path segment holding `\`, `:`, NUL or a control byte, or `.`/`..`, names nothing:
+/// 400.
+#[test]
+fn origin_refuses_backslash_drive_and_nul_paths() {
+    let root = scratch("origin-paths");
+    std::fs::write(root.join("x.json"), b"{}").unwrap();
+    let origin = Origin::start(&root, &[]);
+    for path in [&b"/..\\..\\etc\\passwd"[..], b"/C:/Windows/win.ini", b"/x.json:stream", b"/a\x00b", b"/a\x01b", b"/./x.json", b"/../x.json", b"//x.json", b"/x.json/"] {
+        let mut req = b"GET ".to_vec();
+        req.extend_from_slice(path);
+        req.extend_from_slice(b" HTTP/1.1\r\nHost: a\r\n\r\n");
+        let r = raw(origin.port, &req);
+        assert!(r.starts_with("HTTP/1.1 400"), "{}: {r:?}", String::from_utf8_lossy(path));
+    }
+    assert!(raw(origin.port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n").starts_with("HTTP/1.1 200"));
+}
+
+/// At most `--max-connections` at once (one more is answered 503), and a connection that
+/// sends nothing is answered 408 and closed `--read-timeout-ms` after its accept.
+#[test]
+fn origin_caps_connections_and_times_out() {
+    let root = scratch("origin-cap");
+    std::fs::write(root.join("x.json"), b"{}").unwrap();
+    let origin = Origin::start(&root, &["--max-connections", "2", "--read-timeout-ms", "700"]);
+    let idle: Vec<TcpStream> = (0..2).map(|_| TcpStream::connect(("127.0.0.1", origin.port)).unwrap()).collect();
+    std::thread::sleep(std::time::Duration::from_millis(200));
+    let r = raw(origin.port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n");
+    assert!(r.starts_with("HTTP/1.1 503"), "{r:?}");
+    let t0 = std::time::Instant::now();
+    for mut c in idle {
+        // Told 408, and closed.
+        c.set_read_timeout(Some(std::time::Duration::from_secs(10))).unwrap();
+        let mut out = Vec::new();
+        let _ = c.read_to_end(&mut out);
+        assert!(out.starts_with(b"HTTP/1.1 408"), "{:?}", String::from_utf8_lossy(&out));
+    }
+    assert!(t0.elapsed() < std::time::Duration::from_secs(5));
+    assert!(raw(origin.port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n").starts_with("HTTP/1.1 200"));
+}
+
+/// N1: a whole request head has one deadline from the accept, so connections that send a
+/// byte at a time cannot hold the connection cap: a GET succeeds within about one head
+/// deadline while they keep trickling.
+#[test]
+fn origin_survives_trickling_heads() {
+    let root = scratch("origin-trickle");
+    std::fs::write(root.join("x.json"), b"{}").unwrap();
+    let origin = Origin::start(&root, &["--max-connections", "4", "--read-timeout-ms", "1000"]);
+    let port = origin.port;
+    let stop = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let tricklers: Vec<_> = (0..4).map(|_| {
+        let stop = stop.clone();
+        std::thread::spawn(move || {
+            let mut s = TcpStream::connect(("127.0.0.1", port)).unwrap();
+            let mut sent = 0;
+            // One byte every 100 ms, never ending the head, until the origin closes.
+            for b in b"GET /x.json HTTP/1.1\r\nX-Slow: ".iter().chain(std::iter::repeat(&b'a')) {
+                if stop.load(std::sync::atomic::Ordering::SeqCst) || s.write_all(&[*b]).is_err() {
+                    break;
+                }
+                sent += 1;
+                std::thread::sleep(std::time::Duration::from_millis(100));
+            }
+            sent
+        })
+    }).collect();
+    std::thread::sleep(std::time::Duration::from_millis(200));
+    let t0 = std::time::Instant::now();
+    let mut answer = String::new();
+    while t0.elapsed() < std::time::Duration::from_secs(5) {
+        answer = raw(port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n");
+        if answer.starts_with("HTTP/1.1 200") {
+            break;
+        }
+        std::thread::sleep(std::time::Duration::from_millis(50));
+    }
+    let waited = t0.elapsed();
+    stop.store(true, std::sync::atomic::Ordering::SeqCst);
+    for t in tricklers {
+        t.join().unwrap();
+    }
+    assert!(answer.starts_with("HTTP/1.1 200"), "{answer:?}");
+    assert!(waited < std::time::Duration::from_millis(2500), "the GET waited {waited:?}");
+}
+
+/// R3-3: with its defaults (no cap per peer), eight connections that trickle a head and
+/// reconnect the moment they are closed never shut a legitimate GET out: on a loopback
+/// listener every client has their address.
+#[test]
+fn origin_serves_past_reconnecting_tricklers() {
+    let root = scratch("origin-reconnect");
+    std::fs::write(root.join("x.json"), b"{}").unwrap();
+    let origin = Origin::start(&root, &["--read-timeout-ms", "1000"]);
+    let port = origin.port;
+    let stop = std::sync::Arc::new(std::sync::atomic::AtomicBool::new(false));
+    let tricklers: Vec<_> = (0..8).map(|_| {
+        let stop = stop.clone();
+        std::thread::spawn(move || {
+            while !stop.load(std::sync::atomic::Ordering::SeqCst) {
+                let Ok(mut s) = TcpStream::connect(("127.0.0.1", port)) else { continue };
+                for b in b"GET /x.json HTTP/1.1\r\nX-Slow: ".iter().chain(std::iter::repeat(&b'a')) {
+                    if stop.load(std::sync::atomic::Ordering::SeqCst) || s.write_all(&[*b]).is_err() {
+                        break;
+                    }
+                    std::thread::sleep(std::time::Duration::from_millis(50));
+                }
+            }
+        })
+    }).collect();
+    std::thread::sleep(std::time::Duration::from_millis(300));
+    let t0 = std::time::Instant::now();
+    let mut answers = Vec::new();
+    while t0.elapsed() < std::time::Duration::from_secs(3) {
+        answers.push(raw(port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n").lines().next().unwrap_or("").to_string());
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+    stop.store(true, std::sync::atomic::Ordering::SeqCst);
+    for t in tricklers {
+        t.join().unwrap();
+    }
+    assert!(answers.len() >= 10 && answers.iter().all(|a| a.starts_with("HTTP/1.1 200")), "{answers:?}");
+}
+
+/// R3-3: a connection lives at most `--max-connection-ms` from its accept, so a peer that
+/// reads a large response slowly is cut off then, not served for as long as it keeps
+/// reading.
+#[test]
+fn origin_cuts_a_slow_reader_at_the_lifetime() {
+    let root = scratch("origin-slow-reader");
+    let size = 32usize << 20;
+    std::fs::write(root.join("big.bin"), vec![7u8; size]).unwrap();
+    let origin = Origin::start(&root, &["--max-connection-ms", "1500"]);
+    let mut s = TcpStream::connect(("127.0.0.1", origin.port)).unwrap();
+    s.write_all(b"GET /big.bin HTTP/1.1\r\nHost: a\r\n\r\n").unwrap();
+    s.set_read_timeout(Some(std::time::Duration::from_secs(10))).unwrap();
+    let (t0, mut got, mut buf) = (std::time::Instant::now(), Vec::new(), [0u8; 4096]);
+    // Slowly, past the lifetime: 4 KiB every 100 ms.
+    while t0.elapsed() < std::time::Duration::from_millis(2500) {
+        match s.read(&mut buf) {
+            Ok(0) | Err(_) => break,
+            Ok(n) => got.extend_from_slice(&buf[..n]),
+        }
+        std::thread::sleep(std::time::Duration::from_millis(100));
+    }
+    // Then as fast as it comes: what was already sent, and the end of the connection.
+    let ended = loop {
+        match s.read(&mut buf) {
+            Ok(0) => break true,
+            Ok(n) => got.extend_from_slice(&buf[..n]),
+            Err(e) if matches!(e.kind(), std::io::ErrorKind::WouldBlock | std::io::ErrorKind::TimedOut) => break false,
+            Err(_) => break true,
+        }
+    };
+    assert!(got.starts_with(b"HTTP/1.1 200"), "{:?}", String::from_utf8_lossy(&got[..got.len().min(64)]));
+    assert!(ended, "the connection was still open");
+    assert!(got.len() < size, "the whole response arrived: the connection outlived its lifetime");
+}
+
+/// N1: at most `--max-per-peer` connections from one address, when it is given; one more
+/// is answered 503.
+#[test]
+fn origin_per_peer_limit() {
+    let root = scratch("origin-peer");
+    std::fs::write(root.join("x.json"), b"{}").unwrap();
+    let origin = Origin::start(&root, &["--max-per-peer", "2", "--read-timeout-ms", "2000"]);
+    let idle: Vec<TcpStream> = (0..2).map(|_| TcpStream::connect(("127.0.0.1", origin.port)).unwrap()).collect();
+    std::thread::sleep(std::time::Duration::from_millis(200));
+    let r = raw(origin.port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n");
+    assert!(r.starts_with("HTTP/1.1 503"), "{r:?}");
+    drop(idle);
+    std::thread::sleep(std::time::Duration::from_millis(200));
+    assert!(raw(origin.port, b"GET /x.json HTTP/1.1\r\nHost: a\r\n\r\n").starts_with("HTTP/1.1 200"));
+}
+
+/// N3: `wai http bench` times the base from the session's `base_ready`: with the origin
+/// holding the enhancement's bytes back, the base's time does not include the delay, and
+/// the time to complete does.
+#[test]
+fn bench_times_the_base_apart_from_its_refinement() {
+    use wai::http_binding::head::{parse_head, HeadParse};
+    let root = scratch("bench-delay");
+    let src = object("O8");
+    let env = std::fs::read(&src).unwrap();
+    assert!(wai(&["http", "publish", src.to_str().unwrap(), "--out", root.to_str().unwrap()]).status.success());
+    let HeadParse::Head(h) = parse_head(&env, env.len() as u64).unwrap() else { panic!("a head") };
+    let enh = h.components[1];
+    let delay = format!("{}-{}:1500", enh.start, enh.start + enh.len - 1);
+    let origin = Origin::start(&root, &["--delay-range", &delay]);
+    let rec = root.join("bench.json");
+    let url = format!("http://127.0.0.1:{}/{}.wai#h={}&n={}", origin.port, hex(&content_hash(&env)), h.covered_len(), env.len());
+    let run = wai(&["http", "bench", "--url", &url, "--runs", "2", "--advertise", "wai.video.avc", "--out", rec.to_str().unwrap()]);
+    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
+    let r: serde_json::Value = serde_json::from_slice(&std::fs::read(&rec).unwrap()).unwrap();
+    let base = r["ms_to_verified"]["median"].as_f64().unwrap();
+    let all = r["ms_to_complete"]["median"].as_f64().unwrap();
+    assert!(base < 1000.0, "the base's time includes the enhancement's delay: {base} ms");
+    assert!(all >= 1500.0, "the enhancement was not delayed: {all} ms");
+    // With a refinement deadline shorter than the delay, the enhancement is abandoned.
+    let run = wai(&["http", "bench", "--url", &url, "--runs", "1", "--advertise", "wai.video.avc", "--refinement-deadline-ms", "1", "--out", rec.to_str().unwrap()]);
+    assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
+    let r: serde_json::Value = serde_json::from_slice(&std::fs::read(&rec).unwrap()).unwrap();
+    assert_eq!(r["refinements_abandoned"], serde_json::json!([1]));
+    assert!(r["ms_to_complete"]["median"].as_f64().unwrap() < 1000.0);
+    drop(origin);
+}
diff --git a/wai/wai-rs/tests/int_kernels_vectors.rs b/wai/wai-rs/tests/int_kernels_vectors.rs
index 58e8176cc..a7bf108ab 100644
--- a/wai/wai-rs/tests/int_kernels_vectors.rs
+++ b/wai/wai-rs/tests/int_kernels_vectors.rs
@@ -222,6 +222,8 @@ fn every_decoded_output_states_a_sha256() {
         ("pack-conformance", "encode/expected.json states the SHA-256 of every decoded frame (RGB8); the rest are policies, refusals, conversions and scene cuts, with no decoded output"),
         ("pin-conformance", "parameter-set pins: every digest there is a SHA-256 of a parameter set"),
         ("signer-conformance", "key logs, grants and statuses: signed documents, no decoded output"),
+        ("http-conformance", "objects and head proofs for transport: no case decodes a payload, and the component a fetch case picks is stated by its SHA-256"),
+        ("cache-conformance", "cache rules: a driver, its controls and their reports, with no objects of its own"),
         ("byte-exact-conformance", "goldens over tests/vectors, whose sidecars state the SHA-256"),
         ("int-payload-conformance", "refusal fixtures and the index of the payloads under tests/vectors, whose sidecars state the SHA-256"),
         ("staged-conformance", "each case.json states the SHA-256 of every stage-0 buffer and of every unit's stage (SPEC §7 Digests)"),