Every hop between a source and a screen does work. The encoder splits content and chooses a representation for each piece, the edge selects what to forward, and the sink rebuilds what it receives and checks it. This is how WAI is built for that, starting with how each era of delivery changed the pipe.
Each era of video delivery moved the same kind of cargo — pictures coded for display — and rebuilt the pipe around it: new transport, new caches, new ways to pay for delivery. Codecs got better at packing pictures and pipes got better at moving them. WAI keeps the pipe and changes what rides in it.
Each piece of a stream names the capability that rebuilds it: a standard codestream, an integer learned codec, or instructions the sink evaluates. The origin, the edge and the last mile stay. What changes is the work each hop does.
Split the content and choose a representation for each piece.
Select what to forward, without rewriting it.
Rebuild each piece, check it, and refuse what does not match.
Between them, staggered compression: a base first, refinements after.
Measured, not projected: Cargo, measured runs one clip both ways in your browser.
Splits the content into pieces and names the capability that rebuilds each.
Stores one object per piece with its content hash; identical segments are stored once.
Forwards objects and their receipts byte for byte, and serves the tracks a sink subscribes to.
Carries the pieces the sink picked — a base first, refinements after.
Rebuilds each piece, checks it by hash, refuses a mismatch and falls back to another rendition.
The sink is a computer. A WAI file names the capability each piece of content needs — a standard codec, an integer learned codec, or instructions the sink replays — so the representation is chosen per piece, and a conforming sink rebuilds what it receives.
For the integer and instruction capabilities, conformance requires the same state, samples or per-frame identity on every machine, so a reconstruction made anywhere checks by hash. Each class pins what it owns: a film or a world pins its state and leaves the render to the sink; a world model pins its action trace; a spatial-audio mix is exact for its stereo floor, given the sources' decoded samples.
So every hop does work. The encoder splits content and chooses a representation for each piece. The edge selects what to forward without rewriting it. The sink rebuilds what arrives and proves it. Staggered compression, a base first and refinements after, is what WAI's packager automates next, for on-demand video, live channels and live content alike.
Per-object capabilities with declared fallbacks, envelopes that carry several renditions for the sink to choose among, receipts that relays preserve, and a binding to Media over QUIC in which each object is one envelope.
Content-hashed packaging whose deduplication totals a verifier recomputes, one manifest generation per session class, and an enhancement layer bound to its base.
Refinements delivered as separate objects after their base.
Edges that rebuild content under their own receipt.
The model a neural payload needs is named and pinned by digest, and it is never carried in the envelope; a mismatch is refused. A pinned prior can declare its artifact's wire form, and the NNC bitstream is registered as one.
The normative model pin: one digest over a whole parameter set, a set of several files pinned through its listing, a closed determinism vocabulary and a predecessor link. Each rendition in a multi-rendition envelope can carry its own id, payload digest and pin, and a sink decodes only from the bytes it verified.
A sink that lacks a capability uses a declared fallback or reports the file inert — it never guesses. A fallback decodes the same payload; alternate content travels as renditions.
Standard codestreams. Each capability in the codec registry carries a licence class a deployer queries in code.
Broadcast and streaming codec registrations, each licence-classified, never a default, and decoded by the sink's own libraries.
Integer learned codecs for images, video, audio and 3D splats, whose conformance requires byte-identical output on every machine — among them wai.neural.int_mlicpp, the MLIC++ entropy topology, integer end to end.
A pinned binary payload format for each integer codec, an integer decode path that needs no machine-learning runtime, and a cost a sink reads from the header before it decodes.
Instructions the sink evaluates: worlds, film, reels, score, avatars, feeds, 4D splats and haptics.
Derived tracks: derivation operations over decoded samples, each with a stated determinism tier.
A deriving edge that evaluates those operations.
Because each object names its own capability, a stream changes representation from one object to the next: a coded picture, a learned latent, or instructions.
Several renditions of one piece in one envelope, and a licence class for each capability in the codec registry, queryable in code.
Integer codecs let an encoder predict the decoder's output exactly. The integer video encoder closes its loop on the reconstruction, not on the source.
Segmentation on group-of-pictures boundaries into content-hashed pieces, whose deduplication totals a verifier recomputes from the signed segment map.
wai-pack's policy and segmenter: a declared packaging policy, digested over its canonical form, and pieces cut at scene changes.
wai-pack writes packages: a stage index, a package receipt signed over its policy, a floor checked against its keyframe plan, and HLS, DASH and Media over QUIC views.
A sink that computes starts from a base and improves it as more arrives. WAI does this in three forms.
Temporal: a learned integer keyframe, then integer motion-compensated frames, byte-exact down the whole group of pictures.
Layered: a standard enhancement layer bound to exactly one base rendition in the same envelope; the sink supplies its decoder.
Staged delivery: WAI-native refinements delivered as separate objects after their base, each linked to its base by hash, with a stated determinism tier for every prefix — so a partly refined picture carries its own tier, and a missing refinement leaves the base intact. A sink bounds the work and memory of every layer and of the whole chain.
Staged delivery rebuilt in the browser by the same sink, every stage checked by hash; and measurement of what each stage costs in counted bytes and gives in integer quality, with a stall bound proved for a delivery plan.
How each class of content is carried, and its staged forms. Video has two staged forms in the standard besides staged delivery; staged delivery, refinements as separate objects after a base, covers images, video, audio and 3D splats.
| Media | Carried now | Staged form |
|---|---|---|
| Video | Coded or integer video, packaged on group-of-pictures boundaries into content-hashed segments. |
|
| Still images | Standard codecs and integer learned codecs, one picture per object. |
|
| Audio | Coded audio, integer learned audio, or a scene of sound objects the sink mixes. |
|
| 3D and splats | An integer splat codec, and 4D splats as keyframed tracks. |
|
| Worlds, film and feeds | Signed instructions and operation logs the sink replays. | — |
| Haptics | Haptic signals. | — |
A conforming relay forwards envelopes and their receipts byte for byte: no transcoding, no manifest rewrite, no re-signing. A relay that attests does so in a separate, parallel receipt.
A binding to Media over QUIC, tracking IETF Internet-Drafts: each object is one whole envelope, and the catalog lists every capability a track uses, so a sink decides before it subscribes.
One manifest generation per session class, served to every viewer in that class.
A deriving edge that rebuilds or re-packs content and signs its own step, chained to the source's receipt.
A sink decodes each capability with the decoder it registered for it, and picks among renditions by a policy the deployer sets.
Constraint sets evaluated before dispatch, as specification text.
Rebuilt instruction cargo proves itself by hash: the page rebuilds the content and checks each hash against the native reference.
On demand: renditions in one envelope, packaged into content-hashed pieces.
Live channels: attested playback windows that chain into a record of what aired, with session-class manifests, ad-insertion records and key-release records. The demonstration runs the manifest and ad-insertion steps.
Live content: signed operation logs that the reference relay verifies at the door and that late joiners re-derive. The browser reaches the relay over a WebSocket.
Live rooms over Media over QUIC: several people publish and many watch, every object is checked against its receipt before it is decoded, events are signed and chained per sender, and every sink computes the same layout. Standard encoders and players join over WHIP and WHEP, and each hop signs a record of what it carried.
Shared world-model sessions run on a bidirectional companion relay, reached through a WebSocket bridge. It lives outside the open-standards repository and carries its own licence. The live room's relay is the reference relay in the open-standards repository. Shared world model
The same Rust source builds natively and for WebAssembly; for the integer-exact capabilities both produce the same output hash, which the browser demonstrations check in the page with a 64-bit FNV-1a hash per frame. Receipts commit with BLAKE3.
WebAssembly runs the integer kernels single-threaded. High-resolution learned decoding belongs to the decoder a sink registered for that capability.
The browser sink builds for wasm32 in CI. Keys, decoder modules and pinned parameter sets carry signing authority and revocation through a key log the origin publishes; a sink that holds the log refuses what it revokes.
Publisher-signed group receipts: a content hash per object, a Merkle root per group, an Ed25519 signature, and a link to the previous receipt.
Decode receipts that separate what anyone holding the codestream can recompute from the energy figure, which only the signer attests.
Energy acquisition classes: CalibratedInstrument and OnChipCounter (each with a declared uncertainty), ModelBased, or Estimator. An energy claim signs an object's figure together with its class, and decode receipts carry the class as a signed label. HwShunt is legacy. Work that was not metered carries no figure and reads as not metered.
Typed claim classes with an independent verifier, and a soft binding: a receipt reached through it attests the ancestor, never the object in hand.
Measurement and operating-point reports on an energy figure, a figure, class and origin bound into each object's Merkle leaf, labelled group totals, power readers that count only while live, and "unmetered is never 0" on every receipt path.
Two pages measure in your browser. /cargo measures the bytes, the quality and the decode time of one open-film excerpt as it arrives, and /measure runs the staged-measurement method over its corpus, giving the native tool's figures byte for byte.
Every capability in the standard, area by area, each linked to its specification text and its conformance: the WAI status page.