name: wai-ops-gpu integer operators on GPUs

# wai-ops/1-i32 on GPUs (wai/wai-ops-gpu): the integer operator set's graph operators
# as WGSL kernels through wgpu, exact at acc32 (one 32-bit word per value) and at acc64
# (64- and 128-bit arithmetic built from 32-bit words), and the integer decoders with
# their graphs on the device (wai-rs `ops_gpu`).
#
#   - metal (the `macos` runner, whose host has a GPU): WGSL's integer semantics
#     (wai/wgsl-conformance, determinism-tiers §5, Claiming the tier on a GPU), the
#     committed vectors and SplitMix64 cases of every operation, with an edited kernel
#     refused at discovery; the arithmetic probe on a
#     million cases; every graph vector of wai/ops-conformance that the subset covers,
#     at both widths, against the committed results and the interpreter; the shader
#     mutants, every one of which the corpus must catch; every committed vector and
#     refusal fixture of every capability that runs a wai-ops/1 graph, the jpegai/v1
#     inputs included, against the decode on the CPU; the exact-upscale derivations and
#     the face generator's frames, against the CPU's; and the corpus again in a
#     headless browser's WebGPU, the kernels compiled by the browser's own WGSL
#     compiler, with the semantics suite there and its vectors held to the reference
#     compiled to wasm32, in the page and under Node. Then the integer neural decoders in
#     that browser with their graphs on its WebGPU (wai-web's `neural_webgpu` bundle,
#     demo/verify_int_neural_webgpu.mjs): each committed int_hyper, int_hyper video and
#     int_synth vector equal to its pinned bytes and to the page's CPU decode, and a
#     floating-point product planted in the kernels and a changed weight each caught,
#     and each clip's measured times dispatched as the deadline gives. WAI_OPS_GPU_EXPECT declares the one adapter the host must offer, and
#     WAI_OPS_GPU_REQUIRE makes an absent adapter a failure, never a skip; each step
#     then requires the report lines with their counts, so a filtered or empty run
#     fails too. The splat renderer's compositing (extensions/splat-exact.md) runs there
#     too: every view of the splat corpus equal to the CPU's frame, and its mutants caught.
#   - checks (`linux`, a container with no GPU): the crate and its tests build; the
#     WGSL rules on naga's IR (tests/wgsl_rules.rs) and the committed semantics vectors
#     against the reference, which need no adapter, pass; the device tests print SKIPPED
#     and pass, and the same tests under
#     WAI_OPS_GPU_REQUIRE=1 fail: an absent adapter is not a pass. The browser module
#     builds for wasm32-unknown-unknown; the bench tool builds. The decode answered from
#     outside (wai-rs `ops_offload`, the path a page's WebGPU takes) passes its tests, the
#     keyframe tool builds, wai-web's `neural_webgpu` bundle builds for wasm32, and its
#     dispatch half passes its tests.
#   - vulkan (`linux-amd`, framework-128gb, its integrated GPU; `linux-hw`, jetson-hub, its
#     discrete and integrated GPUs; on each the software Vulkan driver too): the crate's tests
#     as on Metal, and every committed vector and refusal fixture of every capability that
#     runs a wai-ops/1 graph, the jpegai/v1 inputs included, against the decode on the CPU, on
#     every adapter the host declares in WAI_OPS_GPU_EXPECT, under WAI_OPS_GPU_REQUIRE.
#
# The first runs on those adapters were by hand, and are recorded in
# wai/extensions/determinism-tiers.md §6.

# One run per branch at a time; a push supersedes the run before it.
concurrency:
  group: ${{ github.workflow }}-${{ github.event_name == 'push' && github.sha || github.ref }}
  cancel-in-progress: true

