[package] name = "wai" version = "0.3.0" edition = "2024" rust-version = "1.97" license = "Apache-2.0" description = "WAI — Web AI media transport + execution, and a deterministic QUANTUM stack: byte-exact circuit simulation with statevector / stabilizer / tensor-network / sparse-Pauli backends, error mitigation, qLDPC decoding, noise learning, circuit-equivalence proofs and signed energy-accounted receipts — identical results native and in cloud WASM. Plus a capability-as-requirement envelope and zeroth-condition wrappers around standard codec libraries (AVIF / JPEG-XL / PNG / Opus / FLAC / AV1 / zstd / LZMA)." repository = "https://git.transaction.science/Transaction-Science/open-standards" homepage = "https://wai.transaction.science" documentation = "https://wai.transaction.science/quantum-ide" keywords = ["quantum", "simulation", "wasm", "deterministic", "codec"] categories = ["science", "simulation", "wasm", "multimedia"] [lib] name = "wai" crate-type = ["lib", "cdylib", "staticlib"] # cdylib + staticlib for FFI/SDK # clippy.toml's `disallowed-methods` lists the float functions the JPEG AI exact # decoder must not call. Allowed for the package here; each module on that decode path # denies it with `#![deny(clippy::disallowed_methods)]`. [lints.clippy] disallowed_methods = "allow" # `cfg(kani)` is set only by the model checker (wai-verify `#[path]`-includes the # integer sources: rans, int_entropy, int_transform, int_kernels). Declared so an # ordinary build or clippy run knows the name and does not warn on it. [lints.rust] unexpected_cfgs = { level = "warn", check-cfg = ["cfg(kani)"] } [dependencies] # Container manifest. preserve_order so JSON round-trips byte-identical. serde = { version = "1", features = ["derive"] } serde_json = { version = "1", features = ["preserve_order", "raw_value"] } # ---- zeroth codec wrappers: lossy + lossless across all media ---- # All optional behind the (default-on) `codecs` feature: native sinks get # the full menu; a wasm32 world sink builds with --no-default-features # --features world and none of the C codec chain. Registration (the # capability strings in codecs/mod.rs) is NOT gated — only the decoders. # Image image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "avif"], optional = true } # PNG, JPEG decode, AVIF encode (via ravif) jpeg-encoder = { version = "0.7", optional = true } # pure-Rust JPEG with optimized Huffman tables libavif-sys = { version = "0.17", optional = true, default-features = false, features = ["codec-dav1d"] } # AVIF decode through libavif itself, with the reader limits as its decoder limits jpegxl-rs = { version = "0.14", optional = true } # libjxl bindings (links system libjxl; 0.11.x and 0.12.x both work) jpegxl-sys = { version = "0.12", optional = true } # libjxl itself, to read a payload's declared size before it decodes # Audio opus = { version = "0.3", optional = true } # libopus bindings (lossy) ogg = { version = "0.9", optional = true } # Ogg container for standard .opus interop claxon = { version = "0.4", optional = true } # FLAC decode (pure Rust) flac-bound = { version = "0.5", optional = true } # FLAC encode (libFLAC) # Video rav1e = { version = "0.8", default-features = false, features = ["threading"], optional = true } dav1d = { version = "0.11", optional = true } # AV1 decode (libdav1d) # Text zstd = { version = "0.13", optional = true } # zstd bindings xz2 = { version = "0.1", optional = true } # liblzma bindings (XZ/LZMA) # Bytestream framing for video container (we wrap rav1e packets into a # minimal IVF-like sequence for self-contained .wai video payloads). byteorder = { version = "1", optional = true } # ---- neural runtime (optional, behind the `neural` feature) ---- # `ort` wraps ONNX Runtime — same ORT version (1.26) the # browser-side wai-web demo uses, so models built with our exporters # load identically here. The `download-binaries` feature fetches the # right libonnxruntime build at compile time; no manual brew install. ort = { version = "2.0.0-rc.12", default-features = false, features = ["std", "download-binaries", "ndarray", "tls-rustls"], optional = true } ndarray = { version = "0.17", optional = true } # ---- the `wai` CLI's TLS client (optional, behind the `cli_tls` feature) ---- # `wai http receipts --key-origin` retrieves an origin's key log over HTTPS itself # (http-delivery §8.4), the origin's certificate validated against the operating system's # trust store. The library never opens a connection: only the binary uses these, and no # library or wasm32 build enables the feature. ring is the provider already in the graph. rustls = { version = "0.23", default-features = false, features = ["std", "ring", "tls12"], optional = true } rustls-platform-verifier = { version = "0.7", optional = true } zstd-safe = { version = "7", optional = true, features = ["std"] } # for bmshj2018 latent unpack (std → WriteBuf for Vec) # SHA-256 is WAI's digest for parameter-set identity, component identity and decoded-output # conformance digests (SPEC §3.1, §7 *Digests*, §7.1). Pure Rust, so it is always on: the # envelope reader verifies a component digest and a pin with no feature enabled. sha2 = "0.10" # ---- real C2PA manifest emission (optional, behind `c2pa_emit`) ---- # Writes an actual signed manifest carrying the energy + reconstruction # bindings, rather than only defining their shapes. Off by default: the SDK # is a large dependency chain and most consumers only need the types. c2pa = { version = "0.90", optional = true, default-features = false, features = ["rust_native_crypto"] } # ---- interactive worlds (optional, behind the `world` feature) ---- # extensions/interactive-worlds: WWLD container, signed CausalOps, # deterministic fixed-point simulation, replay-equivalence conformance. blake3 = { version = "1.8", optional = true } # state hashes, node minting, op/seal commitments; `hazmat` (1.8) for the HTTP head proof ed25519-dalek = { version = "2", optional = true } # op + seal signatures num-bigint = { version = "0.4", optional = true } # oer: exact decimal arithmetic in the composition checks; live_ads: RFC 9578's RSASSA-PSS # The curve ed25519-dalek is built on, named directly only by `receipt_claims`: its # conformance corpus builds the signatures jwp-receipts §3.1 step 3 must refuse (keys of # small order, non-canonical encodings), which the signing API cannot produce, and the # verifier checks S < L itself (§3.1 step 3). curve25519-dalek = { version = "4", optional = true } # ---- quantum (optional, behind the `quantum*` features) ---- # The quantum stack now lives in its own dependency-light crate so it can be used # without the media/codec chain. `wai` re-exports it unchanged. wai-quantum = { version = "0.6.0", path = "../wai-quantum", optional = true, default-features = false } # ---- the integer operator set (behind `neural_int`) ---- # `wai-ops/1` (extensions/integer-operators.md): an integer decoder that decodes # through it lowers its parameter set to WHG1 graphs and loads them under its # capability's profile, the bounds certificate included (src/int_ops.rs). no_std, no # dependencies of its own. wai-ops = { path = "../wai-ops", optional = true } # `wai-ops/1-i32` on GPUs (feature `ops_gpu`): WGSL kernels through wgpu. Optional and off # by default, so a default build has no GPU interface in it. wai-ops-gpu = { path = "../wai-ops-gpu", optional = true } [features] default = ["codecs"] # The zeroth-condition codec wrappers (image/audio/video/text) + the C # FFI surface built on them. Default-on: a native sink is a full sink. # Disable for targets where the C codec chain can't follow (wasm32) — # the envelope, manifest, and `world` engine build without it. codecs = [ "dep:image", "dep:jpeg-encoder", "dep:libavif-sys", "dep:jpegxl-rs", "dep:jpegxl-sys", "dep:opus", "dep:ogg", "dep:claxon", "dep:flac-bound", "dep:rav1e", "dep:dav1d", "dep:zstd", "dep:xz2", "dep:byteorder", "ffi", ] # The C ABI's envelope surface (buffers, errors, WAI1/WAI2 pack and unpack, §7.1 # selection), with no codec library: it builds and is tested where libjxl and the # other C codec libraries are absent. `codecs` adds the codec wrappers to it. ffi = [] # Pulls in the ONNX runtime + zstd unpack so the native sink can # decode `wai.neural.<...>` envelopes. Off by default — the bare # container + zeroth codecs build with no ML dep chain. # The integer-exact synthesis decoder (`wai.neural.int_synth`). Pure i64 # arithmetic — no ONNX, no float, bit-identical on every machine by # construction — so it sits behind its own light feature, checkable in a CI # matrix with no ONNX Runtime present. `neural` pulls it in. blake3 is for the # conformance corpus's content hash (the same hash the other classes freeze). neural_int = ["dep:blake3", "dep:wai-ops"] # Test-only: the integer decoders' direct decodes, as they were before they decoded # through the integer operator set (`int_synth::legacy`). The differential tests decode # random sets and payloads both ways and require the same output or the same refusal # outside the planned breaks (tests/int_ops_differential.rs). No sink enables it. legacy_int = ["neural_int"] # The 32-bit forms of the stage operators that have one by identity (E9's, # integer-operators §5E), and the decodes of `WIV1` and `WIR1` through them # (`int_video::ops::decode_typed_i32`, `staged::wir1::ops::apply_unit_i32`): the # arithmetic a 32-bit fabric runs, which the parity tests hold to the exact decode. For # the integer GPU legs; no sink decodes through it by default. i32_forms = ["neural_int", "wai-ops/i32_forms"] # The integer decoders' graphs on a GPU (`int_ops::gpu`, `wai_ops_gpu`): `wai-ops/1-i32` in # WGSL kernels through wgpu, at the width each graph's certificate admits. A decode runs # its graphs there only inside `int_ops::gpu::with_gpu`; everywhere else, and for a graph # with an operator outside `wai-ops/1-i32`, the interpreter runs them. Native only: on # wasm32 the feature builds and changes nothing. ops_gpu = ["neural_int", "dep:wai-ops-gpu"] # Deterministic integer generative synthesis (`wai.generate.*`): byte-exact # generation pinned to (model, prompt, seed, steps) — the create-side of the # integer contract. Pure i64, no ONNX/float (serde_json is already a base dep), # so it builds and is bit-checkable with no ML dep chain, and compiles to wasm32. generate = [] # Deterministic integer inter-frame VIDEO (`wai.video.int_motion`): byte-exact # frame-by-frame decode — integer block motion compensation + integer-quantized # residual over the rANS coder. Frame-state-equivalence (per-frame hash); the # temporal extension of the integer contract. Reuses the pure-i64 rANS (neural_int). video_int = ["neural_int"] # Integer-exact LEARNED audio codec (`wai.audio.int_codec`): a learned 1-D transform # codec, integer transposed-conv synthesis → byte-exact int16 PCM (sample-equivalence, # a portable PCM hash). The audio analog of int_hyper. Reuses pure-i64 rANS + IGDN. audio_int = ["neural_int"] # Integer-exact INTERACTIVE WORLD MODEL (the byte-exact renderer for wai.world.model): # action-conditioned next-frame model, transition + synthesis both int_hyper IntModels. # Reuses int_hyper_synth (neural_int). world_int = ["neural_int"] # Integer-exact LEARNED Gaussian-splat ATTRIBUTE codec ("the int_hyper of 3D"): # learned transform over the [14,S,S] attribute image → byte-exact attribute tensor # (splat-equivalence, a portable cloud hash). Reuses int_hyper_synth (neural_int). splat_int = ["neural_int", "serde_json/float_roundtrip"] neural = ["neural_int", "dep:ort", "dep:ndarray", "dep:zstd-safe"] # The perceptual / generative-semantic path: CLIP-similarity conformance, # regenerate-at-sink. Reuses the ONNX runtime for the reference CLIP embedder; # the generator is always sink-supplied. Off by default like `neural`. semantic = ["codecs", "dep:ort", "dep:ndarray"] # Ed25519 verified as WAI verifies every signature (SPEC §7 *Signatures*, `src/sig.rs`): # the dependency on its own, so the one verifier builds exactly when ed25519-dalek does # and asks for no feature its caller does not need. Every signing feature enables it. ed25519 = ["dep:ed25519-dalek"] # Interactive worlds (extensions/interactive-worlds): media that consumes # input. Pure-Rust, no ML dep chain — the sim is closed-form fixed-point. world = ["dep:blake3", "ed25519"] # Live events (extensions/live-events): `wai.live.events`, a signed, hash-chained, # timeline-bound event track — the WEV1 record, its policy, its verifier, poll tallies # replayed through the feed sim (wai.world.sim.feed0), and the MSF event timeline, # EXT-X-DATERANGE and emsg mappings. SHA-256 and Ed25519 only; no new dependency. live_events = ["world"] # Live rooms (extensions/live-rooms): `wai.live.room` — the signed room descriptor (WRD1) # and room grant (WRG1), revocation through the authority's key log (jwp-receipts §7), # track naming, precedence and redundancy over slots, publish profiles, and the room # verifier that replays every principal's events under the grant in effect at each t. # Ed25519, SHA-256 and the key log only; no new dependency. live_room = ["live_events", "key_discovery"] # Capture binding (extensions/capture-binding): `wai.capture.take` — a device's master # recording bound to a live room by rolling take_commit events (the take tree is # staged-measurement Appendix C's, with RFC 9162 consistency proofs), the store's upload # receipts (WUR1), the take manifest (WTM1), consent records (WCN1), and the take verifier # with its single-take, aligned, complete and publishable verdicts. Ed25519, SHA-256 and # the key log only; no new dependency. capture_take = ["live_room"] # Live composition (extensions/live-compose.md): `wai.live.compose` — the signed # composition descriptor (WCD1), the participant set a room's lifecycle replay gives at # each instant, the integer layout function (grid, featured tile, picture in picture, fill # modes) and the saturating integer mixer, and the compositor's signed receipt (WCR1). # The layout and the mixer use nothing beyond core and alloc. Ed25519 and SHA-256 only; no # new dependency. live_compose = ["live_room"] # Live recording (extensions/live-recording): `wai.live.recording` — a finished room session as # one WAI package (the SPEC §3.1 listing of its files; the room, its events, each take and the # composite as components named by id and the SHA-256 of their listings; the signed WRM1 # recording manifest) with its complete and publishable verdicts, and provable clips: WCL1 clip # records whose RFC 6962 range proofs reach a take's commitment, verified without the take. # SHA-256, Ed25519 and the key log only; no new dependency. live_record = ["capture_take"] # Live metering (extensions/live-metering): `wai.live.metering` — the per-hop session record # (WMH1) a relay, compositor or ingest gateway signs, with its ledger of the grants its sessions # ran under and a size bound independent of the audience; the room-session receipt (WMR1) a room # authority or a `live/meter` key signs, its units, joules per hop with their acquisition class and # a total per class, each grant's consumption against its ceilings, and the QoE cell; and the QoE # observations' CMCD event-timeline record and `application/cmcd` batch. It reads rooms, takes and # composition receipts through their modules and the logs through the telemetry module. SHA-256, # Ed25519 and the key log only; no new dependency. live_metering = ["live_compose", "capture_take", "telemetry"] # Energy-aware content steering (extensions/energy-steering): `wai.live.steering` — the signed # steering policy (WSP1) and steering decision (WSD1): each pathway's joules per delivered byte or # per delivered second at the floor tier from its hops' per-hop records (live-metering's WMH1), with # their acquisition class, compared only within a class, a pathway with no figure never ranked above # one with a figure; the integer decision rule with limits, minimum shares and hysteresis; the client's # report from HLS and DASH steering requests and CMCD (an RFC 9651 parser of its own); and the # steering manifest, the HLS tag and the DASH element, written exactly. SHA-256, Ed25519 and the key # log only; no new dependency. energy_steering = ["live_metering"] # Browser sink (extensions/browser-sink.md): how a page routes each object to the user agent's # decoder, a native host's or a wasm decoder (the WebCodecs Codec Registry gate, the tier an object # needs, the probe), evaluates capability-constraints' sets over its register, reports a measured # figure beside the user agent's powerEfficient, and binds each decoded frame to the receipted # object it came from (contentBinding: the jwp-receipts §2.1 content hash, the group receipt's link # hash, the tier), with the side table a page carries it in and the state of the frame on screen. # BLAKE3 and serde_json at run time; Ed25519 to sign the corpus's group receipts. Builds for wasm32. browser_sink = ["jwp_hash", "ed25519"] # Live moderation (extensions/live-moderation): `wai.live.moderation` — the room authority's # signed review policy (WMP1: what is held for review or reviewed after delivery, by whom, each # deadline and fallback, and the reason codes with their grounds), the statement (WMS1) that # follows a `decision` event, notices and complaints (WMN1), lines of decisions by digest, the # review state machine, gaps that withheld events leave explained by the decisions that restrict # them, clips of a redacted take through live-recording's clip verifier, and the export of each # restricting decision as a statement of reasons in the DSA Transparency Database's format, # written by hand. SHA-256, Ed25519 and the key log only; no new dependency. live_moderation = ["live_events", "live_room", "live_record"] # Forensic watermark sessions (extensions/forensic-watermark): `wai.live.watermark` — the edge's # signed session record (WWS1: the positions of an ETSI TS 104 002 pattern it embedded, the variant # at each, the token by its digest, the content keys, and a salted commitment to the session's grant # and principal), the claimant's recovered sequence (WWQ1) and the exact rule that matches it, and # the room authority's disclosure (WWD1) that opens one commitment. The TS's token is read with a # deterministic-CBOR reader of its own and RFC 9052's COSE_Mac0 / COSE_Sign1 structure. SHA-256, # Ed25519 and the key log only; no new dependency. live_watermark = ["live_room"] # Live ads (extensions/live-ads): `wai.live.ads` — server-guided ad insertion for rooms: the # room authority's signed ad policy (WAP1), the schedule of breaks the room's `cue` events open # and close with the post-roll annotation (WAB1), each break's HLS interstitial and preload date # ranges and DASH alternative-presentation event written exactly, the HLS asset lists and DASH # list MPDs each viewer is served, and the room verifier extended to the break form of # wai.video.ssai's receipt: the decision recomputed, the asset list bound, the spend held to the # decider grant's ceiling. With it, ad presentation (extensions/ad-presentation): # `wai.live.ad_presentation` — a player's signed claim (WPC1) that it presented one impression, # its spans of visible and audible play under the viewability rule an ad policy of version 2 # names, an optional device attestation token of RFC 9577 checked against the impression's own # challenge and RFC 9578's publicly verifiable type, and the room verifier's spend counting only # the impressions whose claim verifies. SHA-256, SHA-384, BLAKE3, Ed25519 and the key log, and # num-bigint (already a dependency of `oer`) for the RSA arithmetic. live_ads = ["live_room", "video_ssai", "dep:num-bigint"] # Live provenance (extensions/live-provenance): `wai.live.provenance` — the live video provenance # of C2PA 2.4 §19 for a room's CMAF tracks and a device's CMAF take, written and verified with no # C2PA library: ISO BMFF segments and the BMFF hash over whole-box exclusions, the JUMBF manifest # store, COSE_Sign1 with EdDSA and the OKP key, the claim signer's X.509 chain (DER written and # read here), per-segment manifests chained by manifest identifier, Verifiable Segment Info under # rotating session keys, and each segment tied to the JWP group receipt and object receipts of the # same chunks. CBOR through live_watermark's deterministic reader; the disclosure label and its # IPTC and AI-disclosure mapping through timed_text. SHA-256, BLAKE3 and Ed25519 only; no new # dependency. live_provenance = ["live_watermark", "timed_text"] # A still of packaging §5.7 (src/png_still.rs): one RGB8 frame as a `wai.image.png` payload, # every byte a pure function of the frame, and the reader that decodes any 8-bit RGB PNG # without interlace, with an inflater of its own. No dependency. The reference packager # (wai-pack) and the deriving edge write and read stills with it. png_still = [] # The deriving edge (extensions/deriving-edge.md): `wai.edge.derivation` — the record an edge # signs for an object it derived from delivered objects (a wai.derive.* operation over 8-bit RGB # samples, a frame of a wai.video.int_motion clip rebuilt as a still or a JPEG picture, a WAI2 # component exploded), naming each input by its content hash, its delivery receipt and the # record that derived it; the derivations' arithmetic; the verifier that follows a derived # object back to its source, re-executing each replicate hop whose inputs it holds; and the # reference edge's derive. Its delivery receipts are jwp_delivery's (receipt_claims), its key # logs key_log's (key_discovery), its clips int_video's (video_int); jpeg-encoder, already a # dependency of `codecs`, writes its attested JPEG outputs. No new dependency. derive_edge = ["key_discovery", "video_int", "png_still", "dep:jpeg-encoder"] # Synthesis provenance (extensions/synthesis): `wai.media.synthesis` — the origin claim of an # object, a group or a track (captured, reconstructed, assistive or synthesized; the class rises # along a chain of derivations and never falls), its IPTC digital source type and C2PA statement, # the two pinned integer derivations whose recomputation proves an assistive claim, the marking # and detection records of the second marking layer and their agreement with the claim, the # tracks of a room's AI participants, reviews that a player presents only on a decode path of # the review's tier, and the label obligations of a player's signed log. SHA-256, BLAKE3, # Ed25519 and the key log only; no new dependency. synthesis = ["live_room", "neural_int"] # Contribution records (extensions/contribution): `wai.media.contribution` — a tool's session of # parties (people by key, each countersigning its membership; models by digest), the signed hash # chain of steps (author, generate, candidates, select, edit, inpaint, transform, compose, reject) # in a Merkle tree for selective disclosure, the authorship map computed by re-executing each # act's dependency rule (made_by and directed_by per sample, unknown and undisclosed never # credited), the checks a verifier makes (regions, selections, regeneration, recomputation), and # the agreement with the output's origin claim. Reuses synthesis (its records and derivations) # and generate (the pinned generator its exact steps regenerate with); no new dependency. contribution = ["synthesis", "generate"] # Takedown (extensions/takedown): `wai.media.takedown` — a service's signed takedown of a source # (an object by content hash, a group, a track or a take) under a policy that pins a registry of # regime clocks (registry/takedown-clocks.json) and names its stores; the derivation closure # computed from deriving-edge records, synthesis origin claims and the delivery receipts of the # groups it reaches, against the set the takedown states, with perceptual matches kept apart; # the holders' signed purges and the time to removal held to the clock; and the signed counts # per clock, ground, category and source, recomputed. Reuses derive_edge and synthesis (their # readers), jwp_delivery (group expansion) and settlement (the acknowledgements that show who # served or received an object); no new dependency. takedown = ["derive_edge", "synthesis", "settlement"] # Direction records (extensions/direction): `wai.media.direction` — a director's signed # storyboard (shots, durations, subjects by reference picture, the framing each opens on, an # order), keyframes (a subject's box and its size, position and angle classes, and a camera # window, at stated frames, with pinned integer interpolation; regions held to a reference) and # sequence (shots, their parts, order, cuts and dissolves); the tool's directed output naming # them with every clip frame's layout, the timeline as made and its frames by digest; the pinned # integer render that recomputes every frame from layers wai.generate.spectral regenerates; the # framing measure; and the frames each element governs. Reuses generate and the claim reader; # SHA-256, BLAKE3 and Ed25519 only; no new dependency. direction = ["receipt_claims", "generate"] # The second marking layer's registered scheme, wai-mark:tent64 (extensions/synthesis.md §7.5), # measured: the attack battery (re-encoding with wai.video.int_motion's encoder, the pinned # derivations of §4, area resampling, crops, rotations, noise from a fixed stream, brightness, # contrast, a local blur), the measurement sets generated from fixed seeds (wai.generate.spectral's # generator and a dead-leaves generator), PSNR and SSIM, and the scheme's conformance corpus. The # scheme itself is under `synthesis`; this adds no dependency. synthesis_mark = ["synthesis", "video_int", "generate", "png_still"] # Exact upscale (extensions/exact-upscale): `wai.media.upscale` — the upscale record an origin # signs for a picture a sink upscales with `wai-upscale:sr2` or `wai-upscale:sr4` (`int_sr`, the # integer network over wai-ops/1 under a `WSR1` prior held by digest), with the residual (a WIR1 # payload of staged delivery, decoded over the upscaled picture) that brings it to the origin's # target or to a stated bound; and the sink's presentation statement, which counts the pixels and # frames of a span that were transmitted, derived exactly, edited by an unprovable step or # generated, each held to its origin claim (synthesis). Its claims are synthesis's, its residuals # staged's. SHA-256, BLAKE3 and Ed25519 only; no new dependency. exact_upscale = ["synthesis", "staged"] # AI usage preferences and consumption claims (extensions/ai-usage): `wai.ai.usage` — the usage # statement (draft-ietf-aipref-vocab-08's Structured Field form, the TDM Reservation Protocol's # properties and the Training and Data Mining Assertion's entries, verbatim) in an envelope's # manifest, a room's WAU1 record and a grant's terms; the HTTP and catalog fields checked # against it; and the jwp-receipts `consumption` claim checked against its objects and room. # RFC 9651's Dictionary parser is written here. SHA-256, Ed25519 and the room's records only; # no new dependency. ai_usage = ["live_room"] # Delivery settlement (extensions/settlement): `wai.delivery.settlement` — the acknowledgement a # downstream party signs of what it received (WDA1: per object class, the objects by content hash # under jwp-receipts §2.2's tree, their byte ranges and byte count, chained per window) and the # declaration a hop signs of a delivery nobody acknowledged; the byte-range proof over BLAKE3's # chunk tree (WBR1, through blake3's hazmat API, as the HTTP head proof); paid retrieval billed only # to a grant whose WRP1 proof the request carried; and the settlement statement (WSS1) whose lines, # declared bytes, per-class joules from live-metering's WMH1 and integer amount a verifier # recomputes. SHA-256, BLAKE3, Ed25519 and the room's records only; no new dependency. settlement = ["live_metering", "jwp_hash"] # Co-performance (extensions/co-performance): `wai.live.coperformance` — the room authority's # co-performance policy (WPP1); intents (WPI1) by digest or as notes, a text line or a camera # move, compared with what played under pinned rules, and the clock's fidelity statement # (WPF1), recomputed; turn schedules in microseconds or bars at a tempo, call-and-response # pairs and handovers (WPT1, WPH1), the floor, latency budgets and the clock's marks (WPM1); # audience inputs to selection windows (WPA1, WPW1), the commitment (WPC1) and the three # selection rules with their credits (WPS1). SHA-256, Ed25519 and the room's records only; no # new dependency. co_performance = ["live_events", "live_room"] # Age assurance (extensions/age-assurance): `wai.age.assurance` — rating claims (`wai-rating`) # for an object, a track, a span or a room under named schemes, carried through every # derivation; a room's age policy (`wai-age-policy`) of Privacy Pass issuers with one key per # threshold; admission by a token of RFC 9578's publicly verifiable type and the serving rule; # a sink's age state and predicate with no return path; admission receipts with every count # under 50 suppressed; and the minors' profile over a room's role bitmaps. It reuses the # ad-presentation module's RSASSA-PSS and token reader (`live_ads`): no new cryptography and # no new dependency. age_assurance = ["live_room", "live_ads"] # Influence attribution (extensions/influence): `wai.media.influence` — an owner's signed terms for # a work (its usage statement, the acts it allows, a per-use price or a revenue share, the tier a # use must reach) and signed catalogues; the conditioning record beside a contribution step that # names every work that conditioned it, and the pinned conditioned generator that regenerates the # step from them; the step map, the declared share rule and the attribution a verifier recomputes # (unknown and undisclosed never credited, an estimate never added); the attribution lines of a # WSS1 statement; and the owner's transparency report. Reuses contribution, settlement and # ai_usage; no new dependency. influence = ["contribution", "settlement", "ai_usage"] # Bearer receipts (extensions/bearer-receipts): `wai.bearer.receipts` — one receipt on every # bearer. The jwp-receipts `transmission` and `reconciliation` claims (their bodies are # claim_receipt's), the verdict over a group a verifier derives from them (published, # transmitted or reconciled, never delivered on the publisher's word), the upper bound on a # receiver's share of a shared transmission's energy, and confirmation with no return path, # where a key log that arrives on the bearer anchors nothing. Ed25519, BLAKE3 and the key log # only; no new dependency. bearer_receipts = ["key_discovery"] # Exploration (extensions/exploration): `wai.media.exploration` — six integer descriptors over a # picture's RGB8 samples; quality-diversity archives (MAP-Elites over a declared grid, run by a # pinned schedule over wai.generate.spectral, so every elite regenerates and the archive replays # bit for bit); the default set of a prompt and a work's default-distance (measured for the exact # generator, an estimate otherwise, unknown never zero); collection statements (coverage and # pairwise distances); taste priors (integer ranking models, signed by their owners, carrying a # wai.ai.usage statement), rankings under them, and the disclosure of what steered a pick. # SHA-256, BLAKE3, Ed25519 and ai_usage's statement reader; no new dependency. exploration = ["generate", "ai_usage"] # Timed text and live captions (extensions/timed-text): `wai.text.timed` — the cue model, # live caption revisions (`caption` events of wai.live.events with the WTX1 annotation), # and their exact mappings onto WebVTT documents and segments, the IMSC1 Text Profile, # the MoQ caption timelines, CTA-608 (CC1, pop-on and roll-up) and HLS, with the # machine-generation disclosure carried through each. No new dependency: the XML is # written by hand. timed_text = ["live_events"] # Access services (extensions/access-services): `wai.access.services` — a caption track's # latency, stability and accuracy computed from its signed revisions (sources placed on the # room clock through a take's opening commitment, a reference transcript, word alignment in # integer arithmetic) and the check of a stated figure; audio description (script, ducking, # voicing, synchronisation to DAPT §5.5's bounds) and its DAPT document, written by hand; # sign language as a pose or video track bound to final caption revisions, with a review; and # the completeness claim of a room session. SHA-256, Ed25519 and JCS only; no new dependency. access_services = ["timed_text", "capture_take"] # Object-based spatial audio (extensions/spatial-audio): the deterministic # Fx mixdown engine. Reuses the world `Fx` floor + blake3; no codec/ML deps # (sources arrive as decoded mono PCM — decoding the wai.audio.* assets is # the sink's job, exactly as glb/spz decode is). audio_scene = ["world"] # Haptics (extensions/haptics): touch as a tiny keyframed envelope, # reconstructed in the Fx floor. Sample-equivalence; no codec/ML deps. haptic = ["world"] # Volumetric / 4D temporal Gaussian splats (extensions/volumetric): each # Gaussian's keyframed tracks reconstructed at frame N in the Fx floor. # Frame-state-equivalence; no codec/ML deps (the render is the sink's). splat4d = ["world"] # Music as instructions (extensions/score): a note-event score rendered to # a canonical PCM mixdown by a deterministic trig-free synth in the Fx # floor. Mixdown-equivalence; no codec/ML deps (the instrument is the sink's). score = ["world"] # Asset provenance (extensions/provenance): a signed, energy-accounted # lineage receipt for opaque captured content WAI does not reconstruct. # Reuses the JWP Merkle + Ed25519; no codec/ML deps. provenance = ["world"] # OER/2 outcome-and-energy receipts (extensions/oer-receipts.md): a verifier for # receipts that grade what a unit of work cost (projected/simulated/derived/measured), # content-address and chain it, and sign it. Conformance is reason-set equality with # the reference verifier and the portable C kernel over oer-conformance/. oer = ["dep:blake3", "ed25519", "dep:num-bigint", "serde_json/float_roundtrip"] # jwp-receipts §2.1's object content hash (src/jwp_hash.rs), on its own so any # receipt family that names an object can compute it with BLAKE3 alone. jwp_hash = ["dep:blake3"] # Staged delivery (extensions/staged-delivery.md): a base first, then refinements as # their own objects, each bound to what it refines by content hash. The residual form # (WIR1) is integer rANS (neural_int); content hashes are jwp_hash's BLAKE3; stage # hashes are SHA-256, always on. staged = ["neural_int", "jwp_hash"] # HTTP delivery (extensions/http-delivery.md): objects named by their content hash, the # WHP1 head proof (BLAKE3's tree, through jwp_hash's BLAKE3), verified range fetch of one # WAI2 component, the codecs union and floor, and an origin's responses. Component # digests are SHA-256, always on. No I/O in the library; `wai http` does it. http = ["jwp_hash"] # Staged-delivery measurement (extensions/staged-measurement.md): the counted bytes of # an envelope, the output tree, and the deterministic evaluation of a staged title — # its prefixes' counted bytes, outputs and quality integers, first presentable, # layering overhead and deduplication — over the staged sink and the integer decoders. # Pure integer, no ONNX, no file system on wasm32. stage_measure = ["staged", "video_int", "audio_int", "splat_int"] # Delivery telemetry (extensions/delivery-telemetry.md): unsigned, advisory observations, # their CMCD version 2 and CMSD reports as RFC 9651 Structured Field Values, and session # metrics. No dependency beyond serde_json; wasm32-clean. telemetry = [] # Typed receipt classes on the JWP chain (extensions/jwp-receipts.md §2.4.3–§2.4.7, # §2.6, §3.1–§3.2): `claim` receipts of class energy / lawful-basis / log-inclusion, # the soft-binding class, and recovery under the ancestor rule. Needs `provenance` # for the coverage vocabulary and `oer` for the evidential grades and the OER receipt # an energy claim may name, which it reads and verifies through `crate::oer`; and # `staged`, so a session verifier holding envelopes counts a refinement layer's `WIR1` # payload (staged-measurement §3) and reads its `refines`. Its one direct dependency, # curve25519-dalek, is already in the graph under ed25519-dalek. receipt_claims = ["provenance", "oer", "jwp_hash", "staged", "dep:curve25519-dalek"] # Key discovery and signing authority (extensions/jwp-receipts.md §7): the origin key # log a `did:web` signer_id names, anchoring, the confirmation reported beside a receipt's # or claim's verdict, and the authorisation and revocation of decoder and reconstruct # modules (§7.9). Adds no dependency: it signs and hashes with what `receipt_claims` # already brings, and a module digest is the SHA-256 `oer` already brings. key_discovery = ["receipt_claims"] # The `wai` CLI's TLS client for anchoring an origin (`wai http receipts --key-origin`, # http-delivery §8.4): rustls with the operating system's trust store. Built into the # binary only; without it the CLI refuses to anchor rather than fetch over plaintext. cli_tls = ["http", "key_discovery", "dep:rustls", "dep:rustls-platform-verifier"] # Emit a REAL C2PA manifest (not just the assertion shapes). Off by default: # the SDK is a large dependency chain and most WAI consumers only need the # binding types, which `provenance` already gives them. c2pa_emit = ["provenance", "dep:c2pa"] # wai.world.model — generative-world transport: a signed, replay-equivalent action # trace (reuses the world CausalOp log) + per-frame provenance. The neural sibling # of wai.world.replay; the renderer is a declared world model (sink-supplied, or the # int_* family for byte-exact frames). world_model = ["world", "provenance"] # Linear film (extensions/linear-film): a film is a sealed camera-on-rails # world — the world replay (replay-equivalence) + a keyframed camera track # (Fx floor) + a frame schedule, verified frame-by-frame (film-equivalence). # Composes the world engine; pulls `score` so a reel can embed a soundtrack # (one envelope = movie + sound). No codec/ML deps (the render is the sink's). film = ["world", "score"] # Deterministic quantum-circuit SIMULATION (extensions/quantum-sim, # `wai.quantum.circuit2` and the frozen `wai.quantum.circuit`): the wire carries a # gate op-log (WQC container), the sink # classically simulates it in a fixed-point complex floor, the statevector is # byte-identical on every machine (statevector-equivalence). Pure i64, no float — # blake3 for the conformance/receipt hashes, same discipline as the other floor # classes. No quantum hardware (it would break determinism). Compiles to wasm32. quantum = ["dep:wai-quantum", "wai-quantum/quantum"] # The energy-accounted seal for a quantum reconstruction (extensions/quantum-sim # § Receipt): a signed receipt that separates the portable-exact WORK (n_ops·2^n # amplitude updates, recomputable) from the measured-attested ENERGY (joules_micro # from the sink's meter), both bound to a re-simulatable statevector hash. Reuses # the JWP Merkle + Ed25519 from `world` — reuse, not reinvention. quantum_receipt = ["quantum", "wai-quantum/quantum_receipt"] # The JWP receipt profile for the integer inter-frame video codec. Follows the # same shape as `quantum_receipt`: the class feature plus `world`, which is what # supplies blake3, ed25519 and the shared `merkle_root`. Kept OUT of `video_int` # on purpose — `int_video.rs` is #[path]-included by the byte-exact conformance # crate, and that crate must keep its three-dependency set to stay runnable on # every leg of the cross-arch matrix. video_receipt = ["video_int", "world"] # wai.video.manifest — attested, deduplicating, energy-accounted per-session # manifest. Reuses the world Merkle + Ed25519 and the JCP GrantRef (quantum_ops); # carries no pixel-decode dependency, so it stays a light, pure-Rust surface. # Depends on `world` EXPLICITLY: these receipts use # `crate::world::receipt::merkle_root`. That used to arrive transitively via # `quantum_ops`, which no longer provides it now the quantum stack lives in # its own crate — a dependency this feature always had and never declared. video_manifest = ["quantum_ops", "world"] # Energy meters — the source of a receipt's joules_micro. Reuses the # EnergyProvenance ladder; hardware counter vs calibrated model, mechanically. energy_meter = ["video_manifest"] # wai.video.ssai — attested ad decisioning + per-impression receipt. Reuses the # manifest module's EnergyProvenance + the GrantRef/Merkle/Ed25519 floor. # Pure decision policy (no deps) — separable so it can be model-checked. video_policy = [] video_ssai = ["video_manifest", "video_policy"] # wai.video.keys — attested content-key release; the DRM audit trail as a # recomputable decision. Reuses the manifest floor (EnergyProvenance, GrantRef, # Ed25519). video_keys = ["video_manifest"] # wai.video.package — deterministic segmentation + attested, deduplicating # SegmentMap. Reuses the manifest floor (EnergyProvenance, GrantRef, Merkle). Also the # packaging extension's stage index (WSIX) and version-2 package receipt, which name # each object by jwp-receipts §2.1's content hash (jwp_hash). video_package = ["video_manifest", "jwp_hash"] # wai.video.channel — virtual linear / FAST assembly; the program-as-run hash # chain. Reuses the manifest floor (EnergyProvenance, GrantRef, Merkle). video_channel = ["video_manifest"] # The whole OTT workflow suite in one switch. video_workflow = ["video_manifest", "video_ssai", "video_keys", "video_package", "video_channel"] # Balanced-ternary matrix-product-state transform (`wai.ternary.tt`, # extensions/ternary-tt): quantum-INSPIRED (tensor-network) compression whose # novel delta is an INTEGER core scale — the whole decode is pure i64/i128, so a # ternary-MPS reconstruction is byte-identical on every machine (a portable # reconstruction hash), unlike the float-scale ternary/MPS fabric it ports from. # Lossy codec, deterministic decode. Encoder-side float (SVD) only. Reuses # int_transform's fixed-point idiom (neural_int) + blake3 for the recon hash. ternary = ["neural_int"] # The energy-accounted seal for a ternary-MPS reconstruction (extensions/ternary-tt # § Receipt): a signed receipt separating portable-exact WORK (trit_macs) from # measured-attested ENERGY (joules_micro), bound to the WQTT payload hash + a # re-decodable reconstruction hash. Reuses the JWP Merkle + Ed25519 from `world`. ternary_receipt = ["ternary", "world"] # Quantum-operations attestation (extensions/quantum-ops, `wai.quantum.calibration` # + `wai.quantum.job`): signed, content-addressed, joule-metered, grant-authorized # receipts of calibration runs and QPU jobs — the verify-half of WAI applied to the # quantum-control industry. WAI does NOT run hardware; it owns the receipt. Reuses # the JWP Merkle + Ed25519 from `world`; no sim/codec deps. quantum_ops = ["dep:wai-quantum", "wai-quantum/quantum_ops"] # Deterministic autonomous CALIBRATION engines (extensions/quantum-ops § Calibration): # a fixed-point qubit-device simulator + autonomous tune-up algorithms (Rabi π-pulse # to start), byte-exact and reproducible, sealing a wai.quantum.calibration receipt per run. Pulls quantum_ops. quantum_cal = ["quantum_ops", "wai-quantum/quantum_cal"] # Deterministic quantum ERROR MITIGATION (extensions/quantum-ops § Mitigation, # `wai.quantum.mitigate`): the classical post-processing layer between raw QPU # counts and the reported number — zero-noise extrapolation, tensored readout # inversion, classical shadows — in pure fixed-point, byte-exact, each sealing a # signed, joule-metered MitigationReceipt over the step. Pulls quantum_ops. quantum_mitigate = ["quantum_ops", "wai-quantum/quantum_mitigate"] # Deterministic quantum LDPC DECODING (extensions/quantum-ops § Decoding, # `wai.quantum.decode`): a fixed-point Relay-BP (normalized min-sum) decoder for # qLDPC codes (toric + bivariate-bicycle), byte-exact on every machine, each # decode sealing a signed, joule-metered DecodeReceipt carrying joules-per-decode # signed with the correction. Pulls quantum_ops. quantum_qec = ["quantum_ops", "wai-quantum/quantum_qec"] # Deterministic FILTER-FUNCTION control + NOISE SPECTROSCOPY (extensions/quantum-ops # § Calibration, frequency domain): the filter-function overlap χ = ∫ S(ω)F(ω)/ω² # — DD noise spectroscopy (reconstruct S(ω) from a filter bank) + filter-function # robust control (reshape a DD sequence to dodge a PSD). Fully offline, byte-exact, # sealing wai.quantum.calibration receipts. Pulls quantum_cal (trig/exp + seal). quantum_control = ["quantum_cal", "wai-quantum/quantum_control"] # Deterministic NOISE LEARNING (extensions/quantum-ops § Calibration, noise model, # `wai.quantum.cal.noise_learn`): Cycle Benchmarking + Cycle Error Reconstruction # of a sparse Pauli–Lindblad model — recover a hidden device's Pauli error rates # from a simulated twirled-cycle experiment (multiplicative NNLS), byte-exact, # sealing a signed model whose hash a MitigationReceipt binds (the PEC producer). quantum_noise = ["quantum_cal", "wai-quantum/quantum_noise"] # Deterministic circuit COMPILATION + equivalence proof (extensions/quantum-ops # § Compilation, `wai.quantum.compile`): a coupling-graph router (SWAP insertion) # + a byte-exact Clifford stabilizer-tableau equivalence check, sealing a signed # CompileReceipt that a routed circuit is equivalent to its source — compilation # correctness, which no compiler signs. Pulls quantum_ops. quantum_compile = ["quantum_ops", "wai-quantum/quantum_compile"] # Deterministic neutral-atom REARRANGEMENT (extensions/quantum-ops § Register # preparation, `wai.quantum.rearrange`): a Hungarian / LSAP solver that assigns a # defect-free target register a distinct loaded atom minimizing total move # distance, byte-exact, sealing a signed RearrangeReceipt whose success verdict is # re-checkable. Pulls quantum_ops. quantum_atom = ["quantum_ops", "wai-quantum/quantum_atom"] # WAI Quantum Toolchain (extensions/quantum-sim § Toolchain, # `wai.quantum.toolchain`): the compute core of a classical-hardware quantum IDE — # algorithm library + state analysis (Bloch, entanglement, expectations) + backend # selection (Clifford → statevector → tensor-network cascade) + OpenQASM interop, # all over the byte-exact fixed-point simulator. Framework-neutral, no cloud. quantum_toolchain = ["quantum", "wai-quantum/quantum_toolchain"] # OpenQASM 3 read one way on every surface (wai_quantum::qasm). quantum_qasm = ["quantum", "wai-quantum/quantum_qasm"] # The job service's engine (wai_quantum::engine): plan, run and sign a job as the # service does, re-exported as wai::engine for the browser binding. quantum_engine = ["quantum_qasm", "quantum_receipt", "wai-quantum/quantum_engine"] # Matrix Product State backend (extensions/quantum-sim § MPS, `wai.quantum.mps`): # the tensor-network "classical referee" — evolve a bounded-bond MPS gate-by-gate # with a deterministic complex Jacobi SVD truncation, reproducible on every machine # (approximate method → determinism + retained-weight fidelity, not byte-exact). # Verified against the dense simulator. Pure Rust; only IEEE-754 + - * / sqrt. quantum_mps = ["quantum", "wai-quantum/quantum_mps"] # Stabilizer / CHP backend (extensions/quantum-sim § Stabilizer, # `wai.quantum.stabilizer`): the O(n²) Clifford tier of the cascade — the # Aaronson–Gottesman tableau simulates + samples Clifford circuits far past the # dense 2^n wall (thousands of qubits), exact integer bit-arithmetic (no floats), # deterministic histograms. Rejects non-Clifford gates for fallback. quantum_stabilizer = ["quantum", "wai-quantum/quantum_stabilizer"] # Sparse-Pauli / Heisenberg propagation (extensions/quantum-sim § Pauli, # `wai.quantum.pauli`): the observable referee — propagate an observable backward # through the circuit as a truncated sum of Pauli strings (Begušić and Chan's sparse # Pauli dynamics). Computes ⟨O⟩ on large # low-magic circuits where no state vector exists; grows with magic, not qubits. quantum_pauli = ["quantum", "wai-quantum/quantum_pauli"] # Sparse Pauli dynamics at utility scale (arbitrary angles, up to 1024 qubits), # and its signed receipts. quantum_spd = ["quantum", "wai-quantum/quantum_spd"] quantum_spd_receipt = ["quantum_spd", "wai-quantum/quantum_spd_receipt"] # Tensor-network states on the hardware graph (simple update, belief propagation). quantum_bptn = ["quantum_spd", "wai-quantum/quantum_bptn"] # Fault-tolerant resource estimation (layout, distance, T factories, frontier), # and its signed receipts. quantum_resource = ["dep:wai-quantum", "wai-quantum/quantum_resource"] quantum_resource_receipt = ["quantum_resource", "wai-quantum/quantum_resource_receipt"] # Noisy Clifford circuits at QEC scale: frame sampling, detector error models, # exact matching, measured code models. quantum_frame = ["dep:wai-quantum", "wai-quantum/quantum_frame", "wai-quantum/quantum_uf"] # Tensor-network contraction: hyper-optimised trees, slicing, circuit amplitudes. quantum_tn = ["dep:wai-quantum", "wai-quantum/quantum_tn"] # Gaussian boson sampling: hafnians, torontonians, exact probabilities, samples, checks. quantum_gbs = ["dep:wai-quantum", "wai-quantum/quantum_gbs"] # The dense state vector at any angle: fusion, threads, the same bits everywhere. quantum_sv = ["dep:wai-quantum", "wai-quantum/quantum_sv", "wai-quantum/quantum_noisy"] # Architecture-level estimation: yoked storage, cultivation, CCZ factories, # reaction-limited time, whole machines. quantum_arch = ["dep:wai-quantum", "wai-quantum/quantum_arch"] # qLDPC memory at circuit level: bivariate-bicycle codes, BP-OSD. quantum_ldpc = ["quantum_frame", "wai-quantum/quantum_ldpc"] # Quantum-inspired optimisation: simulated bifurcation, annealing, exact referee. quantum_qio = ["dep:wai-quantum", "wai-quantum/quantum_qio", "wai-quantum/quantum_dmrg", "wai-quantum/quantum_tdvp", "wai-quantum/quantum_chem", "wai-quantum/quantum_nqs"] quantum_qir = ["quantum_toolchain", "wai-quantum/quantum_qir"] # The fabric: members, parity against the CPU reference, certification, # placement by joules, and the core in 32-bit lanes. quantum_fabric = ["quantum", "quantum_ops", "wai-quantum/quantum_fabric"] # The fabric's WebGPU member: the 32-bit-lane kernel in WGSL through the # platform's GPU interface, certified bit-exact per adapter, and # `wai_quantum_vectors verify --webgpu`. Opt-in: it is the one feature that # reaches a platform interface. quantum_fabric_webgpu = ["quantum_fabric", "wai-quantum/quantum_fabric_webgpu"] # Variational quantum machine learning (extensions/quantum-sim § VML, # `wai.quantum.vml`): the interference-based ML the thermodynamic-computing pivot # left behind — a Quantum Circuit Born Machine (P_θ(x)=|ψ_θ(x)|²) trained by the # exact parameter-shift gradient on the classical state vector, plus a # barren-plateau probe (the honest limit). Deterministic f64. Pure Rust, no deps. quantum_vml = ["dep:wai-quantum", "wai-quantum/quantum_vml"] # The phasor bridge (extensions/quantum-sim § Phasor, `wai.quantum.phasor`): a # quantum feature-map model is exactly a Fourier series of phasors (Schuld et al.). # Compute the model on the state vector, extract its spectrum, and reproduce the # identical function as a classical phasor sum (FHRR/HDC) — same interference, two # substrates — with a qFHRR quantized-phase variant. Pure f64, no deps. quantum_phasor = ["dep:wai-quantum", "wai-quantum/quantum_phasor"] # The full Born machine on the qFHRR substrate (extensions/quantum-sim § qFHRR, # `wai.quantum.qfhrr`): run the whole generative distribution P(x)=|ψ(x)|² with # amplitude phases held at qFHRR resolution (b-bit, integer-native) — a trained # Born machine deployed end-to-end on the phasor substrate, converging to the exact # state vector as phase bits grow. Pure f64; reuses the vml ansatz for the ref. quantum_qfhrr = ["quantum_vml", "wai-quantum/quantum_qfhrr"] # Phasor-feature classifier (extensions/quantum-sim § Kernel, `wai.quantum.kernel`): # the quantum kernel deployed as random Fourier / FHRR phasor features + a ridge # classifier — separates nonlinearly-separable data a linear model cannot, at qFHRR # phase resolution, with a counted phasor-op tally for joule pricing. Pure f64. quantum_kernel = ["dep:wai-quantum", "wai-quantum/quantum_kernel"] # Phasor energy meter (extensions/quantum-sim § Receipt, `wai.quantum.phasor`): the # energy-accounted seal for an interference computation. Splits portable-exact # phasor WORK — `D·(dim+1)·n`, linear and recomputable from the shape — from # measured-attested joules, binding both to a reproducible-f64 result hash. Prices # every bind/bundle/similarity op so qFHRR is an accountable substrate, not merely a # fast one. Reuses the JWP Merkle + Ed25519 from `world`. quantum_phasor_meter = ["dep:wai-quantum", "wai-quantum/quantum_phasor_meter"] # Learning from quantum data (extensions/quantum-sim § QData, `wai.quantum.qdata`): # the exponential sample-complexity separation for Pauli-channel learning — Ω(2^n) # copies entanglement-free vs O(1/ε²) n-independent copies with a two-copy Bell # measurement (Chen–Cotler–Huang–Li / Huang Science 2022). The quantum-data advantage # that survives dequantization; it is why `noise_learn`'s Bell/CB sampling is # data-efficient. Pure f64, deterministic in the seed. quantum_qdata = ["dep:wai-quantum", "wai-quantum/quantum_qdata"] # Quantum Bill of Materials (extensions/quantum-ops § Provenance, # `wai.quantum.qbom`): assemble the stage receipts of one quantum computation # (compile/calibrate/execute/mitigate/…) into a single signed, content-addressed # provenance manifest with a total-energy roll-up and an operator-envelope export; # binds each stage to a receipt that itself verifies. Pulls quantum_ops. quantum_qbom = ["quantum_ops", "wai-quantum/quantum_qbom"] # Mixed states (extensions/quantum-sim § Information): density matrices, the # partial trace, purity, exact Pauli expectations, and CHSH against the classical # and Tsirelson bounds. A state vector cannot describe a subsystem; this can. quantum_info = ["quantum", "wai-quantum/quantum_info"] # Qubits AND qutrits (extensions/quantum-sim § Qudits): the Weyl–Heisenberg group, # the Fourier gate over `Z_d`, the controlled sum — exact for `d = 2` and `3`. quantum_qudit = ["quantum", "wai-quantum/quantum_qudit"] # Key distribution and security (extensions/quantum-sim § Communication): BB84 with # an intercept-resend eavesdropper, and the no-cloning theorem priced. quantum_comm = ["quantum", "wai-quantum/quantum_comm"] # The limits on encoding and transport (extensions/quantum-sim § Source): von # Neumann entropy, the Schumacher limit, and the Holevo bound — which says `n` # qubits carry at most `n` classical bits, so quantum does not compress classical # media. The layer that lets WAI state real limits instead of overclaiming. quantum_source = ["quantum_info", "wai-quantum/quantum_source"] # Transport itself (extensions/quantum-sim § Channel): Kraus channels and # linear-inversion tomography, with the law that a channel can only lose # information, never create it. quantum_channel = ["quantum_source", "wai-quantum/quantum_channel"] # Codec-chain examples gate on `codecs` (they call the C codec wrappers), so # a `--no-default-features --features neural` build doesn't try to compile them. [[example]] name = "gen_preview" path = "examples/gen_preview.rs" required-features = ["generate"] [[example]] name = "int_hyper_decode_frame" path = "examples/int_hyper_decode_frame.rs" required-features = ["neural_int"] [[example]] name = "int_audio_decode" path = "examples/int_audio_decode.rs" required-features = ["audio_int"] [[example]] name = "int_world_decode" path = "examples/int_world_decode.rs" required-features = ["world_int"] [[example]] name = "int_splat_decode" path = "examples/int_splat_decode.rs" required-features = ["splat_int"] [[example]] name = "opus_check" path = "examples/opus_check.rs" required-features = ["codecs"] [[example]] name = "dl_check" path = "examples/dl_check.rs" required-features = ["codecs"] [[example]] name = "jpeg_test" path = "examples/jpeg_test.rs" required-features = ["codecs"] # `encode` and `decode` need the `codecs` feature and are compiled out without it; # every other command (wrap, unwrap, inspect, capabilities, registry export) builds # with --no-default-features, which is how CI runs it. `generate` needs the feature # `generate`, and `score` the feature `score`; without them each says so. [[bin]] name = "wai" path = "src/bin/wai.rs" [[bin]] name = "wai_int_synth_vectors" path = "src/bin/wai_int_synth_vectors.rs" required-features = ["neural_int"] # The binary payload vectors of the integer codecs and their refusal fixtures # (extensions/integer-payloads.md §12): `gen` converts the committed JSON, `verify` # requires byte-identical regeneration, the sidecars' SHA-256 and every fixture's code. [[bin]] name = "wai_int_payload_vectors" path = "src/bin/wai_int_payload_vectors.rs" required-features = ["video_int", "audio_int", "splat_int"] [[bin]] name = "wai_staged_vectors" path = "src/bin/wai_staged_vectors.rs" required-features = ["staged", "video_int", "audio_int", "splat_int"] [[bin]] name = "wai_stage_bench" path = "src/bin/wai_stage_bench.rs" required-features = ["staged", "video_int", "audio_int", "splat_int"] [[bin]] name = "wai_film_vectors" path = "src/bin/wai_film_vectors.rs" required-features = ["film"] [[bin]] name = "wai_http_vectors" path = "src/bin/wai_http_vectors.rs" required-features = ["http"] [[bin]] name = "wai_world_vectors" path = "src/bin/wai_world_vectors.rs" required-features = ["world"] [[bin]] name = "wai_live_events_vectors" path = "src/bin/wai_live_events_vectors.rs" required-features = ["live_events"] [[bin]] name = "wai_live_room_vectors" path = "src/bin/wai_live_room_vectors.rs" required-features = ["live_room"] [[bin]] name = "wai_capture_take_vectors" path = "src/bin/wai_capture_take_vectors.rs" required-features = ["capture_take"] [[bin]] name = "wai_live_compose_vectors" path = "src/bin/wai_live_compose_vectors.rs" required-features = ["live_compose"] [[bin]] name = "wai_live_record_vectors" path = "src/bin/wai_live_record_vectors.rs" required-features = ["live_record"] [[bin]] name = "wai_live_metering_vectors" path = "src/bin/wai_live_metering_vectors.rs" required-features = ["live_metering"] [[bin]] name = "wai_energy_steering_vectors" path = "src/bin/wai_energy_steering_vectors.rs" required-features = ["energy_steering"] [[bin]] name = "wai_browser_sink_vectors" path = "src/bin/wai_browser_sink_vectors.rs" required-features = ["browser_sink"] [[bin]] name = "wai_live_moderation_vectors" path = "src/bin/wai_live_moderation_vectors.rs" required-features = ["live_moderation"] [[bin]] name = "wai_synthesis_vectors" path = "src/bin/wai_synthesis_vectors.rs" required-features = ["synthesis"] [[bin]] name = "wai_takedown_vectors" path = "src/bin/wai_takedown_vectors.rs" required-features = ["takedown"] [[bin]] name = "wai_contribution_vectors" path = "src/bin/wai_contribution_vectors.rs" required-features = ["contribution"] [[bin]] name = "wai_direction_vectors" path = "src/bin/wai_direction_vectors.rs" required-features = ["direction"] [[bin]] name = "wai_synthesis_mark_vectors" path = "src/bin/wai_synthesis_mark_vectors.rs" required-features = ["synthesis_mark"] [[bin]] name = "wai_upscale_vectors" path = "src/bin/wai_upscale_vectors.rs" required-features = ["exact_upscale"] [[bin]] name = "wai_upscale_measure" path = "src/bin/wai_upscale_measure.rs" required-features = ["exact_upscale", "video_int"] [[bin]] name = "wai_live_watermark_vectors" path = "src/bin/wai_live_watermark_vectors.rs" required-features = ["live_watermark"] [[bin]] name = "wai_live_ads_vectors" path = "src/bin/wai_live_ads_vectors.rs" required-features = ["live_ads"] # The deriving edge's corpus (edge-conformance/, extensions/deriving-edge.md §10). [[bin]] name = "wai_edge_vectors" path = "src/bin/wai_edge_vectors.rs" required-features = ["derive_edge"] # The reference deriving edge (extensions/deriving-edge.md): derive an object from objects of a # bundle under the edge's key, and verify a derived object back to its source. [[bin]] name = "wai_edge" path = "src/bin/wai_edge.rs" required-features = ["derive_edge"] [[bin]] name = "wai_ad_presentation_vectors" path = "src/bin/wai_ad_presentation_vectors.rs" required-features = ["live_ads"] [[bin]] name = "wai_live_provenance_vectors" path = "src/bin/wai_live_provenance_vectors.rs" required-features = ["live_provenance"] [[bin]] name = "wai_ai_usage_vectors" path = "src/bin/wai_ai_usage_vectors.rs" required-features = ["ai_usage"] [[bin]] name = "wai_settlement_vectors" path = "src/bin/wai_settlement_vectors.rs" required-features = ["settlement"] [[bin]] name = "wai_co_performance_vectors" path = "src/bin/wai_co_performance_vectors.rs" required-features = ["co_performance"] [[bin]] name = "wai_age_assurance_vectors" path = "src/bin/wai_age_assurance_vectors.rs" required-features = ["age_assurance"] [[bin]] name = "wai_influence_vectors" path = "src/bin/wai_influence_vectors.rs" required-features = ["influence"] [[bin]] name = "wai_bearer_vectors" path = "src/bin/wai_bearer_vectors.rs" required-features = ["bearer_receipts"] [[bin]] name = "wai_exploration_vectors" path = "src/bin/wai_exploration_vectors.rs" required-features = ["exploration"] [[bin]] name = "wai_timed_text_vectors" path = "src/bin/wai_timed_text_vectors.rs" required-features = ["timed_text"] [[bin]] name = "wai_access_services_vectors" path = "src/bin/wai_access_services_vectors.rs" required-features = ["access_services"] [[bin]] name = "wai_world_meter" path = "src/bin/wai_world_meter.rs" required-features = ["world", "receipt_claims"] [[bin]] name = "wai_audio_vectors" path = "src/bin/wai_audio_vectors.rs" required-features = ["audio_scene"] [[bin]] name = "wai_haptic_vectors" path = "src/bin/wai_haptic_vectors.rs" required-features = ["haptic"] [[bin]] name = "wai_feed_vectors" path = "src/bin/wai_feed_vectors.rs" required-features = ["world"] [[bin]] name = "wai_avatar_vectors" path = "src/bin/wai_avatar_vectors.rs" required-features = ["world"] [[bin]] name = "wai_splat4d_vectors" path = "src/bin/wai_splat4d_vectors.rs" required-features = ["splat4d"] [[bin]] name = "wai_oer_vectors" path = "src/bin/wai_oer_vectors.rs" required-features = ["oer"] [[bin]] name = "wai_oer_diff" path = "src/bin/wai_oer_diff.rs" required-features = ["oer"] [[bin]] name = "wai_pin_vectors" path = "src/bin/wai_pin_vectors.rs" [[bin]] name = "wai_claim_vectors" path = "src/bin/wai_claim_vectors.rs" required-features = ["receipt_claims"] [[bin]] name = "wai_jwp_vectors" path = "src/bin/wai_jwp_vectors.rs" required-features = ["receipt_claims"] [[bin]] name = "wai_signer_vectors" path = "src/bin/wai_signer_vectors.rs" required-features = ["key_discovery"] [[bin]] name = "wai-keys" path = "src/bin/wai_keys.rs" required-features = ["key_discovery"] [[bin]] name = "wai_quantum_vectors" path = "src/bin/wai_quantum_vectors.rs" required-features = ["quantum"] [[bin]] name = "wai_quantum_ops_vectors" path = "src/bin/wai_quantum_ops_vectors.rs" required-features = ["quantum_ops"] [[bin]] name = "wai_quantum_meter" path = "src/bin/wai_quantum_meter.rs" required-features = ["quantum_receipt", "receipt_claims"] [[bin]] name = "wai_video_meter" path = "src/bin/wai_video_meter.rs" required-features = ["video_receipt", "receipt_claims"] [[bin]] name = "wai_meter" path = "src/bin/wai_meter.rs" required-features = ["haptic", "splat4d", "score", "film", "receipt_claims"] [[bin]] name = "wai_prov" path = "src/bin/wai_prov.rs" required-features = ["provenance", "codecs", "receipt_claims"] [[bin]] name = "wai_bench" path = "src/bin/wai_bench.rs" required-features = ["codecs"] [[bin]] name = "wai_decode_bench" path = "src/bin/wai_decode_bench.rs" required-features = ["neural_int", "video_int", "audio_int", "world_int", "splat_int"] [[bin]] name = "wai_bench_diff" path = "src/bin/wai_bench_diff.rs" required-features = ["codecs"] # A program, not a libtest suite: it lists its own executable's symbols, so the test # harness's code must not be in it (see the file's doc). [[test]] name = "jpegai_decode_symbols" path = "tests/jpegai_decode_symbols.rs" harness = false required-features = ["neural_int"] # Feature-gated integration tests that CI names with `--test`. Declared with their # features so that naming one without them stops cargo with an error, instead of # compiling the `#![cfg(feature)]` file to an empty binary that reports ok. [[test]] name = "int_audio" path = "tests/int_audio.rs" required-features = ["audio_int"] [[test]] name = "int_splat" path = "tests/int_splat.rs" required-features = ["splat_int"] [[test]] name = "cli_http" path = "tests/cli_http.rs" required-features = ["http"] [[test]] name = "int_kernels_vectors" path = "tests/int_kernels_vectors.rs" required-features = ["neural_int", "video_int", "audio_int", "world_int", "splat_int"] [[test]] name = "int_kernels_geometry" path = "tests/int_kernels_geometry.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "int_ops_differential" path = "tests/int_ops_differential.rs" required-features = ["legacy_int", "splat_int", "audio_int", "world_int"] [[test]] name = "int_synth_ops" path = "tests/int_synth_ops.rs" required-features = ["legacy_int"] [[test]] name = "int_audio_ops" path = "tests/int_audio_ops.rs" required-features = ["audio_int", "legacy_int"] [[test]] name = "int_splat_ops" path = "tests/int_splat_ops.rs" required-features = ["splat_int", "legacy_int"] # The integer decoders with their graphs on a GPU (`int_ops::gpu`): every committed vector # and refusal fixture of every capability that runs a `wai-ops/1` graph, against the decode # on the CPU, on every adapter found. Needs a GPU (or a software adapter) to run anything; # with none it prints SKIPPED, and fails under WAI_OPS_GPU_REQUIRE. [[test]] name = "ops_gpu" path = "tests/ops_gpu.rs" required-features = ["ops_gpu", "video_int", "audio_int", "splat_int", "world_int"] [[test]] name = "int_hyper_ops" path = "tests/int_hyper_ops.rs" required-features = ["video_int", "legacy_int"] # wai.world.model's integer renderer through its lowering world/1 (integer-operators §13.5). [[test]] name = "int_world_ops" path = "tests/int_world_ops.rs" required-features = ["world_int", "legacy_int"] [[test]] name = "jpegai_ops" path = "tests/jpegai_ops.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_nets_ops" path = "tests/jpegai_nets_ops.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "int_video_ops" path = "tests/int_video_ops.rs" required-features = ["video_int", "legacy_int"] [[test]] name = "wir1_ops" path = "tests/wir1_ops.rs" required-features = ["staged", "legacy_int"] # What the JPEG AI exact decoder holds against its direct decode (its own binary: a live-bytes allocator). [[test]] name = "jpegai_memory" path = "tests/jpegai_memory.rs" required-features = ["neural_int", "legacy_int"] # What that renderer holds against the direct renderer (its own binary: a live-bytes allocator). [[test]] name = "int_world_memory" path = "tests/int_world_memory.rs" required-features = ["world_int", "legacy_int"] [[test]] name = "int_mlicpp" path = "tests/int_mlicpp.rs" required-features = ["neural_int"] [[test]] name = "int_mlicpp_preflight" path = "tests/int_mlicpp_preflight.rs" required-features = ["neural_int"] [[test]] name = "int_mlicpp_ops" path = "tests/int_mlicpp_ops.rs" required-features = ["legacy_int"] [[test]] name = "cli_stage" path = "tests/cli_stage.rs" required-features = ["staged", "video_int", "audio_int", "splat_int"] [[test]] name = "staged_resources" path = "tests/staged_resources.rs" required-features = ["staged", "video_int"] [[test]] name = "staged_moq" path = "tests/staged_moq.rs" required-features = ["staged", "video_int", "receipt_claims"] [[test]] name = "int_payload" path = "tests/int_payload.rs" required-features = ["video_int", "audio_int", "splat_int"] [[test]] name = "int_payload_preflight" path = "tests/int_payload_preflight.rs" required-features = ["video_int", "audio_int", "splat_int"] [[test]] name = "int_payload_cost" path = "tests/int_payload_cost.rs" required-features = ["video_int", "audio_int", "splat_int", "legacy_int"] # The store of loaded parameter sets under the decodes that use it (src/int_set_cache.rs). [[test]] name = "int_set_cache" path = "tests/int_set_cache.rs" required-features = ["video_int", "audio_int", "splat_int"] [[test]] name = "int_video_enc_memory" path = "tests/int_video_enc_memory.rs" required-features = ["video_int"] [[test]] name = "generate" path = "tests/generate.rs" required-features = ["generate"] # `wai generate` and `wai score build|render` run as a user runs them, against the # committed generate vectors and score-conformance/. [[test]] name = "cli_generate_score" path = "tests/cli_generate_score.rs" required-features = ["generate", "score"] [[test]] name = "ffi_envelope" path = "tests/ffi_envelope.rs" required-features = ["ffi"] [[test]] name = "ffi_neural_pin" path = "tests/ffi_neural_pin.rs" required-features = ["neural", "ffi"] [[test]] name = "neural_native_decode" path = "tests/neural_native_decode.rs" required-features = ["neural"] [[test]] name = "jpegai_e2e_full" path = "tests/jpegai_e2e_full.rs" required-features = ["neural_int"] # Drives the `wai-keys` binary, so it needs the feature that builds it. [[test]] name = "wai_keys_cli" path = "tests/wai_keys_cli.rs" required-features = ["key_discovery"] # On 64-bit Arm, SHA-256 through the processor's SHA-2 instructions where it has them # (sha2's `asm` feature: its aarch64 backend, which detects the instructions at run time # and falls back to the portable code). Hashing a parameter set is a decode's to identify # it (SPEC §3.1), and a set can be tens of megabytes. The digests are the same bytes. # Not on Windows, whose toolchain does not assemble the sha2-asm sources the feature # brings in, and not on wasm32 or any other target, whose build this leaves as it is. [target.'cfg(all(target_arch = "aarch64", not(target_os = "windows")))'.dependencies] sha2 = { version = "0.10", features = ["asm"] } [dev-dependencies] serde_json = { version = "1", features = ["preserve_order"] } # construct manifests in tests # The bounds pass as it stood before its closed forms (`wai_ops::bounds_oracle`), which # the random-set differential (tests/int_ops_differential.rs) holds load step 8 to. wai-ops = { path = "../wai-ops", features = ["oracle"] } [build-dependencies] pkg-config = "0.3" # locate system libflac (cross-platform; replaces # the macOS-hardcoded .cargo/config.toml rustflags) cbindgen = { version = "0.29", default-features = false } # generate include/wai.h from the FFI surface so # SDK consumers get a typed C header instead of # hand-writing extern decls [profile.release] opt-level = 3 lto = true codegen-units = 1 # The HTTP corpus's falsification (http-conformance/falsify/run.sh): one target # directory, each patch rebuilt incrementally on the last; overflow checks and debug # assertions on, as in the tests, so a patch is judged by the code's own checks; enough # optimisation that each verify runs quickly. [profile.falsify] inherits = "dev" opt-level = 1 debug = false incremental = true overflow-checks = true debug-assertions = true [[bin]] name = "wai_score_vectors" path = "src/bin/wai_score_vectors.rs" required-features = ["score"] # Staged-delivery measurement (extensions/staged-measurement.md): `eval` one title, # `verify` the corpus staged-measure-conformance/ (fixtures regenerated in memory, # evaluations, the fixture tool's own reconstruction, goldens), `generate-goldens` # and `gen-fixtures` (never in CI), and `bench` (never in CI): one title's decode time # and decode figure on this machine, and, with `receipt_claims`, its session claim # (`--sign`). [[bin]] name = "wai_stage_measure" path = "src/bin/wai_stage_measure.rs" required-features = ["stage_measure"] [[test]] name = "stage_measure" path = "tests/stage_measure.rs" required-features = ["stage_measure"] # Its own binary: a counting allocator shows a title over an outsized base is refused # before anything is allocated for it. [[test]] name = "stage_measure_bounds" path = "tests/stage_measure_bounds.rs" required-features = ["stage_measure"] # Delivery telemetry (extensions/delivery-telemetry.md): `encode` an observation's CMCD # report, `decode` one, `verify` the corpus telemetry-conformance/, `gen` (never in CI). [[bin]] name = "wai_telemetry" path = "src/bin/wai_telemetry.rs" required-features = ["telemetry"] # Every other feature-gated integration test, declared with its features for the same # reason as those above: named in a step that lacks them, cargo stops with an error # instead of compiling the file to an empty binary that reports ok. A test file gated # on a feature without an entry here fails scripts/check-tests-in-ci.py. [[test]] name = "dash_read_bounds" path = "tests/dash_read_bounds.rs" required-features = ["http"] [[test]] name = "ffi_robustness" path = "tests/ffi_robustness.rs" required-features = ["codecs"] [[test]] name = "fuzz_smoke" path = "tests/fuzz_smoke.rs" required-features = ["codecs"] [[test]] name = "int_hyper_synth" path = "tests/int_hyper_synth.rs" required-features = ["neural_int"] [[test]] name = "int_video" path = "tests/int_video.rs" required-features = ["video_int"] [[test]] name = "int_video_halfpel" path = "tests/int_video_halfpel.rs" required-features = ["video_int"] [[test]] name = "int_video_keyframe" path = "tests/int_video_keyframe.rs" required-features = ["neural_int", "video_int"] [[test]] name = "int_video_sota_keyframe" path = "tests/int_video_sota_keyframe.rs" required-features = ["neural_int", "video_int"] [[test]] name = "int_world" path = "tests/int_world.rs" required-features = ["world_int"] [[test]] name = "int_world2" path = "tests/int_world2.rs" required-features = ["world_int"] [[test]] name = "int_world_shared" path = "tests/int_world_shared.rs" required-features = ["world_int", "world_model"] [[test]] name = "jpegai_bitstream_calibration" path = "tests/jpegai_bitstream_calibration.rs" required-features = ["neural_int"] [[test]] name = "jpegai_color_calibration" path = "tests/jpegai_color_calibration.rs" required-features = ["neural_int"] [[test]] name = "jpegai_cross_platform" path = "tests/jpegai_cross_platform.rs" required-features = ["neural_int", "provenance"] [[test]] name = "jpegai_dequant_calibration" path = "tests/jpegai_dequant_calibration.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_derive_calibration" path = "tests/jpegai_derive_calibration.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_e2e" path = "tests/jpegai_e2e.rs" required-features = ["codecs", "neural"] [[test]] name = "jpegai_e2e_chain" path = "tests/jpegai_e2e_chain.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_e2e_chroma" path = "tests/jpegai_e2e_chroma.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_e2e_dequant" path = "tests/jpegai_e2e_dequant.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_e2e_frontend" path = "tests/jpegai_e2e_frontend.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_e2e_hyperlatent" path = "tests/jpegai_e2e_hyperlatent.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_e2e_synthesis" path = "tests/jpegai_e2e_synthesis.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_efl_calibration" path = "tests/jpegai_efl_calibration.rs" required-features = ["neural_int"] [[test]] name = "jpegai_efn_calibration" path = "tests/jpegai_efn_calibration.rs" required-features = ["neural_int"] [[test]] name = "jpegai_hyper_calibration" path = "tests/jpegai_hyper_calibration.rs" required-features = ["neural", "legacy_int"] [[test]] name = "jpegai_hyperscale_calibration" path = "tests/jpegai_hyperscale_calibration.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_icci_calibration" path = "tests/jpegai_icci_calibration.rs" required-features = ["neural_int"] [[test]] name = "jpegai_icci_net_calibration" path = "tests/jpegai_icci_net_calibration.rs" required-features = ["neural_int"] [[test]] name = "jpegai_lef_calibration" path = "tests/jpegai_lef_calibration.rs" required-features = ["neural_int"] [[test]] name = "jpegai_live" path = "tests/jpegai_live.rs" required-features = ["codecs", "neural"] [[test]] name = "jpegai_lsbs_calibration" path = "tests/jpegai_lsbs_calibration.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_mans_calibration" path = "tests/jpegai_mans_calibration.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_mans_golden" path = "tests/jpegai_mans_golden.rs" required-features = ["neural"] [[test]] name = "jpegai_mcm_calibration" path = "tests/jpegai_mcm_calibration.rs" required-features = ["neural", "legacy_int"] [[test]] name = "jpegai_postfilter_chain" path = "tests/jpegai_postfilter_chain.rs" required-features = ["neural_int"] [[test]] name = "jpegai_reconstruct_calibration" path = "tests/jpegai_reconstruct_calibration.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_reconstruction_binding" path = "tests/jpegai_reconstruction_binding.rs" required-features = ["neural_int", "provenance"] [[test]] name = "jpegai_scope_ort" path = "tests/jpegai_scope_ort.rs" required-features = ["neural"] [[test]] name = "jpegai_sigma_index_calibration" path = "tests/jpegai_sigma_index_calibration.rs" required-features = ["neural_int", "legacy_int"] [[test]] name = "jpegai_synthesis_calibration" path = "tests/jpegai_synthesis_calibration.rs" required-features = ["neural", "legacy_int"] [[test]] name = "jpegai_uv_calibration" path = "tests/jpegai_uv_calibration.rs" required-features = ["neural", "legacy_int"] [[test]] name = "neural_cost_limit" path = "tests/neural_cost_limit.rs" required-features = ["ffi", "neural", "video_int"] [[test]] name = "semantic_path" path = "tests/semantic_path.rs" required-features = ["semantic"] [[test]] name = "text_decode_bounds" path = "tests/text_decode_bounds.rs" required-features = ["codecs"] [[test]] name = "media_decode_bounds" path = "tests/media_decode_bounds.rs" required-features = ["codecs"] [[test]] name = "container_reservations" path = "tests/container_reservations.rs" required-features = ["world", "audio_scene", "film", "score", "haptic", "splat4d"] [[test]] name = "extension_duration_limits" path = "tests/extension_duration_limits.rs" required-features = ["world", "audio_scene", "film", "score", "haptic", "splat4d"] [[test]] name = "text_decode_memory" path = "tests/text_decode_memory.rs" required-features = ["codecs"] [[test]] name = "video_receipt" path = "tests/video_receipt.rs" required-features = ["video_receipt"] [[test]] name = "world_model" path = "tests/world_model.rs" required-features = ["world_model"] [[test]] name = "live_events" path = "tests/live_events.rs" required-features = ["live_events"] [[test]] name = "live_room" path = "tests/live_room.rs" required-features = ["live_room"] [[test]] name = "capture_take" path = "tests/capture_take.rs" required-features = ["capture_take"] [[test]] name = "live_compose" path = "tests/live_compose.rs" required-features = ["live_compose"] [[test]] name = "live_record" path = "tests/live_record.rs" required-features = ["live_record"] [[test]] name = "live_metering" path = "tests/live_metering.rs" required-features = ["live_metering"] [[test]] name = "energy_steering" path = "tests/energy_steering.rs" required-features = ["energy_steering"] [[test]] name = "browser_sink" path = "tests/browser_sink.rs" required-features = ["browser_sink", "receipt_claims"] [[test]] name = "live_moderation" path = "tests/live_moderation.rs" required-features = ["live_moderation"] [[test]] name = "synthesis" path = "tests/synthesis.rs" required-features = ["synthesis"] [[test]] name = "takedown" path = "tests/takedown.rs" required-features = ["takedown"] [[test]] name = "contribution" path = "tests/contribution.rs" required-features = ["contribution"] [[test]] name = "direction" path = "tests/direction.rs" required-features = ["direction"] [[test]] name = "synthesis_mark" path = "tests/synthesis_mark.rs" required-features = ["synthesis_mark"] [[test]] name = "exact_upscale" path = "tests/exact_upscale.rs" required-features = ["exact_upscale"] [[test]] name = "exact_upscale_gpu" path = "tests/exact_upscale_gpu.rs" required-features = ["ops_gpu", "exact_upscale"] [[test]] name = "live_watermark" path = "tests/live_watermark.rs" required-features = ["live_watermark"] [[test]] name = "live_ads" path = "tests/live_ads.rs" required-features = ["live_ads"] [[test]] name = "ad_presentation" path = "tests/ad_presentation.rs" required-features = ["live_ads"] [[test]] name = "live_provenance" path = "tests/live_provenance.rs" required-features = ["live_provenance"] [[test]] name = "derive_edge" path = "tests/derive_edge.rs" required-features = ["derive_edge"] [[test]] name = "ai_usage" path = "tests/ai_usage.rs" required-features = ["ai_usage"] [[test]] name = "settlement" path = "tests/settlement.rs" required-features = ["settlement"] [[test]] name = "co_performance" path = "tests/co_performance.rs" required-features = ["co_performance"] [[test]] name = "age_assurance" path = "tests/age_assurance.rs" required-features = ["age_assurance"] [[test]] name = "influence" path = "tests/influence.rs" required-features = ["influence"] [[test]] name = "bearer_receipts" path = "tests/bearer_receipts.rs" required-features = ["bearer_receipts"] [[test]] name = "exploration" path = "tests/exploration.rs" required-features = ["exploration"] [[test]] name = "timed_text" path = "tests/timed_text.rs" required-features = ["timed_text"] [[test]] name = "access_services" path = "tests/access_services.rs" required-features = ["access_services"] [[test]] name = "world_replay" path = "tests/world_replay.rs" required-features = ["world"]