open-standards/.github/workflows/wai-conformance.yml

name: WAI conformance

# WAI's load-bearing claim is bit-exact reconstruction on every machine,
# no tolerance parameter. This workflow enforces it mechanically: every
# cargo-class corpus — and the integer-exact neural decoders, which make the
# same promise (the registry's NeuralIntegerExact class: i64-only, no float
# ONNX) — is re-derived on every OS/arch leg of the matrix below (x86-64 and
# arm64) and must reproduce its frozen BLAKE3 hashes; and the integer
# byte-equality goldens (rANS / int_synth / JPEG-AI mANS, generated once on
# a reference machine) must decode identically everywhere. All of it is pure
# Rust (no C codec chain, no ONNX Runtime), so the matrix needs no system
# dependencies.

# One run per branch at a time. A push supersedes the run before it.
#
# There is one `macos` runner and it is the dev Mac, so every macOS job in this
# repo queues on it. With no concurrency group, a session pushing four versions
# of a branch queued four complete sets of runs and every one of them had to
# drain: on 2026-10-05 a PR's 21 contexts settled none in 70 minutes behind a
# backlog of 25 runs, and the queue grew faster than it cleared. Only the newest
# commit's verdict is wanted, so the older runs are cancelled.
#
# Verified on this forge (Forgejo 16.0.5) in `ci-test` before being added here:
# the key parses, and a newer push moves an older run to `cancelled` even while
# it is still queued, which is the case that matters.
#
# `cancel-in-progress: true` also applies to `main`. That is deliberate and
# safe here: main advances by merge commits whose tree contains the commits
# before them, so the newer run covers the older one's changes.
concurrency:
  group: ${{ github.workflow }}-${{ github.ref }}
  cancel-in-progress: true

on:
  pull_request:
    paths:
      - 'wai/wai-rs/**'
      # wai-rs path-depends on wai-quantum, and the quantum corpora below are
      # verified through it: a change there changes what this workflow checks.
      - 'wai/wai-quantum/**'
      # The integer decoders that decode through the integer operator set depend on it.
      - 'wai/wai-ops/**'
      - 'wai/*-conformance/**'
      - 'wai/byte-exact-conformance/**'
      # The registry export and the two library tests that read files outside
      # wai-rs (the codec glossary, SPEC.md) must fire this workflow too: a
      # hand edit of an exported file, of SPEC §5 or of the glossary is checked
      # here. vocab/v1's and v2's pin terms are checked by a library test.
      - 'wai/registry/**'
      - 'wai/vocab/**'
      - 'wai/glossary/**'
      - 'wai/SPEC.md'
      - 'wai/REGISTRY.md'
      # A library test checks SPEC §5's pinned integer payloads against this
      # extension's sections, so an edit of it is checked here too.
      - 'wai/extensions/integer-payloads.md'
      # 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, and
      # staged::moq::tests::moq_streaming_format_lists_the_codes checks §4.1's codes.
      - 'wai/extensions/http-delivery.md'
      - 'wai/extensions/moq-streaming-format.md'
      - 'wai/extensions/jwp-receipts.md'
      # The quantum referee requires this extension's Appendix B to state its phase tables.
      - 'wai/extensions/quantum-sim.md'
      # tests/live_events.rs requires this extension's §9 to list the codes the reference
      # reports, and the registry's wire identifiers test reads its sections.
      - 'wai/extensions/live-events.md'
      # tests/live_room.rs requires this extension's §11 to list the codes the reference
      # reports, and the registry's wire identifiers test reads its sections.
      - 'wai/extensions/live-rooms.md'
      # tests/capture_take.rs requires this extension's §12 to list the codes the reference
      # reports, and the registry's wire identifiers test reads its sections.
      - 'wai/extensions/capture-binding.md'
      # tests/live_compose.rs requires this extension's §10 to list the codes the reference
      # reports, and the registry's wire identifiers test reads its sections.
      - 'wai/extensions/live-compose.md'
      # tests/live_record.rs requires this extension's §9 to list the codes the reference
      # reports, and the registry's wire identifiers test reads its sections.
      - 'wai/extensions/live-recording.md'
      # tests/timed_text.rs requires this extension's §12 to list the codes the reference
      # reports, and the registry's wire identifiers test reads its sections.
      - 'wai/extensions/timed-text.md'
      # tests/access_services.rs requires this extension's §10 to list the codes the reference
      # reports, access_services_verify.py reads that table, and the registry's wire
      # identifiers test reads its sections.
      - 'wai/extensions/access-services.md'
      # tests/live_metering.rs requires this extension's §9 to list the codes the reference
      # reports, live_metering_verify.py reads that table, and the registry's wire identifiers
      # test reads its sections.
      - 'wai/extensions/live-metering.md'
      # tests/energy_steering.rs requires this extension's §10 to list the codes the reference
      # reports, energy_steering_verify.py reads that table, and the registry's wire
      # identifiers test reads its sections.
      - 'wai/extensions/energy-steering.md'
      # tests/live_moderation.rs requires this extension's §10 to list the codes the reference
      # reports, live_moderation_verify.py reads its §9.5, §9.6 and §10 tables, and the
      # registry's wire identifiers test reads its sections.
      - 'wai/extensions/live-moderation.md'
      # tests/live_watermark.rs requires this extension's §11 to list the codes the reference
      # reports, live_watermark_verify.py reads that table, and the registry's wire identifiers
      # test reads its sections.
      - 'wai/extensions/forensic-watermark.md'
      # e2ee_verify.py reads this extension's §13 table, and the registry's wire identifiers
      # test reads its sections.
      - 'wai/extensions/confidentiality.md'
      # tests/live_ads.rs requires this extension's §10 to list the codes the reference
      # reports, live_ads_verify.py reads that table, and the registry's wire identifiers test
      # reads its sections.
      - 'wai/extensions/live-ads.md'
      # tests/ad_presentation.rs requires this extension's §11 to list the codes the reference
      # reports, ad_presentation_verify.py reads that table, and the registry's wire identifiers
      # test reads its sections.
      - 'wai/extensions/ad-presentation.md'
      # The ad-presentation step runs the browser client's reference producer against the
      # corpus.
      - 'joule-code/joule-code-rs/crates/joule-moq-web/web/ads/**'
      # tests/live_provenance.rs requires this extension's §12 to list the codes and the C2PA
      # codes the reference reports, c2pa_live_verify.py reads that table, and the registry's
      # wire identifiers test reads its sections.
      - 'wai/extensions/live-provenance.md'
      # tests/derive_edge.rs requires this extension's §9 to list the codes the reference
      # reports and its §4 the derivations, edge_verify.py reads both tables, and the
      # registry's wire identifiers test reads its sections.
      - 'wai/extensions/deriving-edge.md'
      # tests/synthesis.rs requires this extension's §12 to list the codes the reference
      # reports and its §10.2 table to pin the reference's icons, synthesis_verify.py reads
      # both, tests/synthesis_mark.rs and synthesis_mark_verify.py read its scheme's
      # definition, generator, figures, table and claims (§7.4 to §7.5.8), and the registry's
      # wire identifiers test reads its sections.
      - 'wai/extensions/synthesis.md'
      # tests/exact_upscale.rs requires this extension's §8 to list the codes the reference
      # reports, upscale_verify.py reads that table, and the registry's wire identifiers test
      # reads its sections.
      - 'wai/extensions/exact-upscale.md'
      # tests/ai_usage.rs requires this extension's §9 to list the codes the reference reports,
      # ai_usage_verify.py reads that table, and the registry's wire identifiers test reads its
      # sections.
      - 'wai/extensions/ai-usage.md'
      # tests/contribution.rs requires this extension's §11 to list the codes the reference
      # reports, contribution_verify.py reads that table, and the registry's wire identifiers
      # test reads its sections.
      - 'wai/extensions/contribution.md'
      # tests/settlement.rs requires this extension's §11 to list the codes the reference
      # reports, settlement_verify.py reads that table, and the registry's wire identifiers test
      # reads its sections.
      - 'wai/extensions/settlement.md'
      # tests/browser_sink.rs requires this extension's §11 to list the codes the reference
      # reports, browser_sink_verify.py reads its §2, §4.1, §4.2 and §11 tables and
      # capability-constraints' §3.1 register, and the registry's wire identifiers test reads
      # its sections.
      - 'wai/extensions/browser-sink.md'
      - 'wai/extensions/capability-constraints.md'
      # The browser sink's functions for a page, held to the same corpus natively.
      - 'wai/wai-live-web/**'
      # tests/takedown.rs requires this extension's §11 to list the codes the reference
      # reports, takedown_verify.py reads that table, and the registry's wire identifiers test
      # reads its sections. The registry of clocks it reads is under wai/registry/ above.
      - 'wai/extensions/takedown.md'
      # tests/co_performance.rs requires this extension's §10 to list the codes the reference
      # reports, co_performance_verify.py reads that table, and the registry's wire identifiers
      # test reads its sections.
      - 'wai/extensions/co-performance.md'
      # tests/age_assurance.rs requires this extension's §11 to list the codes the reference
      # reports, age_assurance_verify.py reads that table, and the registry's wire identifiers
      # test reads its sections.
      - 'wai/extensions/age-assurance.md'
      # tests/influence.rs requires this extension's §9 to list the codes the reference adds,
      # influence_verify.py reads that table, and the registry's wire identifiers test reads its
      # sections.
      - 'wai/extensions/influence.md'
      # tests/direction.rs requires this extension's §13 to list the codes the reference reports,
      # direction_verify.py reads that table, and the registry's wire identifiers test reads its
      # sections.
      - 'wai/extensions/direction.md'
      # tests/bearer_receipts.rs requires this extension's §10 to list the codes the reference
      # reports, and bearer_verify.py reads that table.
      - 'wai/extensions/bearer-receipts.md'
      # tests/exploration.rs requires this extension's §13 to list the codes the reference
      # reports and its §3.2 table to name the reference's descriptors, exploration_verify.py
      # reads §13, and the registry's wire identifiers test reads its sections.
      - 'wai/extensions/exploration.md'
      - 'wai/wai-web/**'
      # The audio provenance check below reads the corpora above with this tool.
      - 'wai/tools/wai_audio_provenance_check.py'
      - '.github/workflows/wai-conformance.yml'

# No global `shell:` default. The Windows runner is a host executor whose
# `bash` is the WSL stub (a different OS), so shell-specific steps below pick
# their shell per-OS: bash on unix, pwsh on Windows. Bare `cargo …` steps take
# each runner's native default, which runs cargo identically either way. The
# Windows legs are out of the matrices for now (see the comment on each matrix);
# their pwsh steps stay, inactive, so restoring a leg is a one-line change.
  schedule:
    - cron: '20 5 * * *'

