Transaction-Science/open-standards
Watch
1
0
Fork
You've already forked open-standards
 0
Code Issues Pull requests Projects Releases 15 Packages Wiki Activity Actions 5
open-standards/.github/workflows/wai-web-wasm.yml
Transaction Science a1bf417590 wai-quantum: a program's history, attributed, and the Studio's Versions 
Feature 6 of the co-design report: every version of a program, who made
each change and how, and whose hand each line and gate is in, sealed
into the run's receipt.

- engine::versions:
  - versions in a chain, each naming its parents (none, one, or two for
    a merge), who made it (the person, the assistant, an outside agent,
    the engine, or where the program came from) and how (an edit, a
    proposal reviewed change by change, a merge);
  - a version's digest covers its parents' digests, and the recording
    host's key seals it; verify checks every digest, seal and review;
  - changes and apply: a line diff (Myers), so a proposal is taken
    change by change, and the version keeps the whole proposal;
  - blame, authorship and gate_hands: a line keeps its author until
    changed; a model's or an agent's line the person edits is in both
    hands; an undo keeps the earlier authors; a merge keeps each side's;
    gates follow their lines, at a generator's inputs;
  - attest and check_job: a job's request carries the account, the
    receipt binds it, and it is recomputed from the history;
  - call: the history by name with JSON arguments, for the page and the
    desktop app.
- The command line: history start | commit | changes | propose | merge |
  log | blame | verify; run and submit --history; verify --history.
- MCP: history_commit, history_changes, history_blame and history_log.
  An agent's edit is recorded as an outside agent's, under the name its
  client gave in initialize, whatever it says of itself.
- The Studio's Versions pane:
  - what the reader types is theirs, recorded when they pause;
  - every proposal (the assistant's program, an alternative, a generator
    from the Workbench) is offered change by change while the editor
    waits; a fix is the engine's;
  - lines of work in lanes: an older version opened and edited starts
    its own, and "Bring in" merges one change by change;
  - "Who wrote it" marks lines in the gutter and gates on the diagram;
  - the run's receipt binds the account, which the result recomputes;
  - kept in the browser, downloaded for the command line;
  - window.quantumStudio.propose for an embedding page.
- Fixes found by the Studio's test: a run shows it is running before
  the account is made, and the draft is kept as the page goes.
- CI: wai-web's native engine tests count 8, the history's included.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
2026-10-26 02:02:58 -04:00

276 lines
15 KiB
YAML
Raw Permalink Blame History