on:
  pull_request:
    paths:
      - 'wai/wai-ops-gpu/**'
      - 'wai/wai-ops/**'
      - 'wai/ops-conformance/**'
      - 'wai/wgsl-conformance/**'
      # The decoders whose graphs run on the device, and what they decode.
      - 'wai/wai-rs/Cargo.toml'
      - 'wai/wai-rs/Cargo.lock'
      - 'wai/wai-rs/src/int_*.rs'
      - 'wai/wai-rs/src/int_payload/**'
      - 'wai/wai-rs/src/jpegai_*.rs'
      - 'wai/wai-rs/tests/ops_gpu.rs'
      # The exact-upscale derivations' graph on the device, under the corpus's priors.
      - 'wai/wai-rs/src/exact_upscale.rs'
      - 'wai/wai-rs/src/exact_upscale/**'
      - 'wai/wai-rs/tests/exact_upscale_gpu.rs'
      - 'wai/live-conformance/upscale/priors/**'
      - 'wai/wai-rs/src/dred_exact/**'
      - 'wai/wai-rs/tests/dred_exact_gpu.rs'
      - 'wai/live-conformance/dred/**'
      # The splat renderer's compositing on the device (extensions/splat-exact.md), and the
      # scenes it is held to.
      - 'wai/wai-rs/src/splat_exact.rs'
      - 'wai/wai-rs/src/splat_exact/**'
      - 'wai/wai-rs/tests/splat_exact_gpu.rs'
      - 'wai/live-conformance/splat/**'
      # The face generator's graph on the device, over the corpus's frames.
      - 'wai/wai-rs/src/avatar_face.rs'
      - 'wai/wai-rs/src/avatar_face/**'
      - 'wai/wai-rs/tests/avatar_face_gpu.rs'
      - 'wai/live-conformance/avatar-face/**'
      - 'wai/wai-rs/tests/vectors/**'
      - 'wai/int-payload-conformance/**'
      - 'wai/neural-conformance/**'
      - 'wai/tools/ops-gpu-bench/**'
      # The integer neural decoders on a page's WebGPU (wai-web `neural_webgpu`), and the
      # keyframe tool that holds a keyframe to the CPU's bytes on each adapter.
      - 'wai/wai-rs/examples/int_hyper_keyframe_gpu.rs'
      - 'wai/wai-web/Cargo.toml'
      - 'wai/wai-web/Cargo.lock'
      - 'wai/wai-web/src/neural_webgpu.rs'
      - 'wai/wai-web/src/neural_leg.rs'
      - 'wai/wai-web/src/neural_int.rs'
      - 'wai/wai-web/src/video.rs'
      - 'wai/wai-web/src/int_payload.rs'
      - 'wai/wai-web/demo/int_neural_webgpu.html'
      - 'wai/wai-web/demo/verify_int_neural_webgpu.mjs'
      - 'wai/tools/wai_jpegai_fetch_e2e_inputs.sh'
      - 'wai/tools/jpegai-e2e-v1.sha256'
      - 'rust-toolchain.toml'
      - '.github/workflows/wai-ops-gpu.yml'
  schedule:
    - cron: '17 6 * * *'

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: gate
    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-ops-gpu.yml \
                "${{ github.event.pull_request.base.sha }}" \
                "${{ github.event.pull_request.head.sha }}")
          echo "this change touches wai-ops-gpu: $r"
          echo "run=$r" >> "$GITHUB_OUTPUT"

  checks:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: builds · no adapter is not a pass (linux)
    runs-on: linux
    timeout-minutes: 60
    steps:
      - uses: actions/checkout@v5
      - name: Install Rust 1.99.1 with the wasm32-unknown-unknown 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.99.1
          rustup toolchain install 1.99.1 --profile minimal
          rustup default 1.99.1
          rustup target add --toolchain 1.99.1 wasm32-unknown-unknown
          echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
      # This container offers no adapter. The device tests must say so and pass; under
      # WAI_OPS_GPU_REQUIRE=1 the same tests must fail. Were an adapter ever offered
      # here, its results must then be equal instead.
      - name: The crate's tests, and an absent adapter under WAI_OPS_GPU_REQUIRE
        shell: bash
        working-directory: wai/wai-ops-gpu
        run: |
          set -euo pipefail
          log="$RUNNER_TEMP/ops-gpu.log"
          rep="$RUNNER_TEMP/ops-gpu.report"
          : > "$rep"
          WAI_OPS_GPU_REPORT="$rep" cargo test --locked --release -- --nocapture --test-threads=1 2>&1 | tee "$log"
          if grep -q '^ops-gpu corpus: key=' "$rep"; then
            echo "this runner offered an adapter"
            if grep -E '^ops-gpu corpus: key=' "$rep" | grep -vq ' mismatches=0 errors=0 '; then
              echo "::error::an adapter here gave a result that is not the interpreter's"; exit 1
            fi
          else
            grep -q '^ops-gpu corpus: SKIPPED' "$rep" || { echo "::error::the corpus test printed neither a result nor SKIPPED"; exit 1; }
            if WAI_OPS_GPU_REQUIRE=1 cargo test --locked --release --test corpus --test arith --test mutants --test semantics > "$RUNNER_TEMP/require.log" 2>&1; then
              echo "::error::with no adapter, the device tests passed under WAI_OPS_GPU_REQUIRE=1"; exit 1
            fi
            grep -q 'WAI_OPS_GPU_REQUIRE is set' "$RUNNER_TEMP/require.log" \
              || { echo "::error::the tests failed under WAI_OPS_GPU_REQUIRE=1, but not for the absent adapter"; cat "$RUNNER_TEMP/require.log"; exit 1; }
            echo "no adapter: SKIPPED without WAI_OPS_GPU_REQUIRE, a failure with it"
          fi
      - name: The browser module builds for wasm32-unknown-unknown
        working-directory: wai/wai-ops-gpu/browser
        run: cargo build --locked --release --target wasm32-unknown-unknown
      - name: wai-rs builds with ops_gpu, and its GPU test targets
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          cargo test --locked --no-default-features --features ops_gpu,video_int,audio_int,splat_int,world_int --test ops_gpu --no-run
          cargo test --locked --no-default-features --features ops_gpu,exact_upscale --test exact_upscale_gpu --no-run
          cargo test --locked --no-default-features --features splat_exact,ops_gpu --test splat_exact_gpu --no-run
          cargo test --locked --no-default-features --features ops_gpu,avatar_face --test avatar_face_gpu --no-run
      - name: wai-rs builds the DRED profile's GPU test target
        working-directory: wai/wai-rs
        run: cargo test --locked --no-default-features --features dred_exact,ops_gpu --test dred_exact_gpu --no-run
      - name: The bench tool builds
        working-directory: wai/tools/ops-gpu-bench
        run: cargo build --locked --release
      # A decode's graph runs answered from outside it (int_ops::offload): the same bytes as
      # the decode on its own, an answer that is not the interpreter's used, and a held answer
      # for other inputs dropped. Then the keyframe tool, the page's bundle, and its dispatch
      # half (wai-web neural_leg): the deadline to the microsecond, and a report routed
      # and chosen with the leg it gives, the clip routed only where it keeps up.
      - name: The offload path's tests, the keyframe tool, and the neural_webgpu bundle
        shell: bash
        run: |
          set -euo pipefail
          log="$RUNNER_TEMP/offload.log"
          (cd wai/wai-rs && cargo test --locked --release --no-default-features --features ops_offload --lib int_ops::offload 2>&1 | tee "$log")
          grep -q '^test result: ok\. 3 passed; 0 failed; 0 ignored' "$log" || { echo "::error::the three offload tests did not run and pass"; exit 1; }
          (cd wai/wai-rs && cargo build --locked --release --no-default-features --features ops_gpu,ops_offload,video_int --example int_hyper_keyframe_gpu)
          (cd wai/wai-web && cargo build --locked --release --target wasm32-unknown-unknown --features neural_webgpu)
          # Its own target directory where the runner shares one: built after wai-rs's builds
          # with other features in a shared directory, wai-web's test linked a `wai` without its
          # features (seen on the arm64 build host, 2026-11-09).
          (cd wai/wai-web && if [ -n "${CARGO_TARGET_DIR:-}" ]; then export CARGO_TARGET_DIR="$CARGO_TARGET_DIR/neural-dispatch"; fi
           cargo test --locked --release --lib --features neural_webgpu neural_leg:: 2>&1 | tee "$RUNNER_TEMP/dispatch.log")
          grep -q '^test result: ok\. 5 passed; 0 failed; 0 ignored' "$RUNNER_TEMP/dispatch.log" || { echo "::error::the five dispatch tests did not run and pass"; exit 1; }

  metal:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: Metal GPU and browser WebGPU (macos)
    runs-on: macos
    timeout-minutes: 120
    env:
      WAI_OPS_GPU_EXPECT: gpu-metal-0
      WAI_OPS_GPU_REQUIRE: '1'
    steps:
      - uses: actions/checkout@v5
      # launchd's PATH omits cargo on the macOS host runner.
      - name: Put cargo on PATH
        shell: bash
        run: echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
      - name: The probe, the corpus at both widths, and the mutants, on the GPU
        shell: bash
        working-directory: wai/wai-ops-gpu
        run: |
          set -euo pipefail
          log="$RUNNER_TEMP/ops-gpu.log"
          export WAI_OPS_GPU_REPORT="$RUNNER_TEMP/ops-gpu.report"
          : > "$WAI_OPS_GPU_REPORT"
          nice -n 10 cargo test --locked --release -- --nocapture --test-threads=1 2>&1 | tee "$log"
          k=gpu-metal-0
          # Seventeen tests in six binaries: the library's four, arith's two, corpus's two,
          # mutants' one, semantics' three and wgsl_rules' five, none filtered, ignored or
          # failed.
          ran=$(awk '/^test result: ok\. [0-9]+ passed; 0 failed; 0 ignored; 0 measured; 0 filtered out/ { n += $4 } END { print n + 0 }' "$log")
          [ "$ran" = 17 ] || { echo "::error::$ran tests ran and passed, not 17"; exit 1; }
          ! grep -q '^test result: FAILED' "$log" || { echo "::error::a test failed"; exit 1; }
          grep -qxF "ops-gpu adapters: as declared ($k)" "$WAI_OPS_GPU_REPORT" || { echo "::error::the adapters found are not $k"; exit 1; }
          grep -qE "^ops-gpu arith: key=$k .* cases=[0-9]+ words=[0-9]+ equal$" "$WAI_OPS_GPU_REPORT" || { echo "::error::no probe result for $k"; exit 1; }
          grep -qE "^ops-gpu corpus: key=$k .* acc32 vectors=[1-9][0-9]* decodes=[1-9][0-9]*; acc64 vectors=[1-9][0-9]* decodes=[1-9][0-9]*; .* mismatches=0 errors=0 " "$WAI_OPS_GPU_REPORT" \
            || { echo "::error::no equal corpus run for $k"; exit 1; }
          grep -qxF "ops-gpu mutants: key=$k killed 18 of 18" "$WAI_OPS_GPU_REPORT" || { echo "::error::a mutant survived on $k, or the mutant test did not run"; exit 1; }
          grep -qE "^ops-gpu semantics: key=$k .* committed=[1-9][0-9]* cases=[1-9][0-9]* guarded=[1-9][0-9]* differ=0 " "$WAI_OPS_GPU_REPORT" \
            || { echo "::error::no run of WGSL's integer semantics on $k with every guarded case equal"; exit 1; }
          grep -qE "^ops-gpu semantics mutant: key=$k refused: the WGSL semantics suite: rem_i32 " "$WAI_OPS_GPU_REPORT" \
            || { echo "::error::the edited semantics kernel was not refused on $k"; exit 1; }
      - name: The jpegai/v1 inputs
        shell: bash
        run: bash wai/tools/wai_jpegai_fetch_e2e_inputs.sh "$RUNNER_TEMP/jpegai"
      - name: Every capability that runs a wai-ops/1 graph, with its graphs on the GPU
        shell: bash
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          log="$RUNNER_TEMP/ops-gpu-rs.log"
          rep="$RUNNER_TEMP/ops-gpu-rs.report"
          : > "$rep"
          J="$RUNNER_TEMP/jpegai"
          WAI_OPS_GPU_REPORT="$rep" WAI_JPEGAI_CODESTREAM="$J/test256.bin" WAI_JPEGAI_WEIGHTS_DIR="$J" WAI_JPEGAI_NORM="$J/norm.json" WAI_REQUIRE_SOTA_VECTORS=1 \
            nice -n 10 cargo test --locked --release --no-default-features --features ops_gpu,video_int,audio_int,splat_int,world_int \
            --test ops_gpu -- --nocapture 2>&1 | tee "$log"
          grep -q '^test result: ok\. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' "$log" || { echo "::error::the capability test did not run and pass"; exit 1; }
          for cap in wai.neural.int_hyper wai.video.int_hyper wai.audio.int_codec wai.splat.int_codec wai.neural.int_synth \
                     wai.neural.int_mlicpp wai.world.model wai.image.jpegai; do
            grep -qE "^ops-gpu capability: key=gpu-metal-0 .* cap=$cap cases=[1-9][0-9]* .* differ=0 errors=0$" "$rep" \
              || { echo "::error::$cap: no equal run on the GPU"; exit 1; }
          done
      # The exact-upscale derivations (extensions/exact-upscale.md §3.4): under every prior of the
      # corpus, sr2 and sr4 give the same bytes with their graph on the device as on the CPU,
      # every graph run on the device and compared with the interpreter.
      - name: The exact-upscale derivations with their graph on the GPU
        shell: bash
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          log="$RUNNER_TEMP/exact-upscale-gpu.log"
          rep="$RUNNER_TEMP/exact-upscale-gpu.report"
          : > "$rep"
          WAI_OPS_GPU_REPORT="$rep" nice -n 10 cargo test --locked --release --no-default-features --features ops_gpu,exact_upscale \
            --test exact_upscale_gpu -- --nocapture 2>&1 | tee "$log"
          grep -q '^test result: ok\. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' "$log" || { echo "::error::the test did not run and pass"; exit 1; }
          grep -qE "^exact-upscale gpu: key=gpu-metal-0 .* cases=[1-9][0-9]* .* cpu=0 .* differ=0 errors=0 equal$" "$rep" \
            || { echo "::error::no equal run on the GPU"; exit 1; }
      # wai.audio.opus.dred.int (extensions/opus-dred.md §4.8): the corpus's payloads and its
      # streams' reconstructions decoded with both graphs of dred-int/1 on the GPU at acc64, every graph also run on the
      # interpreter and compared, and the decode's integers held to the CPU's. The weights file
      # is fetched and checked against the draft's digest (live-conformance/dred/fetch.sh).
      - name: The DRED profile, with its graphs on the GPU
        shell: bash
        run: |
          set -euo pipefail
          d="$RUNNER_TEMP/dred"
          bash wai/live-conformance/dred/fetch.sh "$d"
          log="$RUNNER_TEMP/dred-gpu.log"
          rep="$RUNNER_TEMP/dred-gpu.report"
          : > "$rep"
          cd wai/wai-rs
          WAI_OPS_GPU_REPORT="$rep" WAI_DRED_WEIGHTS="$d/dred_unquantized_weights.bin" \
            nice -n 10 cargo test --locked --release --no-default-features --features dred_exact,ops_gpu \
            --test dred_exact_gpu -- --nocapture 2>&1 | tee "$log"
          grep -q '^test result: ok\. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' "$log" || { echo "::error::the DRED GPU test did not run and pass"; exit 1; }
          grep -qE "^dred-gpu: key=gpu-metal-0 payloads=[1-9][0-9]* streams=[1-9][0-9]* same=true graphs_on_gpu=[1-9][0-9]* .* on_cpu=0 compared=[1-9][0-9]* differed=0 errors=\[\]$" "$rep" \
            || { echo "::error::no equal DRED run on the GPU"; exit 1; }
      # wai-splat-render:i1 (extensions/splat-exact.md §5.6-§5.7) with its compositing on the
      # GPU: every canonical and own-pose view of every scene of live-conformance/splat/ equal to
      # the CPU's frame byte for byte, and each edited kernel caught.
      - name: The splat renderer's compositing on the GPU
        shell: bash
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          log="$RUNNER_TEMP/splat-gpu.log"
          rep="$RUNNER_TEMP/splat-gpu.report"
          : > "$rep"
          WAI_OPS_GPU_REPORT="$rep" nice -n 10 cargo test --locked --release --no-default-features --features splat_exact,ops_gpu \
            --test splat_exact_gpu -- --nocapture 2>&1 | tee "$log"
          grep -q '^test result: ok\. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' "$log" || { echo "::error::the splat GPU test did not run and pass"; exit 1; }
          grep -qE '^splat-exact gpu: key=gpu-metal-0 views=[1-9][0-9]* differ=0 mutants_survived=0 ' "$rep" \
            || { echo "::error::no equal splat run on gpu-metal-0, or a mutant survived"; exit 1; }
      # The face generator (extensions/avatars.md §7.8): every frame the avatar-face corpus
      # names, from the seeded and the registered generator, is the CPU's frame and the corpus's
      # digest with the generator's graph on the device, every graph run on the device and
      # compared with the interpreter.
      - name: The face generator's frames with its graph on the GPU
        shell: bash
        working-directory: wai/wai-rs
        run: |
          set -euo pipefail
          log="$RUNNER_TEMP/avatar-face-gpu.log"
          rep="$RUNNER_TEMP/avatar-face-gpu.report"
          : > "$rep"
          WAI_OPS_GPU_REPORT="$rep" nice -n 10 cargo test --locked --release --no-default-features --features ops_gpu,avatar_face \
            --test avatar_face_gpu -- --nocapture 2>&1 | tee "$log"
          grep -q '^test result: ok\. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' "$log" || { echo "::error::the test did not run and pass"; exit 1; }
          grep -qE "^face-gpu: key=gpu-metal-0 frames=[1-9][0-9]* same=true graphs_on_gpu=[1-9][0-9]* .* on_cpu=0 .* differed=0 errors=\[\] " "$rep" \
            || { echo "::error::no equal run on the GPU"; exit 1; }
      - name: wasm-bindgen CLI 0.2.127, and the wasm32-unknown-unknown target
        shell: bash
        run: |
          set -euo pipefail
          rustup target add wasm32-unknown-unknown
          cargo install --locked wasm-bindgen-cli --version 0.2.127
      # Playwright and its headless browser go into the job's temporary directory, not
      # the host's caches. `chromium` is Playwright's name for its engine.
      - name: Playwright 1.60.0 and its headless browser
        shell: bash
        run: |
          set -euo pipefail
          pw="$RUNNER_TEMP/playwright"
          mkdir -p "$pw"
          npm install --prefix "$pw" --no-save --no-audit --no-fund playwright@1.60.0
          PLAYWRIGHT_BROWSERS_PATH="$pw/browsers" "$pw/node_modules/.bin/playwright" install --only-shell chromium
          echo "PLAYWRIGHT_HOST=$pw/" >> "$GITHUB_ENV"
          echo "PLAYWRIGHT_BROWSERS_PATH=$pw/browsers" >> "$GITHUB_ENV"
      - name: The corpus in a browser's WebGPU
        shell: bash
        working-directory: wai/wai-ops-gpu/browser
        run: |
          set -euo pipefail
          nice -n 10 cargo build --locked --release --target wasm32-unknown-unknown
          t="${CARGO_TARGET_DIR:-target}"
          wasm-bindgen --target web --out-dir pkg --out-name wai_ops_gpu_browser "$t/wasm32-unknown-unknown/release/wai_ops_gpu_browser.wasm"
          # The committed semantics vectors against the reference compiled to wasm32,
          # under Node, with no GPU.
          node semantics_reference.mjs
          log="$RUNNER_TEMP/browser.log"
          nice -n 10 node run.mjs 2>&1 | tee "$log"
          grep -qE '^browser webgpu: key=gpu-webgpu-[0-9a-f]+ .* acc32 vectors=[1-9][0-9]* decodes=[1-9][0-9]*; acc64 vectors=[1-9][0-9]* decodes=[1-9][0-9]*; .* mismatches=0 errors=0$' "$log" \
            || { echo "::error::no equal corpus run on a GPU adapter in the browser"; exit 1; }
          grep -qE '^wasm reference: target=wasm32 .* cases=[1-9][0-9]* equal$' "$log" \
            || { echo "::error::the semantics vectors are not the wasm32 reference's in the page"; exit 1; }
          grep -qE '^browser webgpu semantics: key=gpu-webgpu-[0-9a-f]+ .* guarded=[1-9][0-9]* differ=0 ' "$log" \
            || { echo "::error::no run of WGSL's integer semantics on a GPU adapter in the browser with every guarded case equal"; exit 1; }
      # The integer neural decoders with their graphs on the browser's WebGPU: the committed
      # vectors, each equal to its pinned bytes and to the page's CPU decode, the two planted
      # changes caught, and the int_hyper clip's measured times routed and chosen on each
      # path as the deadline and §4.7 give (demo/verify_int_neural_webgpu.mjs). Chromium only: the job
      # installs no other engine.
      - name: The integer neural decoders on the browser's WebGPU
        shell: bash
        working-directory: wai/wai-web
        run: |
          set -euo pipefail
          nice -n 10 cargo build --locked --release --target wasm32-unknown-unknown --features neural_webgpu
          t="${CARGO_TARGET_DIR:-target}"
          wasm-bindgen --target web --out-dir demo/pkg-neural-webgpu --out-name wai_web_neural_webgpu "$t/wasm32-unknown-unknown/release/wai_web.wasm"
          log="$RUNNER_TEMP/int-neural.log"
          WAI_INT_NEURAL_ENGINES=chromium WAI_INT_NEURAL_REQUIRE=1 nice -n 10 node demo/verify_int_neural_webgpu.mjs 2>&1 | tee "$log"
          grep -qE '^chromium: int-neural open: path=webgpu key=gpu-webgpu-' "$log" || { echo "::error::the page did not open a GPU adapter"; exit 1; }
          sum=$(grep -E '^chromium: int-neural webgpu: path=webgpu cases=[0-9]+ equal=[0-9]+ planted_float_op=1/1 changed_weight=1/1 dispatch=2/2$' "$log" || true)
          n=$(printf '%s' "$sum" | sed -E 's/.* cases=([0-9]+) equal=([0-9]+) .*/\1 \2/')
          [ -n "$sum" ] && [ "${n% *}" = "${n#* }" ] && [ "${n% *}" -ge 6 ] \
            || { echo "::error::a case was not equal on the browser's WebGPU, a planted change was not caught, or a dispatch was not the deadline's"; exit 1; }
          grep -qxF 'chromium: PASS' "$log" || { echo "::error::the run did not pass"; exit 1; }

  # The same on Vulkan, on the two hosts whose GPUs this fleet's runners reach: framework-128gb
  # (`linux-amd`, its integrated GPU) and jetson-hub (`linux-hw`, its discrete and integrated
  # GPUs), each with the software Vulkan driver beside them. WAI_OPS_GPU_EXPECT declares every
  # adapter the host must offer, and WAI_OPS_GPU_REQUIRE makes an absent one a failure, never a
  # skip: a host whose Vulkan finds no device, or finds another set of adapters, fails here. The
  # crate's tests (the probe, the corpus at both widths, the mutants and WGSL's integer
  # semantics) and the decoders' corpus (every committed vector and refusal fixture of every
  # capability that runs a wai-ops/1 graph, its graphs on the device and compared with the
  # interpreter, the decode compared with the CPU's) run on every declared adapter, and each
  # step requires each adapter's report lines with their counts; the decoders' corpus includes
  # wai.image.jpegai on the jpegai/v1 inputs, kept on the host between runs and checked against
  # their pins each time. Measured on framework-128gb (2026-11-10), on both its adapters: each
  # step under two minutes with its build, the jpegai decode about four seconds of it.
  vulkan:
    needs: relevant
    if: needs.relevant.outputs.run == 'true'
    name: Vulkan GPUs (${{ matrix.host }})
    runs-on: ${{ matrix.runner }}
    timeout-minutes: 60
    strategy:
      fail-fast: false
      matrix:
        include:
          - host: framework-128gb
            runner: linux-amd
            adapters: gpu-vulkan-1002,swgpu-vulkan-10005
            jobs: '12'
          - host: jetson-hub
            runner: linux-hw
            adapters: gpu-vulkan-10de,gpu-vulkan-8086,swgpu-vulkan-10005
            jobs: '8'
    env:
      WAI_OPS_GPU_EXPECT: ${{ matrix.adapters }}
      WAI_OPS_GPU_REQUIRE: '1'
      CARGO_PROFILE_DEV_DEBUG: '0'
      CARGO_BUILD_JOBS: ${{ matrix.jobs }}
    steps:
      - name: Fetch the source
        shell: bash
        run: |
          set -euo pipefail
          want="${{ github.event.pull_request.head.sha || github.sha }}"
          rm -rf src && mkdir src && cd src
          git init -q
          # Fetch the commit itself, not the ref. The host names its own route to the forge
          # (WAI_FORGE_URL).
          timeout 600 git fetch -q --depth 1 "${WAI_FORGE_URL:-http://100.64.224.0:3400}/Transaction-Science/open-standards.git" "$want"
          git checkout -q FETCH_HEAD
          got="$(git rev-parse HEAD)"
          [ "$got" = "$want" ] || { echo "::error::fetched $got, not $want"; exit 1; }
      - name: The probe, the corpus at both widths, the mutants and the semantics suite, on every adapter
        shell: bash
        working-directory: src/wai/wai-ops-gpu
        run: |
          set -euo pipefail
          export PATH="$HOME/.cargo/bin:$PATH"
          log="$RUNNER_TEMP/ops-gpu.log"
          export WAI_OPS_GPU_REPORT="$RUNNER_TEMP/ops-gpu.report"
          : > "$WAI_OPS_GPU_REPORT"
          CARGO_TARGET_DIR="$HOME/hw-target/wai-ops-gpu" nice -n 10 cargo test --locked --release -- --nocapture --test-threads=1 2>&1 | tee "$log"
          # Seventeen tests in six binaries, none filtered, ignored or failed (as on Metal).
          ran=$(awk '/^test result: ok\. [0-9]+ passed; 0 failed; 0 ignored; 0 measured; 0 filtered out/ { n += $4 } END { print n + 0 }' "$log")
          [ "$ran" = 17 ] || { echo "::error::$ran tests ran and passed, not 17"; exit 1; }
          ! grep -q '^test result: FAILED' "$log" || { echo "::error::a test failed"; exit 1; }
          rep="$WAI_OPS_GPU_REPORT"
          keys=$(tr ',' '\n' <<<"$WAI_OPS_GPU_EXPECT" | LC_ALL=C sort | paste -sd, -)
          grep -qxF "ops-gpu adapters: as declared ($keys)" "$rep" || { echo "::error::the adapters found are not $keys"; exit 1; }
          for k in ${keys//,/ }; do
            grep -qE "^ops-gpu arith: key=$k .* cases=[0-9]+ words=[0-9]+ equal$" "$rep" || { echo "::error::no probe result for $k"; exit 1; }
            grep -qE "^ops-gpu corpus: key=$k .* acc32 vectors=[1-9][0-9]* decodes=[1-9][0-9]*; acc64 vectors=[1-9][0-9]* decodes=[1-9][0-9]*; .* mismatches=0 errors=0 " "$rep" \
              || { echo "::error::no equal corpus run for $k"; exit 1; }
            grep -qxF "ops-gpu mutants: key=$k killed 18 of 18" "$rep" || { echo "::error::a mutant survived on $k, or the mutant test did not run"; exit 1; }
            grep -qE "^ops-gpu semantics: key=$k .* committed=[1-9][0-9]* cases=[1-9][0-9]* guarded=[1-9][0-9]* differ=0 " "$rep" \
              || { echo "::error::no run of WGSL's integer semantics on $k with every guarded case equal"; exit 1; }
            grep -qE "^ops-gpu semantics mutant: key=$k refused: the WGSL semantics suite: rem_i32 " "$rep" \
              || { echo "::error::the edited semantics kernel was not refused on $k"; exit 1; }
          done
      # The jpegai/v1 inputs, kept on the host: fetched (within ten minutes) only when a file is
      # missing or not its pin.
      - name: The jpegai/v1 inputs
        shell: bash
        working-directory: src/wai
        run: |
          set -euo pipefail
          J="$HOME/hw-cache/jpegai-v1"
          mkdir -p "$J"
          if ! (cd "$J" && sha256sum --quiet -c "$OLDPWD/tools/jpegai-e2e-v1.sha256") 2>/dev/null; then
            timeout 600 bash tools/wai_jpegai_fetch_e2e_inputs.sh "$J"
          fi
          (cd "$J" && sha256sum --quiet -c "$OLDPWD/tools/jpegai-e2e-v1.sha256")
          echo "WAI_JPEGAI_DIR=$J" >> "$GITHUB_ENV"
      - name: The decoders' corpus with its graphs on every adapter
        shell: bash
        working-directory: src/wai/wai-rs
        run: |
          set -euo pipefail
          export PATH="$HOME/.cargo/bin:$PATH"
          log="$RUNNER_TEMP/ops-gpu-rs.log"
          rep="$RUNNER_TEMP/ops-gpu-rs.report"
          : > "$rep"
          J="$WAI_JPEGAI_DIR"
          WAI_OPS_GPU_REPORT="$rep" CARGO_TARGET_DIR="$HOME/hw-target/wai-rs-ops-gpu" \
            WAI_JPEGAI_CODESTREAM="$J/test256.bin" WAI_JPEGAI_WEIGHTS_DIR="$J" WAI_JPEGAI_NORM="$J/norm.json" WAI_REQUIRE_SOTA_VECTORS=1 \
            nice -n 10 cargo test --locked --release --no-default-features --features ops_gpu,video_int,audio_int,splat_int,world_int \
            --test ops_gpu -- --nocapture 2>&1 | tee "$log"
          grep -q '^test result: ok\. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out' "$log" || { echo "::error::the capability test did not run and pass"; exit 1; }
          ! grep -q '^ops-gpu adapter refused: ' "$rep" || { echo "::error::an adapter was refused"; grep '^ops-gpu adapter refused: ' "$rep"; exit 1; }
          for k in ${WAI_OPS_GPU_EXPECT//,/ }; do
            for cap in wai.neural.int_hyper wai.video.int_hyper wai.audio.int_codec wai.splat.int_codec wai.neural.int_synth \
                       wai.neural.int_mlicpp wai.world.model wai.image.jpegai; do
              grep -qE "^ops-gpu capability: key=$k .* cap=$cap cases=[1-9][0-9]* .* differ=0 errors=0$" "$rep" \
                || { echo "::error::$k, $cap: no equal run on the device"; exit 1; }
            done
          done