jobs:
  # Does this pull request's own diff touch the paths below? This forge matches a
  # workflow's `paths:` against the push, so a merge of main into a branch fires the
  # workflow whatever the pull request changes; every job here waits on this answer.
  # A push to main, a schedule, or anything the script cannot determine answers
  # `true` (scripts/pr-touches-paths.py).
  relevant:
    name: does this change touch it
    runs-on: linux-arm64
    outputs:
      run: ${{ steps.gate.outputs.run }}
    steps:
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
      - id: gate
        run: |
          set -euo pipefail
          r=$(python3 scripts/pr-touches-paths.py .github/workflows/wai-conformance.yml \
                "${{ github.event.pull_request.base.sha }}" \
                "${{ github.event.pull_request.head.sha }}")
          echo "this change touches wai-conformance: $r"
          echo "run=$r" >> "$GITHUB_OUTPUT"

  cargo-classes:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: cargo-class corpora · ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        # Self-hosted fleet labels. Both architectures: x86_64 by linux, arm64
        # by linux-arm64 + macos — what matters for the Fx integer floor is the
        # arch, not the OS. No Intel-Mac runner exists in the fleet, and it
        # would add no arch coverage anyway.
        # Windows x86_64 leg removed 2026-09-30: runner offline. Restore by
        # re-adding `windows` here once the runner is back online.
        os: [linux, linux-arm64, macos]
    steps:
      - uses: actions/checkout@v5

      # unix: the docker runners (linux / linux-arm64) ship no Rust, so rustup
      # is bootstrapped; the macOS `host` runner has it but launchd's PATH omits
      # ~/.cargo/bin. dtolnay/rust-toolchain is unusable — it calls a `rustup`
      # the docker image lacks.
      - name: Install Rust 1.98.0 (unix)
        if: matrix.os != 'windows'
        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
          rustup component add --toolchain 1.98.0 clippy
          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"

      # Windows: a host executor with rustup already installed. Only ensure the
      # pinned toolchain is present + default. pwsh, never bash (that is WSL here).
      - name: Install Rust 1.98.0 (Windows)
        if: matrix.os == 'windows'
        shell: pwsh
        run: |
          rustup toolchain install 1.98.0 --profile minimal
          rustup default 1.98.0

      - name: Build the cargo classes (pure Rust, no C codec chain)
        working-directory: wai/wai-rs
        # neural_int joins the pure-Rust set: the integer-synthesis decoder is
        # i64-only (no ONNX, no float), so it carries the same bit-exact promise
        # and is checkable on this matrix with no ONNX Runtime present. receipt_claims
        # is in the set because the reference meters (wai_meter, wai_world_meter) write a
        # measurement report by default and require it: without it they would drop out
        # 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; 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,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
      # denies, rejects a listed float method however it is spelled; and
      # tests/jpegai_decode_symbols.rs lists the linked decoder's symbols with `nm` and
      # rejects any C math-library function it imports, whatever made the call, and any
      # it defines other than the round-to-integral ones (see its doc). `-A clippy::all`
      # keeps the output to that guard. Unix legs only: `nm` is not on the Windows
      # runner, and for clippy the unix legs already cover both architectures.
      - name: JPEG AI exact decode calls no platform math library (unix)
        if: matrix.os != 'windows'
        shell: bash
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          cargo clippy --lib --no-default-features --features neural_int -- -A clippy::all
          cargo test --no-default-features --features world,audio_scene,haptic,splat4d,score,provenance,neural_int,film --test jpegai_decode_symbols

      # Each extension container refuses a count its bytes cannot hold, without reserving
      # it first (found by the coverage-guided fuzzer, wai-rs/fuzz/, target `containers`),
      # and a declared duration past the reader limits it shares with SPEC §2.
      - name: Extension containers reserve no more than their bytes hold, and are held to their duration limits
        shell: bash
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --features world,audio_scene,haptic,splat4d,score,film --test container_reservations --test extension_duration_limits

      # The integer decoders run fast kernels (src/int_kernels.rs) that must give
      # the same integer as the scalar reference kernels for every output element.
      # The feature list above leaves out audio_int, video_int, world_int and
      # splat_int, so without these two steps int_audio's kernel-equivalence tests
      # and tests/int_kernels_vectors.rs (every committed integer-decoder vector
      # decoded under the reference and under each fast policy, against its frozen
      # hash) would run nowhere. `--lib` also carries the other kernels' equivalence
      # modules; tests/int_kernels_geometry.rs runs edge geometry (strides up to
      # usize::MAX, padding far beyond the kernel) through the public decoders
      # under every policy. Both profiles, because the overflow-parity tests assert
      # different things in each: with overflow checks on (dev) that the fast path panics
      # where the reference panics, with them off (release) that it returns the
      # same integers. All pure Rust, so every leg runs them.
      # tests/int_synth_ops.rs holds wai.neural.int_synth to its lowering through the
      # integer operator set (extensions/integer-operators.md §13.1): every committed set
      # lowers to its committed graph and loads with its certificate's verdict, decodes
      # through it to every committed golden, and refuses whatever the direct decode
      # refuses. tests/int_ops_differential.rs (feature legacy_int: the direct decode,
      # test-only) decodes random sets and payloads both ways: the same output or both
      # refused, except on the planned breaks of integer-operators §15.3, where the decode
      # through the operator set refuses. wai-ops-differential.yml runs it for an hour in
      # each profile, nightly. tests/int_splat_ops.rs holds wai.splat.int_codec to its
      # lowering whm1/1 the same way (integer-operators §13.2): its committed set lowers,
      # from its bytes and from the model this crate parses, to its committed graph, and
      # loads with its certificate's verdict. tests/int_audio_ops.rs does the same for
      # wai.audio.int_codec and its lowering wam1/1 (§13.3), and tests/int_hyper_ops.rs
      # for wai.neural.int_hyper and the keyframe of wai.video.int_hyper (whm1/1: h_s,
      # then g_s with the RGB8 step), and tests/int_mlicpp_ops.rs for wai.neural.int_mlicpp
      # (wmb1/1: h_s, entropy, then g_s with the RGB8 step), and tests/int_world_ops.rs for
      # wai.world.model's integer renderer (world/1, informative: T with its action planes,
      # then g_s with the RGB8 step).
      # tests/int_mlicpp.rs decodes the committed wai.neural.int_mlicpp vector against
      # its pinned hashes (image, every scale bucket, every symbol) under every kernel
      # policy and thread count, and checks that damaged payloads are refused rather than
      # overflowing — which is why it runs in both profiles too.
      # tests/int_mlicpp_preflight.rs (its own binary: it installs a counting global
      # allocator) checks that a header the model cannot fit is refused before the
      # decode allocates anything sized from it.
      # tests/int_audio.rs and tests/int_splat.rs decode the committed wai.audio.int_codec and
      # wai.splat.int_codec vectors against the hashes the Python integer reference computed at
      # export, and check each vector's metadata. `--lib` runs int_payload's unit tests: each
      # binary payload (WIV1, WIH1, WIA1, WIS1) against the JSON it is converted from, under
      # every kernel policy, and decode_int for every integer capability in this build, which
      # has no `neural`. tests/int_payload.rs refuses every fixture of int-payload-conformance
      # with its code, every strict prefix of every payload, and runs a byte-change sweep in
      # which nothing may panic; tests/int_payload_preflight.rs (its own binary, a counting
      # allocator) checks that a header past the caps is refused before anything sized from it
      # is allocated; tests/int_payload_cost.rs (its own binary, a live-bytes allocator) checks
      # that int_payload::declared_cost bounds what each decode holds, with the store of loaded
      # sets off, then on (a decode that loads its set, and one that finds it held), that the
      # store counts at least the bytes it holds, and, in the release step only, decodes a
      # 2^30-byte clip a 3 KB payload codes; tests/int_set_cache.rs checks that store under
      # the decodes: a second decode through a set is a hit with the same bytes on every
      # committed vector, sets one byte apart never share an entry, a refused set stays
      # refused, refusals keep their codes, and the least recently used set goes first;
      # tests/int_world_memory.rs (its own binary, the same allocator) checks that the world
      # renderer, with its set loaded, holds no more than the direct renderer it replaced.
      # tests/int_video_enc_memory.rs
      # (its own binary, the same allocator) checks that int_video_enc::working_bytes bounds
      # what the encoder holds. tests/staged_resources.rs (its
      # own binary, a counting allocator) checks that the staged sink's work and memory per
      # layer grow linearly in the layer's units, that a layer past the chain budget is
      # refused before any stream is decoded, that what no unit holds is dropped, and that a
      # WIR1 parse holds no more than its declared working bytes. tests/stage_measure.rs counts every
      # committed staged envelope as exactly its length, refuses JSON, base64 and another capability's
      # format, and evaluates a measured title read from a map of files to its golden, refusing a
      # changed byte of a layer, the base, the source or a parameter-set file (extensions/
      # staged-measurement.md). Cargo.toml declares them, and the other
      # feature-gated targets named here, with required-features, so if this step ever loses a
      # feature, cargo stops with an error instead of compiling an empty binary that reports ok.
      # Each committed vector's decoded output is also checked against the SHA-256 in
      # its sha256.json sidecar (SPEC §7 *Digests*), and
      # int_kernels_vectors::every_decoded_output_states_a_sha256 requires a sidecar,
      # or a named exclusion, for every corpus directory. tests/generate.rs checks the
      # wai.generate.spectral vectors, which `generate` enables: the 96x96 vector, sizes.json
      # and instr-v0.json, the instruction object of form v0 (SPEC §5), whose two larger
      # listed sizes run only in the release step (seconds each in a debug build).
      # tests/cli_generate_score.rs runs `wai generate` and `wai score build|render`, which
      # the features `generate` and `score` build into the `wai` binary: every pin it prints
      # against those vectors and score-conformance/ (pcm_sha256 among them), every object
      # instr-v0.json lists as accepted (one at each bound) made and wrapped, every object
      # it lists as refused refused for the reason it states, and each refusal writing
      # nothing; tests/generate.rs holds the same lists to a second statement of form v0.
      # tests/manifest_parse_memory.rs (its own binary, a counting allocator) checks that
      # reading a manifest allocates within the bound SPEC §2's reader limits give, at the
      # length limit and at the value limit, and tests/manifest_reader_equivalence.rs holds
      # the readers to the derived reader's result on every committed envelope. Both run in
      # the release step only: the first writes manifests of 2^27 bytes, which takes a debug
      # build most of a minute.
      # tests/int_video.rs, int_video_halfpel.rs and int_video_keyframe.rs hold the integer
      # video codec to its goldens (whole clips, half-pel motion, the keyframe through the
      # integer hyperprior); int_world.rs and int_world2.rs the integer world renderers;
      # jpegai_bitstream_calibration.rs the JPEG AI bitstream reader against the committed
      # codestream. No step named any of them until scripts/check-tests-in-ci.py asked.
      # jpegai_ops.rs holds the JPEG AI scale path (integer-operators §13.6.1) to its committed
      # lowered graphs and certificate here; its cases on the jpegai/v1 bundle skip here and
      # run in wai-jpegai-e2e.yml, which fetches the bundle and requires them.
      # jpegai_nets_ops.rs does the same for its other integer networks (§13.6.2): the
      # committed synthetic networks' lowered graphs and certificate, and every kernel
      # policy on them, here; its jpegai/v1 cases there.
      # int_video_ops.rs and wir1_ops.rs hold WIV1 and WIR1, which decode through the
      # operator set's stage operators with no graph (integer-operators §13.5), to their
      # stage forms, goldens and refusals; `i32_forms` builds E9's 32-bit form, which they
      # and int_ops_differential.rs hold to the exact one.
      - name: Fast integer kernels ≡ reference kernels (overflow checks on)
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --features neural_int,video_int,audio_int,world_int,splat_int,generate,score,staged,stage_measure,legacy_int,i32_forms --lib --test int_kernels_vectors --test int_kernels_geometry --test int_synth_ops --test int_ops_differential --test int_splat_ops --test int_audio_ops --test int_hyper_ops --test int_mlicpp --test int_mlicpp_preflight --test int_mlicpp_ops --test int_world_ops --test int_world_memory --test jpegai_ops --test jpegai_nets_ops --test int_video_ops --test wir1_ops --test int_audio --test int_splat --test generate --test cli_generate_score --test int_payload --test int_payload_preflight --test int_payload_cost --test int_set_cache --test int_video_enc_memory --test cli_stage --test staged_resources --test stage_measure --test stage_measure_bounds --test int_video --test int_video_halfpel --test int_video_keyframe --test int_world --test int_world2 --test jpegai_bitstream_calibration
      - name: Fast integer kernels ≡ reference kernels (release, overflow checks off)
        working-directory: wai/wai-rs
        run: cargo test --release --no-default-features --features neural_int,video_int,audio_int,world_int,splat_int,generate,score,staged,stage_measure,legacy_int,i32_forms --lib --test int_kernels_vectors --test int_kernels_geometry --test int_synth_ops --test int_ops_differential --test int_splat_ops --test int_audio_ops --test int_hyper_ops --test int_mlicpp --test int_mlicpp_preflight --test int_mlicpp_ops --test int_world_ops --test int_world_memory --test jpegai_ops --test jpegai_nets_ops --test int_video_ops --test wir1_ops --test int_audio --test int_splat --test generate --test cli_generate_score --test int_payload --test int_payload_preflight --test int_payload_cost --test int_set_cache --test int_video_enc_memory --test cli_stage --test staged_resources --test stage_measure --test stage_measure_bounds --test manifest_parse_memory --test manifest_reader_equivalence --test int_video --test int_video_halfpel --test int_video_keyframe --test int_world --test int_world2 --test jpegai_bitstream_calibration
      # 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. 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 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,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
          # With the claim classes too: a browser sink seals its reconstruct-session claim
          # (jwp-receipts §2.4.12), and wai-web's measurement binding signs with them.
          cargo build --lib --target wasm32-unknown-unknown --no-default-features --features receipt_claims,stage_measure
          # So is delivery telemetry: a browser sink writes the same reports.
          cargo build --lib --target wasm32-unknown-unknown --no-default-features --features telemetry
      # carriage: every registered capability round-trips byte-exact. cli_wrap_intent and
      # cli_registry run the `wai` binary, which builds without the codecs feature: the
      # intent rule of `wai wrap`, its refusal of candidate capabilities (SPEC §5), its media
      # class, and `wai registry export --check` on the tree and on a drifted copy.
      # tests/manifest_builders.rs: the manifest types are #[non_exhaustive], and the
      # builders write the JSON a struct literal wrote; members the types keep only
      # as `extra` (and `security`) survive a round trip.
      # corpus_provenance: every corpus README states where its content comes from.
      - name: Carriage conformance, the wai CLI (wrap, registry export) and corpus provenance
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --test carriage --test manifest_builders --test cli_wrap_intent --test cli_registry --test corpus_provenance
      # 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; and `hls`,
      # `mpd`, `seal-playlist` and `check-playlist`, whose receipts need video_manifest;
      # and `receipts`, an object's receipt index checked over HTTP with its signers
      # confirmed under a key log, which needs key_discovery: the log anchored over TLS
      # (cli_tls; the binary's own tests run its TLS client against servers under a test
      # CA, tests/fixtures/tls/), never over plaintext, and a plaintext test anchor
      # labelled as one. The second run builds without cli_tls: the CLI then refuses to
      # anchor and connects to nothing.
      # Cargo.toml declares it with required-features = ["http"]. tests/dash_read_bounds.rs
      # holds Appendix I's reader to the document's size under a counting allocator, and an
      # element's attributes to linear CPU time; a binary of its own, one test.
      - name: The wai http commands
        working-directory: wai/wai-rs
        shell: bash
        run: |
          cargo test --no-default-features --features http,video_manifest,key_discovery,cli_tls --bin wai --test cli_http --test dash_read_bounds
          cargo test --no-default-features --features http,video_manifest,key_discovery --test cli_http -- receipts_never_anchors_over_plaintext
      # tests/staged_moq.rs runs the MoQ trace of staged-conformance/moq/ (moq-streaming-format
      # §4.1) with signed receipts: a chain for each track, a receipt held for its parent and
      # admitted when it arrives, the relay's per-hop delivery timeout, dropped objects checked
      # by inclusion and named by the relay's delivery-gap claims, and each base's stage claim,
      # which seals and verifies; the subscriber of two tracks holds exactly their chains.
      # Cargo.toml declares it with required-features = ["staged", "video_int", "receipt_claims"].
      # The interactive-world tests, which no step named: world_replay.rs (the replay
      # class, under `world`), world_model.rs (the signed action trace and per-frame
      # provenance, under `world_model`) and int_world_shared.rs (two sinks converging on
      # one integer world, under both). `world_model` is enabled by no other step.
      - name: World replay, the world model and the shared integer world
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --features world_model,world_int --test world_replay --test world_model --test int_world_shared
      - name: Staged tracks over MoQ, with signed receipts
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --features staged,video_int,receipt_claims --test staged_moq
      # 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
      # export is the same text on every platform.
      - name: The registry export is up to date (linux)
        if: matrix.os == 'linux'
        working-directory: wai/wai-rs
        run: cargo run -q --no-default-features --bin wai -- registry export --check
      # The C ABI's envelope surface builds with no codec library (feature `ffi`):
      # unpack returns each manifest as the envelope carries it, the WAI2 table carries
      # every component's identity and selectability, wai_envelope_select follows
      # SPEC §7.1 and never picks a candidate, and the packers refuse a candidate
      # (SPEC §5). Cargo.toml declares the target with required-features.
      - name: C ABI envelope surface (no codec library)
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --features ffi --test ffi_envelope
      # The browser crate wraps the same envelope types (wai::container), so role,
      # companion_of, component identity and the pin reach JS, and its pick is SPEC
      # §7.1's. Its tests target the pure-Rust half (`core`), which runs natively; one
      # leg suffices, the logic is architecture-independent. The JS surface itself runs
      # under wasm32 in wai-web-wasm.yml.
      - name: wai-web envelope surface (native tests)
        if: matrix.os == 'linux'
        working-directory: wai/wai-web
        run: cargo test --locked
      # jwp-receipts §7.1, §7.8: no `did:web`/`did:key` literal in a tracked .rs, .json or
      # .js file under wai/ names a real web origin — every key the tree signs with has a
      # published seed. Ungated: it reads the tree through `git ls-files` and classifies
      # with `signer_id`, which builds with no feature.
      - name: Every signer id in the tree is a label
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --test signer_ids_are_labels
      # jwp-receipts §7: `wai-keys` builds a key log from operator-supplied seeds, appends
      # revocations and rotations, signs statuses and module grants, verifies a log as
      # §7.3 anchors one, and checks a DID document against it. The test drives the binary.
      - name: wai-keys — build, check and publish an origin key log
        working-directory: wai/wai-rs
        run: cargo test --no-default-features --features key_discovery --test wai_keys_cli
      # key_log has no I/O, clock or threads, so a browser sink could run it before it
      # instantiates a module (§7.9); no browser sink does yet. Nor do the HTTP binding's
      # receipts and keys (http-delivery §8.1–§8.5), which a browser client checks what it
      # fetched with. This step checks that both build for wasm32 on the unix legs (the
      # target is added to the pinned toolchain here; the Windows host runner is not set up
      # for it).
      - name: key_log and the HTTP receipts build for wasm32 (unix)
        if: matrix.os != 'windows'
        shell: bash
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          rustup target add --toolchain 1.98.0 wasm32-unknown-unknown
          cargo check --lib --target wasm32-unknown-unknown --no-default-features --features key_discovery,http

      # The corpus-verify loop is genuinely shell-specific (a helper that groups
      # log output and propagates the first non-zero exit), so it ships once per
      # shell family. The command it runs is identical; only the wrapper differs.
      - name: Every cargo-class corpus reproduces its frozen hashes (unix)
        if: matrix.os != 'windows'
        shell: bash
        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,http,video_manifest
          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
          v haptics       wai_haptic_vectors     ../haptic-conformance
          v state-feeds   wai_feed_vectors       ../feed-conformance
          v avatars       wai_avatar_vectors     ../avatar-conformance
          v volumetric    wai_splat4d_vectors    ../volumetric-conformance
          v score         wai_score_vectors      ../score-conformance
          v int-synth     wai_int_synth_vectors  ../neural-conformance
          v film          wai_film_vectors       ../film-conformance
          v quantum       wai_quantum_vectors    ../quantum-conformance
          v quantum-ops   wai_quantum_ops_vectors ../quantum-ops-conformance
          v oer           wai_oer_vectors        ../oer-conformance
          v jwp           wai_jwp_vectors        ../jwp-conformance
          v claims        wai_claim_vectors      ../claim-conformance
          v pin           wai_pin_vectors        ../pin-conformance
          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
      # code with wai-rs. One leg is enough — it checks digests and listing rules, which
      # do not depend on the architecture — and the macOS host has python3.
      - name: The pin corpus checks against an independent verifier (macOS)
        if: matrix.os == 'macos'
        shell: bash
        working-directory: wai
        run: python3 pin-conformance/pin_verify.py pin-conformance
      # Every committed audio vector must come from a seeded generator. This check reads
      # each one to PCM (each audio base's stage 0 in the staged corpus, each measured
      # source over one, each spatial-audio source, every audio file under wai/) and
      # fails if any correlates above 0.5, at any lag, with a recording in the reference
      # set the host has: its system sound directory, or the directories named in
      # WAI_AUDIO_REFERENCE_DIRS. A generated signal stays near 0.2; a lossy coding of a
      # recording is near 1. A host with no reference set, or no converter to read it,
      # prints why and skips: the linux legs skip, the macOS leg checks.
      - name: No committed audio vector is a coding of a reference recording (unix)
        if: matrix.os != 'windows'
        shell: bash
        working-directory: wai
        run: |
          if command -v python3 >/dev/null 2>&1; then
            python3 tools/wai_audio_provenance_check.py
          else
            echo "audio provenance: SKIPPED — no python3 on this host"
          fi
      # OER's second implementation is portable C, not Rust. Rebuild it from source and
      # require its output to match the pinned corpus byte for byte: the kernel is
      # deterministic, and wai_oer_vectors above has already verified the pinned copy,
      # so equality carries that verification to what the source produces today.
      # `cc` with the Makefile's flags, so the step needs no `make` on the runner.
      - name: OER C kernel reproduces its pinned receipts (unix)
        if: matrix.os != 'windows'
        shell: bash
        working-directory: wai/oer-conformance/settle
        run: |
          set -euo pipefail
          cc -O2 -std=c99 -Wall -Wextra -Wno-unused-parameter -Wno-sign-compare \
            -o "$RUNNER_TEMP/settle_host" host_main.c settle.c sha256.c tweetnacl.c -lm
          "$RUNNER_TEMP/settle_host" "$RUNNER_TEMP/firmware_vectors.json" 400
          cmp "$RUNNER_TEMP/firmware_vectors.json" ../firmware_vectors.json
      - name: Every cargo-class corpus reproduces its frozen hashes (Windows)
        if: matrix.os == 'windows'
        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,http,video_manifest"
          function v($grp, $bin, $path) {
            Write-Output "::group::$grp"
            cargo run -q --no-default-features --features $F --bin $bin -- verify $path
            if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
            Write-Output "::endgroup::"
          }
          v worlds        wai_world_vectors      ../world-conformance
          v spatial-audio wai_audio_vectors      ../audio-conformance
          v haptics       wai_haptic_vectors     ../haptic-conformance
          v state-feeds   wai_feed_vectors       ../feed-conformance
          v avatars       wai_avatar_vectors     ../avatar-conformance
          v volumetric    wai_splat4d_vectors    ../volumetric-conformance
          v score         wai_score_vectors      ../score-conformance
          v int-synth     wai_int_synth_vectors  ../neural-conformance
          v film          wai_film_vectors       ../film-conformance
          v quantum       wai_quantum_vectors    ../quantum-conformance
          v quantum-ops   wai_quantum_ops_vectors ../quantum-ops-conformance
          v oer           wai_oer_vectors        ../oer-conformance
          v jwp           wai_jwp_vectors        ../jwp-conformance
          v claims        wai_claim_vectors      ../claim-conformance
          v pin           wai_pin_vectors        ../pin-conformance
          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

  # wai-quantum and the quantum corpus under wasm32-wasip2, run by wasmtime. On wasm32
  # usize is 32 bits, so arithmetic that cannot overflow on a 64-bit host can there: a
  # section's offset plus its length, a capacity reserved from a count a file claims, a
  # shift by a qubit count. The builds are debug builds, so overflow checks are on and
  # such an overflow panics instead of wrapping. Three steps:
  #   1. tests/bit_identity.rs, which pins one result of each f64 layer, so the wasm32
  #      build must give the bits every native leg gives;
  #   2. the library's unit tests in the modules that hold the circuit core, its
  #      container, its JSON reader and its pins (quantum, ijson, receipt_pins,
  #      quantum_fabric, quantum_source, quantum_channel, quantum_qudit, quantum_receipt),
  #      each required to have run, and each test of the fabric's groundwork for
  #      accelerator members required by name (the WebGPU member itself has no wasm32-
  #      wasip2 build; wai-quantum-webgpu.yml checks that the feature is inert there);
  #   3. wai_quantum_vectors verify over all four trees of quantum-conformance/ (both
  #      capabilities, the reject corpus and the accept corpus), the same check the matrix
  #      above runs natively.
  # One leg: wasm32 is the same machine on every host. Linux, so it does not queue on the
  # single macOS runner.
  quantum-wasip2:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: quantum core and corpus under wasm32-wasip2 (wasmtime)
    runs-on: linux
    # The fabric's planner test runs fabric-v1 under every planner configuration in a
    # debug wasm build, several minutes on its own; the timeout leaves it room rather
    # than the test being skipped on wasm32.
    timeout-minutes: 90
    steps:
      - uses: actions/checkout@v5

      - name: Install Rust 1.98.0 with the wasm32-wasip2 target
        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
          rustup target add --toolchain 1.98.0 wasm32-wasip2
          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"

      # The release binary, pinned by version and SHA-256, rather than a build from source.
      - name: Install wasmtime 49.0.2
        shell: bash
        run: |
          set -euo pipefail
          [ "$(uname -m)" = x86_64 ] || { echo "::error::the pinned wasmtime archive is x86_64; this host is $(uname -m)"; exit 1; }
          if ! command -v xz >/dev/null 2>&1; then
            SUDO=""; [ "$(id -u)" -ne 0 ] && SUDO="sudo"
            $SUDO apt-get update -qq
            $SUDO apt-get install -y -qq xz-utils
          fi
          v=49.0.2
          f="wasmtime-v$v-x86_64-linux.tar.xz"
          curl --proto '=https' --tlsv1.2 -sSfL -o "$RUNNER_TEMP/$f" \
            "https://github.com/bytecodealliance/wasmtime/releases/download/v$v/$f"
          echo "a4d6e9e3a5a60f527cf7793d674c48930c80c2e8977995b8a275cad3254b9322  $RUNNER_TEMP/$f" | sha256sum -c -
          tar -xJf "$RUNNER_TEMP/$f" -C "$RUNNER_TEMP"
          echo "$RUNNER_TEMP/wasmtime-v$v-x86_64-linux" >> "$GITHUB_PATH"

      - name: tests/bit_identity.rs under wasmtime
        working-directory: wai/wai-quantum
        env:
          CARGO_TARGET_WASM32_WASIP2_RUNNER: wasmtime
        run: cargo test --locked --target wasm32-wasip2 --features full --test bit_identity

      # The filters are module paths, so a module that is renamed or loses its tests would
      # leave its filter matching nothing and the run passing; the loop fails the step
      # unless every module had a test that passed.
      - name: The circuit core's unit tests under wasmtime
        shell: bash
        working-directory: wai/wai-quantum
        env:
          CARGO_TARGET_WASM32_WASIP2_RUNNER: wasmtime
        run: |
          set -euo pipefail
          mods="quantum ijson receipt_pins quantum_fabric quantum_source quantum_channel quantum_qudit quantum_receipt"
          filters=()
          for m in $mods; do filters+=("$m::"); done
          cargo test --locked --target wasm32-wasip2 --features full --lib -- "${filters[@]}" 2>&1 \
            | tee "$RUNNER_TEMP/wasip2-lib.log"
          for m in $mods; do
            grep -q "^test $m::.* \.\.\. ok$" "$RUNNER_TEMP/wasip2-lib.log" \
              || { echo "::error::no test of $m ran"; exit 1; }
          done
          # The fabric's groundwork for accelerator members (certification one case at
          # a time, the fabric-v1 corpus and its pins, the 32-bit-lane words and their
          # range guard, run meters, metered calibration, placement for a run and the
          # fabric's fallback, the program a member runs in every planner configuration,
          # the WGSL kernels' host layouts, member ids and mutants), each by name: a module
          # filter is satisfied by any one test of the module, so a test dropped or
          # compiled out on wasm32 would otherwise go unnoticed.
          for t in quantum_fabric::tests::certification_is_certify \
                   quantum_fabric::tests::fxmul_wide_is_the_exact_product \
                   quantum_fabric::tests::apply_words_is_apply \
                   quantum_fabric::tests::malformed_words_are_refused \
                   quantum_fabric::tests::z_on_the_most_negative_lane_is_flagged \
                   quantum_fabric::tests::simulate_checked_is_simulate \
                   quantum_fabric::tests::a_rounded_product_is_never_negated \
                   quantum_fabric::tests::the_guard_horizon_is_pinned \
                   quantum_fabric::tests::valid_circuits_stay_in_lanes \
                   quantum_fabric::tests::fabric_corpus_starts_with_random_v1 \
                   quantum_fabric::tests::the_fabric_v1_corpus_of_each_gateset_is_pinned \
                   quantum_fabric::tests::fabric_v1_covers_every_dispatch_shape \
                   quantum_fabric::tests::gate_words_are_the_table \
                   quantum_fabric::tests::a_meter_reading_is_labelled_or_dropped \
                   quantum_fabric::tests::a_placement_figure_is_a_measurement_or_nothing \
                   quantum_fabric::tests::figures_go_on_both_members_or_neither \
                   quantum_fabric::tests::place_for_sends_small_runs_to_the_cpu_and_large_ones_to_the_gpu \
                   quantum_fabric::tests::the_fabric_falls_back_and_names_the_member_that_produced_the_result \
                   quantum_fabric::tests::a_metered_fabric_run_seals_its_reading \
                   quantum_fabric::tests::a_calibration_gives_the_cpu_reference_its_figure \
                   quantum_fabric::plan::tests::execute_is_the_native_simulator \
                   quantum_fabric::plan::tests::every_configuration_is_the_native_simulator \
                   quantum_fabric::plan::tests::long_circuits_tile_as_they_run_gate_by_gate \
                   quantum_fabric::plan::tests::tiles_are_exact_on_any_words \
                   quantum_fabric::plan::tests::tiles_cover_every_path \
                   quantum_fabric::plan::tests::the_v1_tail_phases_are_not_skipped \
                   quantum_fabric::plan::tests::malformed_programs_are_refused \
                   quantum_fabric::wgsl::tests::implementation_id_is_pinned \
                   quantum_fabric::wgsl::tests::gate_record_layout \
                   quantum_fabric::wgsl::tests::grids_cover_every_item_once \
                   quantum_fabric::wgsl::tests::the_index_map_is_a_bijection \
                   quantum_fabric::wgsl::tests::member_ids_are_pinned \
                   quantum_fabric::wgsl::tests::the_cpu_reference_is_placed_first_when_nothing_is_metered \
                   quantum_fabric::wgsl::tests::mutants_apply_once \
                   quantum_fabric::wgsl::tests::mutant_witnesses_exist \
                   quantum_fabric::wgsl::tests::placement_breaks_an_implementation_tie_by_name \
                   quantum_fabric::wgsl::tests::tile_implementation_id_is_pinned \
                   quantum_fabric::wgsl::tests::tile_records_layout \
                   quantum_fabric::wgsl::tests::tile_grids_cover_every_tile_once \
                   quantum_fabric::wgsl::tests::tile_mutants_apply_once \
                   quantum_fabric::wgsl::tests::tile_mutant_witnesses_exist; do
            grep -q "^test $t \.\.\. ok$" "$RUNNER_TEMP/wasip2-lib.log" \
              || { echo "::error::$t did not run"; exit 1; }
          done

      # The wai package is built as one codegen unit here. Its lib target is also a cdylib,
      # and the wasm linker in Rust 1.98 (LLD 22) can crash with SIGSEGV linking that cdylib:
      # the linker keeps the flags of the first object that names the function table, so
      # when that object names it without NO_STRIP the table is no garbage-collection root.
      # Nothing the cdylib keeps calls through the table, but it does keep function
      # addresses, and writing their element segment then dereferences a table that was
      # never created. Which object comes first follows the hashed names of the codegen
      # units, so an unrelated change to the crate, or a different checkout path, can bring
      # the crash on or off. As one unit, wai's object comes first and takes function
      # addresses, so it names the table with NO_STRIP. LLD 23 keeps NO_STRIP from any
      # object. The units change how the crate is split for code generation, not what the
      # program computes.
      - name: wai_quantum_vectors verify under wasmtime
        shell: bash
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          cargo build --locked --target wasm32-wasip2 --no-default-features --features quantum --bin wai_quantum_vectors \
            --config 'profile.dev.package.wai.codegen-units=1'
          wasmtime run --dir ../quantum-conformance::/corpus \
            target/wasm32-wasip2/debug/wai_quantum_vectors.wasm verify /corpus

  # The generated v2 vocabulary (wai/vocab/v2.*) is checked as a consumer uses it:
  # sample manifests, typed and untyped, WAI1 and WAI2, are expanded through the
  # JSON-LD context exactly as written on the wire and validated against the SHACL
  # shapes, each with the result it must give (a candidate in any place is
  # rejected; a media value no revision lists is accepted). One leg: RDF tooling,
  # not arithmetic. The tool versions are pinned.
  vocab-shapes:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: v2 vocabulary · manifests validate as stated
    runs-on: linux-arm64
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-python@v5
        with:
          python-version: '3.11'
      - name: Install the RDF tools
        shell: bash
        run: python -m pip install rdflib==7.6.0 PyLD==3.3.0 pyshacl==0.40.1
      - name: Sample manifests against vocab/v2.shapes.ttl
        shell: bash
        run: python wai/vocab/check_shapes.py

  # The corpora above are generated and verified by wai-rs, one implementation. These are
  # the second implementations, written from the extension text in Python and sharing no
  # code with wai-rs: claim_verify.py (every claim vector, the canonical fixture, and the
  # bracket arithmetic of energy-measurement §6.2 recomputed with Python's integers),
  # differential.py (both verifiers' verdicts on generated inputs the corpus does not hold,
  # under a fixed seed, so a run is reproducible), jwp_verify.py (every JWP vector), and
  # 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), and http_verify.py (the HTTP delivery
  # corpus), and quantum-conformance/tools/referee.py (both quantum-sim capabilities), and
  # one verifier for each corpus under live-conformance/, which live-conformance/README.md
  # lists beside its directory, extension and generator.
  # 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:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: independent verifiers · claims, JWP, key discovery and integer payloads (Python)
    runs-on: linux-arm64
    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'

      # The ad-presentation step runs the browser client's reference producer under Node, whose
      # WebCrypto signs with Ed25519.
      - uses: actions/setup-node@v4
        with:
          node-version: '22'

      # The verifiers check Ed25519's equation with the `cryptography` package and make the
      # rest of jwp-receipts §3.1 step 3 themselves.
      - name: Install the Ed25519 library
        shell: bash
        run: python -m pip install cryptography

      # differential.py drives wai_claim_vectors' `verdicts` mode; the key-discovery
      # verdicts are compared with wai_signer_vectors'.
      - name: Build the corpus verifiers wai-rs ships
        working-directory: wai/wai-rs
        shell: bash
        run: cargo build --no-default-features --features key_discovery --bin wai_claim_vectors --bin wai_jwp_vectors --bin wai_signer_vectors

      # The integer payload corpus's second implementation (int-payload-conformance/README):
      # it parses every payload with the extension's rules and check order, converts every
      # JSON source independently and requires the committed bytes, decodes the WIV1
      # keyframe-0 payloads in full to their sidecars' SHA-256, and checks every refusal
      # fixture. Standard library only, so it needs nothing installed.
      - name: int_payload_verify.py
        working-directory: wai
        shell: bash
        run: python3 int-payload-conformance/int_payload_verify.py int-payload-conformance
      # The staged-delivery corpus's second implementation (staged-conformance/README): it
      # replays every case from its stage-0 buffers through its own reading of the
      # extension (refines, WIR1, the sink's steps, holds, batches, conflicts, deadlines,
      # tiers, stage hashes), decodes the WIV1 keyframe-0, PNG and FLAC bases, explodes the
      # WAI2 files, and replays the schedule. Standard library only.
      - name: staged_verify.py
        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, the codecs union and floor, the
      # playlists (read, rendered, held adjacent, the classical master unchanged), playlist
      # receipts (WAI's strict Ed25519, _ed25519.py) and the live edge, and the adaptation policies,
      # checked first against published BLAKE3 vectors, with the standard library alone;
      # and the receipts, key logs, grants files and parameter sets of §8.1–§8.5, through
      # http_receipts.py and the corpora's own verifiers of jwp-receipts, which need the
      # `cryptography` package installed above (without it those cases fail, never skip).
      # 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; playlists, adjacent pairs,
      # published masters, renderings, adaptation states, the integer log and changed
      # receipt files; receipt files, indexes, grants files and key logs of §8.1–§8.5,
      # whose cases need the `cryptography` package installed above) 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,video_manifest,key_discovery --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,
      # and requires its decode to be the fixture tool's and its figures to be goldens.json's.
      # Standard library only.
      - name: measure_verify.py
        working-directory: wai
        shell: bash
        run: python3 staged-measure-conformance/measure_verify.py staged-measure-conformance
      # The delivery simulator's second implementation: Appendix B from the text, every case
      # of staged-measure-conformance/sim/ reproduced and its claim checked, with a
      # counter-case required for each part of the stall bound a schedule can lose.
      - name: sim_verify.py
        working-directory: wai
        shell: bash
        run: python3 staged-measure-conformance/sim_verify.py staged-measure-conformance
      # The simulator differentially, outside the corpus: seeded random models (a refinement
      # with its own delivery timeout among them) and plans, each simulated by
      # wai_stage_measure sim and by sim_verify.py, the refusal or the whole result, the
      # stall bound and the longest stall equal, and every stall within the bound where it
      # applies. Two fixed seeds, so a run is reproducible.
      - name: sim_diff.py, wai_stage_measure against sim_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo build --no-default-features --features stage_measure --bin wai_stage_measure)
          for seed in 1 2; do
            python3 staged-measure-conformance/sim_diff.py wai-rs/target/debug/wai_stage_measure "$seed" 1500
          done
      # wai.live.events (extensions/live-events.md): the reference module's unit tests and
      # tests/live_events.rs (the committed corpus regenerates byte for byte from its fixed
      # seeds, wai-rs gives every vector, policy case and binding case its stated outcome,
      # the corpus covers every kind and reason, and §9 lists exactly the reference's
      # codes); then the corpus's second implementation, live_events_verify.py, written
      # from the extension's text and sharing no code with wai-rs, which verifies the same
      # cases with WAI's strict Ed25519 (claim-conformance/_ed25519.py) and BLAKE3
      # (claim-conformance/_blake3.py), standard library only, run isolated (-I).
      - name: live events · wai-rs and live_events_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_events --lib live_events::)
          (cd wai-rs && cargo test --no-default-features --features live_events --test live_events)
          python3 -I live-conformance/live_events_verify.py live-conformance/events
      # wai.live.room (extensions/live-rooms.md): the reference module's unit tests and
      # tests/live_room.rs (the committed corpus regenerates byte for byte from its fixed
      # seeds, wai-rs gives every vector its stated outcome, every reason of §11 refuses a
      # vector, and §11 lists exactly the reference's codes); then the corpus's second
      # implementation, live_rooms_verify.py, written from the extension's text and sharing
      # no code with wai-rs, which verifies every event with live_events_verify.py and every
      # signature with WAI's strict Ed25519 (claim-conformance/_ed25519.py), standard
      # library only, run isolated (-I).
      - name: live rooms · wai-rs and live_rooms_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_room --lib live_room::)
          (cd wai-rs && cargo test --no-default-features --features live_room --test live_room)
          python3 -I live-conformance/live_rooms_verify.py live-conformance/rooms
      # wai.capture.take (extensions/capture-binding.md): the reference module's unit tests,
      # the output tree's (whose RFC 6962 hash and RFC 9162 consistency proofs the take tree
      # reuses), and tests/capture_take.rs (the committed corpus regenerates byte for byte
      # from its fixed seeds, wai-rs gives every vector its stated outcome, every reason of
      # §12 appears in it, and §12 lists exactly the reference's codes); then the corpus's
      # second implementation, capture_take_verify.py, written from the extension's text and
      # sharing no code with wai-rs, which verifies each room with live_rooms_verify.py and
      # every signature with WAI's strict Ed25519 (claim-conformance/_ed25519.py), and
      # requires every mutated copy of the corpus to fail; standard library only, run
      # isolated (-I).
      - name: capture take · wai-rs and capture_take_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features capture_take --lib -- capture_take:: output_tree::)
          (cd wai-rs && cargo test --no-default-features --features capture_take --test capture_take)
          python3 -I live-conformance/capture_take_verify.py live-conformance/takes
      # wai.live.compose (extensions/live-compose.md): the reference module's unit tests (the
      # layout over every grid of 1 to 64 tiles stays on its canvas with no tile overlapping
      # another, the fill modes, the attributes, the mixer) and tests/live_compose.rs (the
      # committed corpus regenerates byte for byte from its fixed seeds, wai-rs gives every
      # case its stated outcome, every reason of §10 refuses a case, and §10 lists exactly
      # the reference's codes); then the corpus's second implementation,
      # live_compose_verify.py, written from the extension's text and sharing no code with
      # wai-rs, which verifies each room with live_rooms_verify.py, steps through its
      # lifecycle replay to each instant itself, gives every layout, mix, descriptor,
      # composition and receipt the same outcome rectangle for rectangle and sample for
      # sample, and requires every mutated copy of the corpus to fail; standard library
      # only, run isolated (-I).
      - name: live compose · wai-rs and live_compose_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_compose --lib live_compose::)
          (cd wai-rs && cargo test --no-default-features --features live_compose --test live_compose)
          python3 -I live-conformance/live_compose_verify.py live-conformance/compose
      # wai.live.recording (extensions/live-recording.md): the reference module's unit tests,
      # the output tree's (whose range proofs it adds, tested against RFC 9162 §2.1.3.2's
      # check), and tests/live_record.rs (the committed corpus regenerates byte for byte from
      # its fixed seeds, wai-rs gives every recording and clip its stated outcome, every reason
      # of §9 appears in it, every take it says it reuses is capture binding's byte for byte,
      # and §9 lists exactly the reference's codes); then the corpus's second implementation,
      # live_record_verify.py, written from the extension's text and sharing no code with
      # wai-rs, which checks range proofs by the extension's recursion and by RFC 9162
      # §2.1.3.2's own algorithm, verifies each take with capture_take_verify.py and every
      # signature with WAI's strict Ed25519 (claim-conformance/_ed25519.py), and requires every
      # mutated copy of the corpus to fail; standard library only, run isolated (-I).
      - name: live recording · wai-rs and live_record_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_record --lib -- live_record:: output_tree::)
          (cd wai-rs && cargo test --no-default-features --features live_record --test live_record)
          python3 -I live-conformance/live_record_verify.py live-conformance/recordings
      # wai.text.timed (extensions/timed-text.md): the reference module's unit tests (cue model,
      # annotation, WebVTT, IMSC1 and its render-model bound, timelines, disclosure, and the
      # 608 encoder and decoder) and tests/timed_text.rs (every file of the committed corpus,
      # vectors.json and each expected .vtt, .ttml and .608.hex, regenerates byte for byte
      # from its fixed seeds and no other file is there, wai-rs gives every case its stated
      # outcome, the corpus covers every 608 code path, and §12 lists exactly the reference's
      # codes); then the corpus's second implementation, timed_text_verify.py, written from
      # the extension's text and sharing no code with wai-rs, which verifies every event with
      # live_events_verify.py, writes every output byte for byte from the text, parses each
      # IMSC1 document with xml.etree, and requires every mutated copy of the corpus to fail;
      # standard library only, run isolated (-I).
      - name: timed text · wai-rs and timed_text_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features timed_text --lib timed_text::)
          (cd wai-rs && cargo test --no-default-features --features timed_text --test timed_text)
          python3 -I live-conformance/timed_text_verify.py live-conformance/captions
      # wai.access.services (extensions/access-services.md): the reference module's unit tests
      # (words, full and prefix alignment with their walk back, signed integers, gains) and
      # tests/access_services.rs (vectors.json and each DAPT document regenerate byte for byte
      # from their fixed seeds and no other file is there, wai-rs gives every vector and
      # document its stated outcome and figures, every reason of §10 refuses a case, and §10
      # lists exactly the reference's codes); then the corpus's second implementation,
      # access_services_verify.py, written from the extension's text and sharing no code with
      # wai-rs, which verifies events and captions with timed_text_verify.py and every record
      # with WAI's strict Ed25519 rule, computes every figure and writes every DAPT document
      # itself, parses each with xml.etree, reads the extension's reason table, and requires
      # every mutated copy of the corpus to fail; standard library only, run isolated (-I).
      - name: access services · wai-rs and access_services_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features access_services --lib access_services::)
          (cd wai-rs && cargo test --no-default-features --features access_services --test access_services)
          python3 -I live-conformance/access_services_verify.py live-conformance/access
      # wai.live.metering (extensions/live-metering.md): the reference module's unit tests
      # (records and ledgers round-trip, the energy rules, the size bound at its limit, a
      # total of two classes told from a wrong one, funds rounding, the CMCD event-timeline
      # record and the application/cmcd batch, a ledger entry's audit path) and
      # tests/live_metering.rs (the committed corpus regenerates byte for byte from its fixed
      # seeds and the reference relay's recorded record, wai-rs gives every vector its stated
      # outcome, every reason of §9 refuses a vector, the large audience's relay record is the
      # lesson's size, and §9 lists exactly the reference's codes); then the corpus's second
      # implementation, live_metering_verify.py, written from the extension's text and sharing
      # no code with wai-rs, which verifies each room with live_rooms_verify.py, each take with
      # capture_take_verify.py and each composition receipt with live_compose_verify.py,
      # recomputes every unit, total and grant's consumption itself, and requires every
      # mutated copy of the corpus to fail; standard library only, run isolated (-I).
      - name: live metering · wai-rs and live_metering_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_metering --lib live_metering::)
          (cd wai-rs && cargo test --no-default-features --features live_metering --test live_metering)
          python3 -I live-conformance/live_metering_verify.py live-conformance/metering
      # wai.live.steering (extensions/energy-steering.md): the reference module's unit tests
      # (policies and decisions round-trip and their rules refuse, the window, the request
      # reader over HLS, DASH and CMCD, the RFC 9651 parser, exact products at their limits,
      # the margin at its boundary, figures compared only within a class, and a pathway with
      # no figure never placed first by its rank while one with a figure is within the
      # limits) and tests/energy_steering.rs (the committed corpus regenerates byte for byte
      # from its fixed seeds, wai-rs gives every request and vector its stated outcome, every
      # reason of §10 refuses a vector, and §10 lists exactly the reference's codes); then the
      # corpus's second implementation, energy_steering_verify.py, written from the
      # extension's text and sharing no code with wai-rs, which reads the room with
      # live_rooms_verify.py and the per-hop records with live_metering_verify.py, parses RFC
      # 9651 itself, recomputes every report, figure, decision and manifest, and requires
      # every mutated copy of the corpus to fail; standard library only, run isolated (-I).
      - name: energy steering · wai-rs and energy_steering_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features energy_steering --lib energy_steering::)
          (cd wai-rs && cargo test --no-default-features --features energy_steering --test energy_steering)
          python3 -I live-conformance/energy_steering_verify.py live-conformance/steering
      # wai.live.moderation (extensions/live-moderation.md): the reference module's unit tests
      # (policies, statements and notices round-trip and their rules refuse, the export's
      # strings and dates, the content types, the states that show an item) and
      # tests/live_moderation.rs (every file of the committed corpus, vectors.json and each
      # statement-of-reasons export, regenerates byte for byte from its fixed seeds and no
      # other file is there, wai-rs gives every room, export and clip its stated outcome, and
      # §10 lists exactly the reference's codes, each of which the corpus gives); then the
      # corpus's second implementation, live_moderation_verify.py, written from the
      # extension's text and sharing no code with wai-rs, which verifies each room with
      # live_rooms_verify.py and each clip with live_record_verify.py, writes every export
      # byte for byte, reads the extension's category, content-type and reason tables, and
      # requires every mutated copy of the corpus to fail; standard library only, run
      # isolated (-I).
      - name: live moderation · wai-rs and live_moderation_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_moderation --lib live_moderation::)
          (cd wai-rs && cargo test --no-default-features --features live_moderation --test live_moderation)
          python3 -I live-conformance/live_moderation_verify.py live-conformance/moderation
      # wai.live.ads (extensions/live-ads.md): the reference module's unit tests (policies and
      # annotations round-trip and their rules refuse, a break's identity, tags, events and
      # asset lists written exactly), the break form of wai.video.ssai's receipt (its JSON
      # carriage, each of its rules, its strict signature, the stitched form's legacy pin
      # unchanged), and tests/live_ads.rs (every file of the committed corpus, vectors.json and
      # each room's HLS tags, regenerates byte for byte from its fixed seeds and no other file
      # is there, wai-rs gives every room its stated outcome, and §10 lists exactly the
      # reference's codes, each of which the corpus gives); then the corpus's second
      # implementation, live_ads_verify.py, written from the extension's text and sharing no
      # code with wai-rs, which verifies each room with live_rooms_verify.py, writes every tag,
      # event and asset list byte for byte, verifies every receipt with WAI's strict Ed25519
      # rule and BLAKE3 from claim-conformance, reads the extension's reason table, and
      # requires every mutated copy of the corpus to fail; standard library only, run isolated
      # (-I).
      - name: live ads · wai-rs and live_ads_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_ads --lib live_ads::)
          (cd wai-rs && cargo test --no-default-features --features live_ads --lib wai_video_ssai::)
          (cd wai-rs && cargo test --no-default-features --features live_ads --test live_ads)
          python3 -I live-conformance/live_ads_verify.py live-conformance/ads
      # wai.live.ad_presentation (extensions/ad-presentation.md): the reference module's unit
      # tests (claims round-trip and their rules refuse, the quartile, the qualifying run, the
      # touched objects, a policy's presentation fields, RFC 9577's TokenChallenge) and
      # tests/ad_presentation.rs (every file of the committed corpus regenerates byte for byte
      # from its fixed seeds and no other file is there, RFC 9578's own token verifies under its
      # key, wai-rs gives every room its outcome and every claim its verdict, and §11 lists
      # exactly the reference's codes); then the corpus's second implementation,
      # ad_presentation_verify.py, written from the extension's text and sharing no code with
      # wai-rs, which verifies each room with live_ads_verify.py, judges every claim and its
      # RSASSA-PSS itself, requires every mutated copy of the corpus to fail and catches each of
      # its own checks dropped; standard library only, run isolated (-I). Last, the browser
      # client's reference producer (joule-moq-web/web/ads), which records observation
      # sequences into spans and writes and signs the corpus's claims from them, byte for byte.
      - name: ad presentation · wai-rs, ad_presentation_verify.py and the reference producer
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_ads --lib live_ads::presentation::)
          (cd wai-rs && cargo test --no-default-features --features live_ads --test ad_presentation)
          python3 -I live-conformance/ad_presentation_verify.py live-conformance/presentation
          node --test ../joule-code/joule-code-rs/crates/joule-moq-web/web/ads/presentation.test.mjs
      # wai.live.provenance (extensions/live-provenance.md): the reference module's unit tests
      # (boxes, chunks, emsg and the BMFF hash; the JUMBF store; COSE_Sign1 and the OKP key;
      # certificates written and read, their profile and chain; identifiers, track renderings,
      # dates and the compositor's source type) and tests/live_provenance.rs (every file of the
      # committed corpus regenerates byte for byte from its fixed seeds and the packaging
      # corpus's AV1 floor, and no other file is there; wai-rs gives every vector its stated
      # outcome; every reason of §12 refuses a vector; §12 lists exactly the reference's codes
      # with the two C2PA codes it reports); then the corpus's second implementation,
      # c2pa_live_verify.py, written from the extension's text and sharing no code with
      # wai-rs, which reads CBOR, ISO BMFF, JUMBF, COSE and X.509 DER itself, verifies every
      # signature with WAI's strict Ed25519 rule and every receipt with BLAKE3 from
      # claim-conformance, reads the extension's reason table, and requires every mutated copy
      # of a good vector to be refused; standard library only, run isolated (-I).
      - name: live provenance · wai-rs and c2pa_live_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_provenance --lib live_provenance::)
          (cd wai-rs && cargo test --no-default-features --features live_provenance --test live_provenance)
          python3 -I live-conformance/c2pa_live_verify.py live-conformance/c2pa-live
      # wai.media.synthesis (extensions/synthesis.md): the reference module's unit tests (the
      # pinned derivations by their rules, the class lattice, a generator's envelope) and
      # tests/synthesis.rs (the committed corpus regenerates byte for byte from its fixed seeds
      # and no other file is there, wai-rs gives every case its stated outcome and statements,
      # §12 lists exactly the reference's codes, each of which the corpus gives, and §10.2's
      # table pins exactly the reference's icons); then the corpus's second implementation,
      # synthesis_verify.py, written from the extension's text and sharing no code with wai-rs,
      # which runs the pinned derivations and writes each digital source type and C2PA
      # statement itself, verifies each room with live_rooms_verify.py and every record with
      # WAI's strict Ed25519 rule and BLAKE3 from claim-conformance, reads the extension's icon
      # and reason tables, and requires every mutated copy of the corpus to fail; standard
      # library only, run isolated (-I).
      - name: synthesis provenance · wai-rs and synthesis_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features synthesis --lib synthesis::)
          (cd wai-rs && cargo test --no-default-features --features synthesis --test synthesis)
          python3 -I live-conformance/synthesis_verify.py live-conformance/synthesis
      # The registered watermark scheme wai-mark:tent64 (extensions/synthesis.md §7.4 to §7.8):
      # the reference's unit tests (the code corrects 29 errors and its generator is the
      # definition's, the layout, the embedding and the detector in every orientation, the
      # battery's resampling, rotation and keyframe), then tests/synthesis_mark.rs in release,
      # since it embeds and attacks every picture of the measurement sets (every file of
      # live-conformance/synthesis-mark/ regenerates byte for byte, the measurement among them,
      # and no other file is there; every embedding, detection and case gets what it states;
      # the extension's definition, generator polynomial and shuffle are the reference's;
      # §7.5.8 claims only attacks the measurement shows survived, and §7.5.6's figures are the
      # measurement's); then the second implementation, synthesis_mark_verify.py with
      # _wai_mark.py, written from the extension's text and sharing no code with wai-rs, which
      # embeds, detects and decodes itself, runs the battery's picture attacks, verifies every
      # case with synthesis_verify.py, mutates copies of the corpus and weakens its own verifier
      # in turn; standard library only, run isolated (-I).
      - name: synthesis watermark · wai-rs and synthesis_mark_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features synthesis_mark --lib -- synthesis::mark synthesis_mark::)
          (cd wai-rs && cargo test --release --no-default-features --features synthesis_mark --test synthesis_mark)
          python3 -I live-conformance/synthesis_mark_verify.py live-conformance/synthesis-mark
      # wai.media.upscale (extensions/exact-upscale.md): the integer super-resolution
      # derivations' unit tests (the wai-ops/1 graph against the arithmetic of §3.2 written out
      # loop by loop, on random priors and pictures; a prior with no detail is the pinned
      # upscale; sr4 is sr2 twice; a prior that breaks §3.1 refused in its order; a picture past
      # the caps refused), the module's unit tests (the pixel counts of §6.3, a residual within
      # half its step), and tests/exact_upscale.rs (the committed corpus regenerates byte for
      # byte from its fixed seeds and its two pinned trained priors, and no other file is there;
      # wai-rs gives every case its stated outcome and statements; §8 lists exactly the
      # reference's codes, each of which the corpus gives; sha256.json names every accepted
      # output); then the corpus's second implementation, upscale_verify.py, written from the
      # extension's text and sharing no code with wai-rs, which runs the derivations with
      # _int_sr.py, verifies the claims with synthesis_verify.py and the residuals with
      # staged_verify.py, and requires every mutated copy of the corpus to fail; standard
      # library only, run isolated (-I).
      - name: exact upscale · wai-rs and upscale_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features neural_int --lib int_sr::)
          (cd wai-rs && cargo test --no-default-features --features exact_upscale --lib exact_upscale::)
          (cd wai-rs && cargo test --no-default-features --features exact_upscale --test exact_upscale)
          python3 -I live-conformance/upscale_verify.py live-conformance/upscale
      # wai.ai.usage (extensions/ai-usage.md): the reference module's unit tests (RFC 9651's
      # Dictionary parser against the vocabulary's examples and the RFC's edges, statements
      # read and refused in their steps' order, the precedence rule, HTTP fields compared by
      # meaning), the consumption class's body and terms in claim_receipt, and
      # tests/ai_usage.rs (vectors.json regenerates byte for byte from its fixed seeds and no
      # other file is there, wai-rs gives every statement, object, room, response, catalog,
      # claim and gate its stated outcome, §9 lists exactly the reference's codes, each of which
      # the corpus gives, and jwp-receipts §3.1 lists the class rules); then the corpus's second
      # implementation, ai_usage_verify.py, written from the extension's text and sharing no
      # code with wai-rs, which parses Structured Fields, canonical forms, receipts and claims
      # itself, reads rooms with live_rooms_verify.py, checks signatures with WAI's strict
      # Ed25519 rule and BLAKE3 from claim-conformance, reads the extension's reason table,
      # requires every mutated copy of the corpus to fail, and drops each of its own checks in
      # turn and requires the corpus to catch the weakened verifier; standard library only, run
      # isolated (-I). Last, claim-conformance's own verifier reads every consumption claim of
      # the corpus through jwp-receipts §3.1 steps 1 to 4 and requires the stated step and reason.
      - name: AI usage · wai-rs and ai_usage_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features ai_usage --lib ai_usage::)
          (cd wai-rs && cargo test --no-default-features --features ai_usage --lib claim_receipt::consumption::)
          (cd wai-rs && cargo test --no-default-features --features ai_usage --test ai_usage)
          python3 -I live-conformance/ai_usage_verify.py live-conformance/usage
          python3 -I claim-conformance/claim_verify.py consumption live-conformance/usage/vectors.json
      # wai.media.contribution (extensions/contribution.md): the reference module's unit tests
      # (every proof of the steps' tree walks to its root, the copying operations follow their
      # sample mappings, a map has one encoding) and tests/contribution.rs (the committed corpus
      # regenerates byte for byte from its fixed seeds and no other file is there, wai-rs gives
      # every case its stated outcome and statements, §11 lists exactly the reference's codes,
      # each of which the corpus gives, and the corpus generates with the model file of
      # wai.generate.spectral's conformance vector); then the corpus's second implementation,
      # contribution_verify.py, written from the extension's text and sharing no code with
      # wai-rs, which evaluates every pinned operation, runs the generator in its own arithmetic
      # after checking it against the generator's conformance vector, computes every map, share
      # and C2PA statement itself, reads origin claims with synthesis_verify.py and every record
      # with WAI's strict Ed25519 rule and BLAKE3 from claim-conformance, requires every mutated
      # copy of the corpus to fail, and drops each of its own checks in turn and requires the
      # corpus to catch the weakened verifier; standard library only, run isolated (-I).
      - name: contribution records · wai-rs and contribution_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features contribution --lib contribution::)
          (cd wai-rs && cargo test --no-default-features --features contribution --test contribution)
          python3 -I live-conformance/contribution_verify.py live-conformance/contribution
      # wai.delivery.settlement (extensions/settlement.md): the reference module's unit tests
      # (range proofs over every range around every chunk boundary of objects of many lengths
      # against BLAKE3's own root, tampered proofs refused, the group tree of jwp-receipts §2.2,
      # records and item lists read and refused, amounts rounded down per line) and
      # tests/settlement.rs (vectors.json regenerates byte for byte from its fixed seeds and no
      # other file is there, wai-rs gives every statement and range proof its stated outcome, §11
      # lists exactly the reference's codes, each of which the corpus gives, beside every code it
      # reuses); then the corpus's second implementation, settlement_verify.py, written from the
      # extension's text and sharing no code with wai-rs, which verifies range proofs over
      # BLAKE3's chunk tree with claim-conformance's BLAKE3, reads rooms, grants and proofs with
      # live_rooms_verify.py and per-hop records with live_metering_verify.py, checks signatures
      # with WAI's strict Ed25519 rule, recomputes every figure of every statement, reads the
      # extension's reason table, requires every mutated copy of the corpus to fail, and drops
      # each of its own checks in turn and requires the corpus to catch the weakened verifier;
      # standard library only, run isolated (-I).
      - name: delivery settlement · wai-rs and settlement_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features settlement --lib settlement::)
          (cd wai-rs && cargo test --no-default-features --features settlement --test settlement)
          python3 -I live-conformance/settlement_verify.py live-conformance/settlement
      # The browser sink (extensions/browser-sink.md): the reference module's unit tests (the
      # registry gate's rows, registered tiers, integers as §5 reads them, a binding's
      # canonical form, an answer for an unregistered codec string never read, powerEfficient
      # never stated off the user agent's route, the side table's ambiguity) and
      # tests/browser_sink.rs (both files of the committed corpus regenerate byte for byte and
      # no other file is there, wai-rs gives every case its stated outcome, every reason of
      # §11 appears in the corpus and §11 lists exactly the reference's codes, and the chain
      # the generator signs by hand verifies under jwp_delivery); wai-live-web's browser
      # functions held to the same corpus natively, and its wasm-route decoder verifying,
      # decoding and binding every chain object to the published frame digests; then the
      # corpus's second implementation, browser_sink_verify.py, written from the extension's
      # text and sharing no code with wai-rs, which reads the registry export for each
      # capability's class, recomputes every route, evaluation, energy entry, binding, chain
      # signature, frame state and side table, changes the answers for unregistered codec
      # strings every way and requires the corpus still to pass, and requires every mutated
      # copy of the corpus to fail; standard library only, run isolated (-I). The browser's
      # own run of it is joule-moq-web.yml's scenario binding.
      - name: browser sink · wai-rs, wai-live-web and browser_sink_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features browser_sink --lib browser_sink::)
          (cd wai-rs && cargo test --no-default-features --features browser_sink,receipt_claims --test browser_sink)
          (cd wai-rs && cargo run -q --no-default-features --features browser_sink --bin wai_browser_sink_vectors -- verify ../live-conformance/browser)
          (cd wai-live-web && cargo test --locked --lib browser_tests)
          (cd wai-live-web && cargo test --locked --features int_video --lib browser_tests)
          python3 -I live-conformance/browser_sink_verify.py live-conformance/browser
      # wai.media.takedown (extensions/takedown.md): the reference module's unit tests (times,
      # clock identifiers, the published registry, the order of subjects, the lower median) and
      # tests/takedown.rs (the committed corpus regenerates byte for byte from its fixed seeds
      # and no other file is there, wai-rs gives every case its stated outcome and facts and
      # every counts entry its rows, §11 lists exactly the reference's codes, each of which the
      # corpus gives, and the registry the module carries is registry/takedown-clocks.json);
      # then the corpus's second implementation, takedown_verify.py, written from the
      # extension's text and sharing no code with wai-rs, which computes every closure, holder,
      # purge time, clock verdict and counts row itself, reads derivation records and delivery
      # receipts with edge_verify.py, origin claims with synthesis_verify.py, acknowledgements
      # with settlement_verify.py and every record with WAI's strict Ed25519 rule and BLAKE3
      # from claim-conformance, requires every mutated copy of the corpus to fail, and drops
      # each of its own checks in turn and requires the corpus to catch the weakened verifier;
      # run isolated (-I). The reference relay's DVR store honours takedowns (§10.1), tested by
      # joule-moq-relay's tests/dvr.rs in joule-code-conformance.yml.
      - name: takedown · wai-rs and takedown_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features takedown --lib takedown::)
          (cd wai-rs && cargo test --no-default-features --features takedown --test takedown)
          python3 -I live-conformance/takedown_verify.py live-conformance/takedown
      # wai.media.influence (extensions/influence.md): the reference module's unit tests (the
      # blend keeps its base and its references by weight, the makers' split is whole, an
      # estimate mixed into a share is told from another difference) and tests/influence.rs (the
      # committed corpus regenerates byte for byte from its fixed seeds and no other file is
      # there, wai-rs gives every case, statement and report its stated outcome, every reason of
      # §9 and every code it reuses refuses a vector, and §9 lists exactly the reference's codes);
      # then the corpus's second implementation, influence_verify.py, written from the
      # extension's text and sharing no code with wai-rs, which verifies each session with
      # contribution_verify.py, regenerates every conditioned step with that implementation's
      # arithmetic of the generator, reads usage statements with ai_usage_verify.py and
      # statements with settlement_verify.py, computes every step map, share, attribution line
      # and report itself, requires every mutated copy of the corpus to fail, and drops each of
      # its own checks in turn and requires the corpus to catch the weakened verifier; standard
      # library only, run isolated (-I).
      - name: influence attribution · wai-rs and influence_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features influence --lib influence::)
          (cd wai-rs && cargo test --no-default-features --features influence --test influence)
          python3 -I live-conformance/influence_verify.py live-conformance/influence
      # wai.media.direction (extensions/direction.md): the reference module's unit tests (the
      # interpolations reach both keys and stay between them, the framing measure at its bounds,
      # a signed integer's one spelling, the timeline's starts and overlaps, a frame set's one
      # encoding) and tests/direction.rs (the committed corpus regenerates byte for byte from its
      # fixed seeds and no other file is there, wai-rs gives every case its stated outcome and
      # statements, §13 lists exactly the reference's codes, each of which the corpus gives, and
      # the corpus generates with the model file of wai.generate.spectral's conformance vector);
      # then the corpus's second implementation, direction_verify.py, written from the
      # extension's text and sharing no code with wai-rs, which runs the generator in its own
      # arithmetic after checking it against the generator's conformance vector, renders every
      # frame, interpolates every track, measures every box and writes every statement and C2PA
      # statement itself, reads records with synthesis_verify.py's strict JSON reader and every
      # signature with WAI's strict Ed25519 rule and BLAKE3 from claim-conformance, requires every
      # mutated copy of the corpus to fail, and drops each of its own checks in turn and requires
      # the corpus to catch the weakened verifier; standard library only, run isolated (-I).
      - name: direction records · wai-rs and direction_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features direction --lib direction::)
          (cd wai-rs && cargo test --no-default-features --features direction --test direction)
          python3 -I live-conformance/direction_verify.py live-conformance/direction
      # wai.live.coperformance (extensions/co-performance.md): the reference module's unit tests
      # (the policy and every statement round-trip and their rules refuse, the attributes'
      # decimal integers, a schedule's turns in bars and microseconds, the symbolic bodies read
      # whole) and tests/co_performance.rs (vectors.json regenerates byte for byte from its fixed
      # seeds and no other file is there, wai-rs gives every room its stated outcome, and §10
      # lists exactly the reference's codes, each of which the corpus gives); then the corpus's
      # second implementation, co_performance_verify.py, written from the extension's text and
      # sharing no code with wai-rs, which verifies each room with live_rooms_verify.py and every
      # signature with WAI's strict Ed25519 rule from claim-conformance, recomputes every intent,
      # fidelity statement, turn, floor, commitment, selection and credit, reads the extension's
      # reason table, requires every mutated copy of the corpus to fail, and drops each of its
      # own checks in turn and requires the corpus to catch the weakened verifier; standard
      # library only, run isolated (-I).
      - name: co-performance · wai-rs and co_performance_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features co_performance --lib co_performance::)
          (cd wai-rs && cargo test --no-default-features --features co_performance --test co_performance)
          python3 -I live-conformance/co_performance_verify.py live-conformance/coperformance
      # wai.age.assurance (extensions/age-assurance.md): the reference module's unit tests (the
      # pinned AlgorithmIdentifier and RFC 9578's first vector through this module, the
      # TokenChallenge read exactly, the suppression floor, the grant attribute `age`, a span's
      # coverage) and tests/age_assurance.rs (vectors.json regenerates byte for byte from its
      # fixed seeds and no other file is there, wai-rs gives every case its stated outcome, and
      # §11 lists exactly the reference's codes, each of which the corpus gives); then the
      # corpus's second implementation, age_assurance_verify.py, written from the extension's
      # text and sharing no code with wai-rs, which reads every record, writes JCS and verifies
      # every token's RSASSA-PSS itself, reads rooms with live_rooms_verify.py, checks signatures
      # with WAI's strict Ed25519 rule and BLAKE3 from claim-conformance, reads the extension's
      # reason table, requires every mutated copy of the corpus to fail, and drops each of its
      # own checks in turn and requires the corpus to catch the weakened verifier; standard
      # library only, run isolated (-I).
      - name: age assurance · wai-rs and age_assurance_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features age_assurance --lib age_assurance::)
          (cd wai-rs && cargo test --no-default-features --features age_assurance --test age_assurance)
          python3 -I live-conformance/age_assurance_verify.py live-conformance/age
      # wai.bearer.receipts (extensions/bearer-receipts.md): the reference module's unit tests
      # (the bound, the bitmap rules, the bearer classes, and the corpus reaching every stated
      # outcome and failing a changed one) and tests/bearer_receipts.rs (vectors.json
      # regenerates byte for byte from its fixed seeds and no other file is there, wai-rs gives
      # every case its stated outcome, the cases that carry one receipt on every bearer class
      # carry the same bytes with the same object verdicts, §10 lists exactly the reference's
      # codes, each of which the corpus gives, and jwp-receipts §3.1 lists the class codes at
      # their steps); then the corpus's second implementation, bearer_verify.py, written from
      # the extension's text and sharing no code with wai-rs, which verifies groups and objects
      # with jwp_verify.py, claims through jwp-receipts §3.1 steps 1-5 with claim_verify.py and
      # confirmations with signer_verify.py (each needs the `cryptography` package installed
      # above), writes the context checks, the verdict, the bound and offline confirmation
      # itself, reads the extension's reason table, requires every mutated copy of the corpus
      # to fail, and drops each of its own checks in turn and requires the corpus to catch the
      # weakened verifier; run isolated (-I). Last, claim-conformance's own verifier reads every
      # transmission and reconciliation claim of the corpus through jwp-receipts §3.1 steps 1
      # to 4 and requires the stated step and reason.
      - name: bearer receipts · wai-rs and bearer_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features bearer_receipts --lib bearer)
          (cd wai-rs && cargo test --no-default-features --features bearer_receipts --test bearer_receipts)
          python3 -I live-conformance/bearer_verify.py live-conformance/bearers
          python3 -I claim-conformance/claim_verify.py bearer live-conformance/bearers/vectors.json
      # wai.media.exploration (extensions/exploration.md): the reference module's unit tests (the
      # descriptors of flat, single-row and checkerboard pictures, grid bins at both ends, the
      # sample distance's zero, the taste score, derived prompts, and a schedule that replays and
      # keeps the first comer without an objective) and tests/exploration.rs (vectors.json
      # regenerates byte for byte from its fixed seeds and no other file is there, wai-rs gives
      # every generation, descriptor vector and case its stated outcome, §13 lists exactly the
      # reference's codes, each of which the corpus gives, and §3.2 names the reference's
      # descriptors); then the corpus's second implementation, exploration_verify.py, written from
      # the extension's text and sharing no code with wai-rs, which makes every picture with the
      # generator as the extension's Appendix A restates it, computes the descriptors, replays
      # every archive's schedule, reads usage statements with ai_usage_verify.py, verifies every
      # record with WAI's strict Ed25519 rule and BLAKE3 from claim-conformance, reads the
      # extension's reason table, requires every mutated copy of the corpus to fail, and drops each
      # of its own checks in turn and requires the corpus to catch the weakened verifier; standard
      # library only, run isolated (-I).
      - name: exploration · wai-rs and exploration_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features exploration --lib exploration::)
          (cd wai-rs && cargo test --no-default-features --features exploration --test exploration)
          python3 -I live-conformance/exploration_verify.py live-conformance/exploration
      # wai.live.e2ee (extensions/confidentiality.md): the corpus's second implementation,
      # e2ee_verify.py, written from the extension's text and the documents it reads and
      # sharing no code with the reference (joule-moq's secure_objects and joule-moq-mls,
      # whose own checks run in joule-code-conformance.yml). Standard library only, run
      # isolated (-I): AES, AES-GCM and RFC 9605's counter mode written from their
      # specifications for test vectors only, HKDF and HMAC from the standard library,
      # BLAKE3 and strict Ed25519 from claim-conformance. It checks every vector RFC 9605
      # and draft-ietf-moq-secure-objects-01 publish, every record, key schedule, sealed
      # object and room of vectors.json (taking each epoch's application secret as given,
      # §14), and requires every mutated copy of the corpus to fail.
      - name: end-to-end encrypted rooms · e2ee_verify.py
        working-directory: wai
        shell: bash
        run: python3 -I live-conformance/e2ee_verify.py live-conformance/e2ee
      # wai.live.watermark (extensions/forensic-watermark.md): the reference module's unit tests
      # (the CBOR reader's deterministic-encoding rules, tokens of both COSE structures and
      # every mode read and their rules refuse, a record's rules, big-endian bit addressing,
      # the exact match and the binding) and tests/live_watermark.rs (vectors.json regenerates
      # byte for byte from its fixed seeds and no other file is there, wai-rs gives every
      # token, session list, match and disclosure its stated outcome, and §11 lists exactly the
      # reference's codes, each of which the corpus gives); then the corpus's second
      # implementation, live_watermark_verify.py, written from the extension's text and sharing
      # no code with wai-rs, which reads rooms with live_rooms_verify.py and tokens with a CBOR
      # reader of its own, requires every mutated copy of the corpus to fail, and drops each of
      # its own checks in turn and requires the corpus to catch the weakened verifier; standard
      # library only, run isolated (-I).
      - name: forensic watermark sessions · wai-rs and live_watermark_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features live_watermark --lib live_watermark::)
          (cd wai-rs && cargo test --no-default-features --features live_watermark --test live_watermark)
          python3 -I live-conformance/live_watermark_verify.py live-conformance/watermark
      # wai.edge.derivation (extensions/deriving-edge.md): the reference module's unit tests
      # (the operations pixel by pixel, which operations the registry's composition rule makes
      # exact, the check each derivation takes, a record's reading rule by rule, its round trip
      # and signature, the pinned output manifest, provenance items and AI-origin labels, the
      # C2PA stores embedded in a still), the still writer and reader the module
      # shares with wai-pack (png_still), and tests/derive_edge.rs (vectors.json regenerates
      # byte for byte from its fixed seeds and no other file is there, wai-rs gives every vector
      # its stated outcome, §9 lists exactly the reference's codes and §4 its derivations, and
      # the reference edge wai_edge, run twice over a clip, makes a chain of two hops that
      # verifies and is refused once a byte changes); then the corpus's second implementation,
      # edge_verify.py, written from the extension's text and sharing no code with wai-rs,
      # which reads receipts and writes stills itself, re-executes every replicate hop,
      # requires every mutated copy of the corpus to fail, and drops each of its own checks in
      # turn and requires the corpus to catch the weakened verifier; standard library only,
      # run isolated (-I).
      - name: deriving edge · wai-rs and edge_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          (cd wai-rs && cargo test --no-default-features --features derive_edge --lib derive_edge::)
          (cd wai-rs && cargo test --no-default-features --features derive_edge --lib png_still::)
          (cd wai-rs && cargo test --no-default-features --features derive_edge --test derive_edge)
          python3 -I edge-conformance/edge_verify.py edge-conformance
      # The quantum corpus's second implementation (quantum-sim extension), integers only:
      # it derives the circuit/1 phase table by its recurrence and the circuit2 table by an
      # interval-certified procedure, and requires both literal tables and their digests,
      # and the extension's Appendix B to state the same;
      # rebuilds every file of both vector trees byte for byte and recomputes every manifest
      # entry with its own reader, simulator, sampler and BLAKE3; refuses every reject file
      # with its listed class and by the rule its name states; and requires dyadic_ladder
      # to see every ±1 change of every P(k) under both tables. Standard library only, run
      # isolated (-I), so no module from the working directory, the environment or the
      # user's site-packages is imported.
      - name: quantum referee.py
        shell: bash
        run: python3 -I wai/quantum-conformance/tools/referee.py wai/quantum-conformance
      # chain_differential.py signs receipt chains around jwp-receipts §3 step 3 and §6.1
      # (two keys, two tracks, both payloads, replays, forks, gaps, the guard and the
      # freshness bound), and chain_gap_differential.py genuine chains up to 90 groups
      # delivered shuffled, withheld and walked back with rewritten links and forks; both
      # require wai_jwp_vectors and jwp_verify.py to give every chain the same verdict. Two
      # fixed seeds each, so a run is reproducible.
      - name: claim_verify.py, differential.py, jwp_verify.py, chain_differential.py, chain_gap_differential.py, signer_verify.py
        working-directory: wai
        shell: bash
        run: |
          set -euo pipefail
          python3 claim-conformance/claim_verify.py claim-conformance/vectors.json
          python3 claim-conformance/differential.py "$GITHUB_WORKSPACE/wai/wai-rs/target/debug/wai_claim_vectors" --random 2000 --seed 1
          python3 jwp-conformance/jwp_verify.py jwp-conformance/vectors.json
          for seed in 1 2; do
            python3 jwp-conformance/chain_differential.py "$GITHUB_WORKSPACE/wai/wai-rs/target/debug/wai_jwp_vectors" --n 3000 --seed "$seed"
            python3 jwp-conformance/chain_gap_differential.py "$GITHUB_WORKSPACE/wai/wai-rs/target/debug/wai_jwp_vectors" --n 400 --seed "$seed"
          done
          python3 signer-conformance/signer_verify.py signer-conformance/vectors.json
          python3 signer-conformance/signer_verify.py verdicts signer-conformance/vectors.json > "$RUNNER_TEMP/signer-py.tsv"
          "$GITHUB_WORKSPACE/wai/wai-rs/target/debug/wai_signer_vectors" verdicts signer-conformance/vectors.json > "$RUNNER_TEMP/signer-rs.tsv"
          diff "$RUNNER_TEMP/signer-py.tsv" "$RUNNER_TEMP/signer-rs.tsv"

  # Delivery telemetry's second implementation is an independent open-source CMCD and CMSD
  # library at locked versions (telemetry-conformance/cml/package-lock.json). The
  # differential builds each observation's report from the extension's tables, encodes it
  # with the library, requires the bytes of expected/cmcd.json and expected/cmsd.json, reads
  # the expected strings back as dictionary, query and header shards, and validates every
  # report with no error. One platform: string encoding, not arithmetic.
  telemetry-differential:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: delivery telemetry · CMCD and CMSD against an independent library
    runs-on: linux-arm64
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
      - name: npm ci, then the differential
        working-directory: wai/telemetry-conformance/cml
        shell: bash
        run: |
          set -euo pipefail
          npm ci --no-audit --no-fund
          node differential.mjs ..

  byte-exact:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: cross-arch byte-equality · ${{ matrix.os }}
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      matrix:
        # Self-hosted fleet labels. Both architectures: x86_64 by linux, arm64
        # by linux-arm64 + macos — what matters for the Fx integer floor is the
        # arch, not the OS. No Intel-Mac runner exists in the fleet, and it
        # would add no arch coverage anyway.
        # Windows x86_64 leg removed 2026-09-30: runner offline. Restore by
        # re-adding `windows` here once the runner is back online.
        os: [linux, linux-arm64, macos]
    steps:
      - uses: actions/checkout@v5

      - name: Install Rust 1.98.0 (unix)
        if: matrix.os != 'windows'
        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"
      - name: Install Rust 1.98.0 (Windows)
        if: matrix.os == 'windows'
        shell: pwsh
        run: |
          rustup toolchain install 1.98.0 --profile minimal
          rustup default 1.98.0

      - name: Integer rANS + int_synth + JPEG-AI mANS goldens (one machine → every machine)
        working-directory: wai/byte-exact-conformance
        run: cargo test --release

  # The codec wrappers are behind `codecs`, which binds C and C++ libraries that no
  # container image of this fleet carries, so no other job compiles them. A feature no
  # workflow enables has no CI coverage at all: without this job the wrappers' tests,
  # and the limits on what a text payload may decode to (SPEC §2), pass by not running.
  #
  # One platform, the `macos` runner, whose host has the libraries. What the job proves
  # is how the wrappers treat hostile bytes and where their limits fall, which is the
  # same code on every host. A missing library fails the build step by name.
  codec-wrappers:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: codec wrappers · fuzz smoke, text decode limits, C entry points, provenance, the semantic path
    runs-on: macos
    steps:
      - uses: actions/checkout@v5

      - name: Install Rust 1.98.0
        shell: bash
        run: |
          export PATH="$HOME/.cargo/bin:$PATH"
          rustup toolchain install 1.98.0 --profile minimal
          rustup default 1.98.0
          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"

      # Every one of these test files is `#![cfg(feature = "codecs")]`: built without
      # the feature each reports "0 passed" and exits 0. So the step names the feature,
      # and then requires that each of the five binaries ran at least one test.
      - name: Fuzz smoke, the text and media decode limits and the C entry points
        working-directory: wai/wai-rs
        shell: bash
        run: |
          set -o pipefail
          cargo test --locked --features codecs \
            --test fuzz_smoke --test text_decode_bounds --test text_decode_memory \
            --test media_decode_bounds --test ffi_robustness \
            2>&1 | tee "$RUNNER_TEMP/codec-wrappers.log"
          ran=$(grep -cE '^test result: ok\. [1-9][0-9]* passed' "$RUNNER_TEMP/codec-wrappers.log" || true)
          if [ "$ran" -ne 5 ]; then
            echo "::error::expected five test binaries that each ran tests; $ran did"
            exit 1
          fi

      # wai_prov needs `codecs`, so no other job builds it. Its --carry path writes the
      # provenance asset and receipt that wai-web's reach vectors commit: carried onto
      # its own receipt, a run must write both again byte for byte. A receipt changed
      # by one byte must be refused, which shows the comparison is not vacuous.
      - name: wai_prov carries the committed provenance receipt, byte for byte
        working-directory: wai/wai-rs
        shell: bash
        run: |
          set -euo pipefail
          cargo build --locked --features provenance,codecs,receipt_claims --bin wai_prov
          bin="${CARGO_TARGET_DIR:-target}/debug/wai_prov"
          v=../wai-web/reach/test/vectors/provenance
          "$bin" "$RUNNER_TEMP/prov" --carry "$v/captured.receipt.json"
          cmp "$RUNNER_TEMP/prov/captured.jpeg.wai" "$v/captured.jpeg.wai"
          cmp "$RUNNER_TEMP/prov/captured.receipt.json" "$v/captured.receipt.json"
          sed 's/"encode.jpeg"/"encode.jpeh"/' "$v/captured.receipt.json" > "$RUNNER_TEMP/changed.receipt.json"
          if cmp -s "$RUNNER_TEMP/changed.receipt.json" "$v/captured.receipt.json"; then
            echo "::error::the changed receipt is not changed"; exit 1
          fi
          if "$bin" "$RUNNER_TEMP/prov-changed" --carry "$RUNNER_TEMP/changed.receipt.json"; then
            echo "::error::a changed receipt was carried"; exit 1
          fi

      # tests/semantic_path.rs needs `semantic`, which builds on `codecs` and binds the
      # ONNX runtime, so this is the one job that can run it.
      - name: The semantic path
        working-directory: wai/wai-rs
        shell: bash
        run: |
          set -o pipefail
          cargo test --locked --features codecs,semantic --test semantic_path 2>&1 | tee "$RUNNER_TEMP/semantic-path.log"
          ran=$(grep -cE '^test result: ok\. [1-9][0-9]* passed' "$RUNNER_TEMP/semantic-path.log" || true)
          if [ "$ran" -ne 1 ]; then
            echo "::error::the semantic path's test binary ran no test"
            exit 1
          fi

  # The C2PA emitter is gated behind an off-by-default feature, so the four-platform
  # job above — which builds a fixed feature list — never compiles it. A feature no
  # workflow enables has no CI coverage at all: the suite passes, and the tests in it
  # simply do not run.
  #
  # One platform, deliberately. Everything the matrix above exists to prove is about
  # byte-identical reconstruction across architectures; a signed manifest makes no
  # such claim and would not become more true for being emitted on four machines. What
  # this job proves is that the manifest is still well-formed, still carries the three
  # assertions, and still validates — which is architecture-independent.
  c2pa-emitter:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: C2PA manifest emission · signed, read back, validated
    runs-on: linux-arm64
    steps:
      - uses: actions/checkout@v4

      - 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"

      # `rust_native_crypto` rather than the SDK's default openssl backend, so this
      # job needs no system libraries — the same property the matrix above depends on.
      # Asserted, not assumed: an openssl-linked build would still pass the tests here
      # while quietly making the crate undistributable to a bare runner.
      - name: The emitter pulls in no system crypto
        working-directory: wai/wai-rs
        shell: bash
        run: |
          for dep in openssl openssl-sys; do
            if cargo tree --no-default-features --features c2pa_emit -i "$dep" >/dev/null 2>&1; then
              echo "::error::$dep reached the c2pa_emit dependency graph"
              exit 1
            fi
          done
          echo "no system crypto in the graph"

      - name: Emit, sign, read back, validate
        working-directory: wai/wai-rs
        run: cargo test --lib --no-default-features --features c2pa_emit c2pa_emit

      # A room-session receipt (extensions/live-metering.md §7) in a real signed manifest:
      # energy_kwh only where one class covers the session whole, the companion always.
      - name: Emit a room-session receipt, sign, read back, validate
        working-directory: wai/wai-rs
        run: cargo test --lib --no-default-features --features c2pa_emit,live_metering c2pa_emit::tests::a_session

      # The feature must stay optional. If `provenance` ever pulls c2pa in, every
      # consumer that wanted only the binding types inherits a large dependency tree
      # they did not ask for, and the "off by default" claim in the extension is false.
      - name: The feature stays optional
        working-directory: wai/wai-rs
        shell: bash
        run: |
          if cargo tree --no-default-features --features provenance -i c2pa >/dev/null 2>&1; then
            echo "::error::c2pa is reachable from the provenance feature; it must stay opt-in"
            exit 1
          fi
          cargo build --no-default-features --features provenance
          echo "provenance builds without c2pa"