name: wai-web wasm32
# The browser sink (wai/wai-web) is the same Rust as the native reference,
# compiled to wasm32-unknown-unknown. This job builds it and runs, under node:
#
# - demo/verify_int_synth_wasm.mjs against the committed conformance corpus
# wai/neural-conformance/ (not the demo's staged copies): the wasm32
# int_synth decode must hash to the corpus's frozen native hashes;
# - demo/verify_generate_wasm.mjs against wai/wai-rs/tests/vectors/generate/ and
# wai/score-conformance/: generateSpectral at every pinned size (sizes.json,
# instr-v0.json's object and every object it accepts) and ScoreSink over every
# score vector must give the SHA-256 the native `wai generate` and `wai score
# render` wrote, so a page checking the browser's output against those pins can;
# - demo/verify_menu.mjs: every capability the browser sink advertises is
# registered in wai/registry/capabilities.json as a payload or companion
# capability, none is a candidate (SPEC §5), and the wasm build's own
# registry agrees with the export on every candidate;
# - demo/verify_pack.mjs: the browser writers `pack` and `packMulti` refuse
# every candidate the export lists, in every place an envelope can name one,
# and a manifest that names a member twice in one object;
# - demo/verify_int_world_wasm.mjs against wai/wai-rs/tests/vectors/int_world{,2}/:
# the WorldModel binding, wai.world.model's integer renderer, must render every
# frame of both committed world vectors to the SHA-256 their sidecars state;
# - demo/verify_staged_wasm.mjs against the staged-delivery corpus
# wai/staged-conformance/: every case replayed through the wasm32 StageSink
# must give the reports, final units and stage hashes the native sink wrote;
# - demo/verify_measure.sh against the staged-measurement corpus
# wai/staged-measure-conformance/: every figure of the wasm32 measurement
# binding equals the corpus and the native tool's byte for byte, and the
# session claims it seals are verified natively and by the independent
# Python verifier with the same verdicts;
# - a byte comparison of the demo's staged int_synth copies with the corpus;
# - the crate's wasm_tests under wasm-bindgen-test-runner, and its native unit
# tests on the host.
#
# The full-scale int_hyper wasm decode needs vectors regenerated from a
# pretrained model; wai-sota-vectors.yml runs it after regenerating them.
# 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-web/**'
- 'wai/wai-rs/**'
# wai-rs's integer decoders depend on the integer operator set.
- 'wai/wai-ops/**'
- 'wai/wai-quantum/**'
# quantum::tests and quantum_toolchain::tests read the quantum corpora.
- 'wai/quantum-conformance/**'
- 'wai/neural-conformance/**'
- 'wai/staged-conformance/**'
- 'wai/staged-measure-conformance/**'
- 'wai/int-payload-conformance/**'
- 'wai/claim-conformance/**'
- 'wai/score-conformance/**'
- '.github/workflows/wai-web-wasm.yml'
schedule:
- cron: '45 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-web-wasm.yml \
"${{ github.event.pull_request.base.sha }}" \
"${{ github.event.pull_request.head.sha }}")
echo "this change touches wai-web-wasm: $r"
echo "run=$r" >> "$GITHUB_OUTPUT"
wasm32:
needs: relevant
if: needs.relevant.outputs.run == 'true'
name: wai-web wasm32 build · corpus, menu and writers
runs-on: linux
timeout-minutes: 45
steps:
- uses: actions/checkout@v5
# The docker runner image ships no Rust.
- name: Install Rust 1.98.0 with the wasm32 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 wasm32-unknown-unknown
echo "$HOME/.cargo/bin" >> "$GITHUB_PATH"
# Pinned to the wasm-bindgen version in wai-web/Cargo.lock: the CLI and the
# crate must match exactly.
- name: wasm-bindgen CLI 0.2.127
shell: bash
run: cargo install --locked wasm-bindgen-cli --version 0.2.127
- uses: actions/setup-node@v4
with:
node-version: '22'
- name: Build wai-web for wasm32 (node bindings)
shell: bash
working-directory: wai/wai-web
run: |
set -euo pipefail
cargo build --locked --release --target wasm32-unknown-unknown
wasm-bindgen --target nodejs --out-dir demo/pkg-node --out-name wai_web \
target/wasm32-unknown-unknown/release/wai_web.wasm
# The JS surface itself (pick, companionsOf, verifyPin, rendition() and
# companion() refusing what is never presented or does not match its digest,
# the held-sets conversion, and the WAI2 parse at 32-bit usize) runs only on
# wasm32 (`mod wasm_tests`). wasm-bindgen-test-runner, installed above at the
# version Cargo.lock pins, runs it under Node. The count check turns a test
# that stopped being compiled into a failure instead of a silent "0 passed".
- name: wai-web JS surface (wasm32 tests under Node)
shell: bash
working-directory: wai/wai-web
run: |
set -euo pipefail
CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER=wasm-bindgen-test-runner \
cargo test --locked --target wasm32-unknown-unknown 2>&1 | tee "$RUNNER_TEMP/wai-web-wasm.log"
grep -q "test result: ok. 4 passed; 0 failed" "$RUNNER_TEMP/wai-web-wasm.log"
# The job service's engine in a page (src/quantum_engine.rs, feature
# quantum_engine, which only the IDE's bundle carries): a job planned, run and
# signed in wasm32 under Node, its receipt checked there and a changed result
# refused, every method a tab holds run with no clock and no threads, a
# program's critique, equivalence check and variants, and its classical
# shortcuts with a contraction search. The count is the four tests above and
# its four.
- name: The job engine in a page (wasm32 tests under Node)
shell: bash
working-directory: wai/wai-web
run: |
set -euo pipefail
CARGO_TARGET_WASM32_UNKNOWN_UNKNOWN_RUNNER=wasm-bindgen-test-runner \
cargo test --locked --target wasm32-unknown-unknown --features quantum_engine 2>&1 | tee "$RUNNER_TEMP/wai-web-engine-wasm.log"
grep -q "test result: ok. 8 passed; 0 failed" "$RUNNER_TEMP/wai-web-engine-wasm.log"
# Its native half: the service's form and receipt, any angle on the state
# vector, what does not run saying why, plan, lint, draw and methods as JSON,
# critique, equivalence and variants as JSON, the classical shortcuts, the
# workbench run and sealed in the page, and a program's history recorded and
# blamed there.
- name: The job engine in a page (native unit tests)
shell: bash
working-directory: wai/wai-web
run: |
set -euo pipefail
cargo test --locked --lib --features quantum_engine quantum_engine:: 2>&1 | tee "$RUNNER_TEMP/wai-web-engine.log"
grep -q "test result: ok. 8 passed; 0 failed" "$RUNNER_TEMP/wai-web-engine.log"
# The crate's native unit tests, run on the host: the pure-Rust halves of the
# bindings, which wasm_tests does not run. They decode the committed integer
# payloads to their sidecars' SHA-256 (int_payload::tests) and check that the
# writers `pack` and `packMulti` refuse a payload that is not the format SPEC §5
# pins its integer capability to, and a manifest that names a member twice (tests); the
# staged-delivery binding's pure half replays the staged corpus and reads a layer's
# header and cost (stage::tests); the measurement binding's pure half evaluates the
# staged-measurement corpus to its goldens and seals a page-recorded session equal
# to the native tool's (measure::tests). The quantum sink opens every file of
# both quantum corpora to their manifests' hashes and capability and refuses
# every reject file with its listed class (quantum::tests), and the quantum IDE
# builds its catalog circuits in its gateset to the same manifests, stores no
# parameter on a gate other than P, and shows no hash for an invalid circuit;
# its import reads a program as the job service does and refuses one that
# measures and then acts, its replies stay valid JSON whatever an error says,
# and it signs with the page's own key once given one (quantum_toolchain::tests). The OTT demo seals a figure the page supplies as
# an estimate, never a reading (video_ott::tests). The count check turns a test that
# stopped being compiled into a failure instead of a silent "0 passed".
- name: wai-web native unit tests
shell: bash
working-directory: wai/wai-web
run: |
set -euo pipefail
cargo test --locked --lib 2>&1 | tee "$RUNNER_TEMP/wai-web-native.log"
grep -q "test result: ok. 35 passed; 0 failed" "$RUNNER_TEMP/wai-web-native.log"
- name: wasm32 int_synth decode equals the frozen native corpus
shell: bash
working-directory: wai/wai-web
run: node demo/verify_int_synth_wasm.mjs ./pkg-node/wai_web.js ../neural-conformance
# decodeWiv1, decodeWih1, decodeWia1 and decodeWis1 on the committed integer
# payloads give the SHA-256 their sidecars state, and a JSON form is refused.
- name: wasm32 integer payload decode equals the native sidecars
shell: bash
working-directory: wai/wai-web
run: node demo/verify_int_payload_wasm.mjs ./pkg-node/wai_web.js ../wai-rs/tests/vectors
# WorldModel, wai.world.model's integer renderer (integer-operators §13.5,
# informative), renders each committed world vector, one agent and two, frame by
# frame, to the SHA-256 its sidecar states for every frame and for the clip.
- name: wasm32 integer world renderer equals the native sidecars
shell: bash
working-directory: wai/wai-web
run: node demo/verify_int_world_wasm.mjs ./pkg-node/wai_web.js ../wai-rs/tests/vectors
# The generator and the score synth in wasm32 against the native pins: every size
# sizes.json and instr-v0.json pin (the object's four listed sizes, and the first
# listed size of each object at a bound of form v0), and every score vector's
# pcm_sha256, mixdown hash and score hash. Pages that make these pieces in the
# browser hold their output to such pins, made natively.
- name: wasm32 generator and score synth equal the native pins
shell: bash
working-directory: wai/wai-web
run: node demo/verify_generate_wasm.mjs ./pkg-node/wai_web.js ../wai-rs/tests/vectors/generate ../score-conformance
# Every staged-delivery case replayed through the wasm32 StageSink: each integer
# base decoded in wasm32 to its stage0.bin with its pin, and every report, final
# unit, stage hash and clip hash equal to what the native sink wrote in case.json.
# Then the binding's guards: bases that declare huge clips refused under a cost
# limit with linear memory checked, a base past the chain budget, base facts a
# page cannot raise (fallback, tier, claimed), addBase spending its base, and a
# seeded fuzz that must never trap.
- name: wasm32 staged-delivery sink equals the native corpus
shell: bash
working-directory: wai/wai-web
run: node demo/verify_staged_wasm.mjs ./pkg-node/wai_web.js ../staged-conformance
# The staged-measurement binding (src/measure.rs) over wai/staged-measure-conformance/:
# every fixture's evaluation, the refusal titles, the counted objects, the quality
# pairs and every simulator case equal the corpus, and the evaluations equal the native
# `wai_stage_measure eval --json` byte for byte; every session the wasm32 build seals
# is the native tool's claim, commits to the golden output tree, and gets the same
# verdicts from the wasm32 verifier, `wai_claim_vectors verdicts` and claim_verify.py.
# It uses the package built above; a missing artifact fails the step.
- uses: actions/setup-python@v5
with:
python-version: '3.11'
- name: Install the Ed25519 library (claim_verify.py)
shell: bash
run: python -m pip install cryptography
- name: wasm32 staged measurement equals the native tool and the corpus
shell: bash
working-directory: wai/wai-web
run: bash demo/verify_measure.sh ./demo/pkg-node/wai_web.js
- name: The browser menu is registered and names no candidate
shell: bash
working-directory: wai/wai-web
run: node demo/verify_menu.mjs ./pkg-node/wai_web.js ../registry/capabilities.json
- name: The browser writers refuse every candidate
shell: bash
working-directory: wai/wai-web
run: node demo/verify_pack.mjs ./pkg-node/wai_web.js ../registry/capabilities.json
- name: The demo's staged int_synth vectors are byte copies of the corpus
shell: bash
working-directory: wai
run: |
set -euo pipefail
cmp wai-web/demo/int_synth/expected_hashes.json neural-conformance/expected_hashes.json
for n in gradient bloom facade photo; do
for f in latent.bin int_synth.json; do
cmp "wai-web/demo/int_synth/$n/$f" "neural-conformance/vectors/$n/$f"
done
done
Reference in a new issue View git blame Copy permalink