open-standards/wai/wai-rs/src/lib.rs

//! WAI — Web AI media transport + execution.
//!
//! What this crate IS:
//!   - the **envelope** (length-prefixed magic + JSON manifest + payload)
//!   - the **capability dispatch** model (capability is named, not shipped)
//!   - thin, tested **wrappers around standard codec libraries** for
//!     the zeroth condition (AVIF / JPEG-XL / PNG / Opus / FLAC / AV1 /
//!     zstd / XZ — all royalty-free), behind the `codecs` feature
//!   - the WAI-native capability classes (integer codecs, worlds, scores,
//!     films, quantum simulation, receipts), each behind its feature
//!   - the **FFI surface** so this Rust crate is the SDK other languages
//!     consume (C ABI via `extern "C"`, cdylib/staticlib outputs)
//!
//! What this crate is NOT:
//!   - a re-implementation of the standard codecs. The zeroth-condition
//!     codecs are wrappers around their reference libraries; the WAI-native
//!     classes are WAI's own, each with its own conformance criterion.
//!
//! Neural capabilities (`wai.neural.*`) are declared here so the
//! dispatch table knows them; the actual neural model runs in whatever
//! ML runtime the sink has installed (PyTorch / Core ML / ONNX / etc.).

pub mod codecs;
pub mod container;
// Parameter-set pins (SPEC §3.1): the listing form, and verifying a pin against
// the sets a sink holds. Pure Rust over bytes, so it is always on.
pub mod pin;
#[cfg(feature = "ffi")]
pub mod ffi;
#[cfg(feature = "codecs")]
pub mod ffi_codecs;

// The integer-exact synthesis decoder lives at the crate root behind the
// light `neural_int` feature: pure i64 arithmetic, no ONNX runtime, so it
// builds (and its cross-hardware bit-exactness is checkable) without `ort`.
// The `neural` module re-exposes it via the `wai.neural.int_synth` capability.
#[cfg(feature = "neural_int")]
pub mod int_synth;

// Fast kernels (convolution, transposed convolution, IGDN, channel attention)
// for the integer decoders, plus the run-time policy that selects them or the
// scalar reference kernels. Output is the same integer for every element either
// way, and an overflow-checked build panics on the same inputs (the message can
// differ); an allocation that fails is outside that claim. Argued and tested, not
// machine-proved: the module docs state the claim precisely. Pure std — no dependency — and single-threaded
// on wasm.
#[cfg(feature = "neural_int")]
pub mod int_kernels;

// Integer Gaussian-conditional entropy — the reusable scale→bucket primitive
// that makes a conditional codec's entropy decode hardware-deterministic (the
// integer half of the integer-entropy contract). Pure i64, no `ort`, like
// int_synth; the integer rANS + int_synth are the arithmetic-coder + synthesis
// halves a full `NeuralIntegerExact` conditional codec also needs.
#[cfg(feature = "neural_int")]
pub mod int_entropy;

// The integer rANS arithmetic coder (CompressAI rans64, precision 16) — a pure
// i64 entropy coder, no `ort`, so it sits with the other `neural_int` primitives
// rather than behind the ONNX `neural` feature that also consumes it. The
// encode+decode round-trip is the arithmetic-coder half of a `NeuralIntegerExact`
// conditional codec (with `int_entropy` for bucketing, `int_hyper_synth` for the
// transforms).
#[cfg(feature = "neural_int")]
pub mod rans;

// Integer-exact transform primitives (softmax/layernorm/matmul) — the missing
// piece for a NeuralIntegerExact *attention-based* decode (the attention and
// MetaFormer transform class learned codecs use). Pure i64, no `ort`, like int_synth/int_entropy.
#[cfg(feature = "neural_int")]
pub mod int_transform;

// Integer-exact synthesis of a pretrained learned image codec (per-channel int12
// convs + integer IGDN) — the decode side of a NeuralIntegerExact conditional
// codec (the pretrained mbt2018_mean, exported to integers; quality measured in
// int_hyper_synth.rs). Pure i64, no `ort`. Runs the model the export tool emits.
#[cfg(feature = "neural_int")]
pub mod int_hyper_synth;

// The MLIC++ entropy topology (channel-autoregressive slices × checkerboard passes,
// an entropy network over the latent decoded so far) with every decode-side network
// integer: `wai.neural.int_mlicpp`. Built from int_hyper_synth's networks,
// int_entropy's bucketing and the integer rANS; refuses any stream value outside the
// exact integer range rather than overflowing. Pure integer, no `ort`.
#[cfg(feature = "neural_int")]
pub mod int_mlicpp;

// Byte-exact integer TRANSFORMER kernels (softmax / attention / LayerNorm /
// L2-norm / ELU / Sigmoid / MDTA) — the pure-i64 arithmetic a learned ATTENTION
// image codec (JPEG-AI's Restormer synthesis) needs beyond the conv/IGDN stack
// above. NOTE: distinct from `int_transform` (a signal transform). Pure i64.
#[cfg(feature = "neural_int")]
pub mod int_transformer;

// Whole-net byte-exact integer JPEG-AI synthesis (Restormer, model_y) — threads the
// real traced topology through int_transformer + int_hyper_synth ops on sink-supplied
// 16-bit-PTQ weights → Y plane. Pure i64. (Structural; PSNR-vs-float pending.)
#[cfg(feature = "neural_int")]
pub mod jpegai_synthesis;

// Byte-exact mANS entropy decoder for JPEG-AI (port of the ISO reference
// decompressor.cpp) — two interleaved ANS states, sgm (y-latent) + fac (z-latent)
// paths. Pure integer ⇒ byte-identical everywhere.
#[cfg(feature = "neural_int")]
pub mod jpegai_mans;

// JPEG-AI decode-pipeline glue (dequant + reconstruction wiring).
#[cfg(feature = "neural_int")]
pub mod jpegai_pipeline;

// JPEG-AI eICCI post-filter: the Haar wavelet domain its CNN operates in.
#[cfg(feature = "neural_int")]
pub mod jpegai_icci;

// JPEG-AI bitstream container (marker segments) + the MSB-first header bit reader —
// the decoder's entry point.
#[cfg(feature = "neural_int")]
pub mod jpegai_bitstream;

// Float functions (exp, rounding) built only from IEEE-754 basic operations, so their
// bits are fixed by the source rather than by a platform math library. The JPEG-AI
// exact decoder's float stages use them.
#[cfg(feature = "neural_int")]
pub mod float_repro;

// JPEG-AI whole-decoder entry point: composes the entropy, value, synthesis and
// post-filter stages into `decode(codestream, weights, norm) -> Rgb`.
#[cfg(feature = "neural_int")]
pub mod jpegai_decode;

// Deterministic integer generative synthesis (`wai.generate.*`) — the
// `intent=create` analog of the integer-exact codecs: a generator whose entire
// pipeline is integer/fixed-point, pinned to (model, prompt, seed, steps), so the
// generated image is byte-identical on every machine (its hash is portable, can
// go in a receipt). Pure i64, no float/ONNX; compiles to wasm32.
#[cfg(feature = "generate")]
pub mod 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 portable hash),
// the temporal extension of the integer contract. Pure i64, no float/ONNX.
#[cfg(feature = "video_int")]
pub mod int_video;

// Integer-exact LEARNED audio codec (`wai.audio.int_codec`) — a learned 1-D
// transform codec whose synthesis is a stack of integer transposed convolutions +
// integer IGDN, decoding to int16 PCM byte-identically on every machine
// (NeuralIntegerExact; *sample-equivalence*, a portable PCM hash). The audio analog
// of int_hyper. Pure i64, no float/ONNX; compiles to wasm32.
#[cfg(feature = "audio_int")]
pub mod int_audio;

// Integer-exact INTERACTIVE WORLD MODEL (`int_world`) — the byte-exact renderer for
// wai.world.model: an action-conditioned next-frame model (transition + synthesis are
// both int_hyper IntModels), so given (model, z0, action trace) every generated frame
// is byte-identical on every machine. Pure i64; compiles to wasm32.
#[cfg(feature = "world_int")]
pub mod int_world;

// Integer-exact LEARNED Gaussian-splat ATTRIBUTE codec (`int_splat`) — "the int_hyper
// of 3D": a learned transform over the [14,S,S] attribute image, integer synthesis →
// byte-exact attribute tensor (splat-equivalence). Pure i64; compiles to wasm32.
#[cfg(feature = "splat_int")]
pub mod int_splat;

// The parsers and writers of the integer payload formats (`WIV1`, `WIH1`, `WIA1`,
// `WIS1`), with no dependency on the rest of the crate and no feature: the container's
// emit paths check a payload with them (`container::check_int_payload_framing`), and
// `int_payload` re-exports them as `int_payload::wire`.
#[doc(hidden)]
#[path = "int_payload/wire.rs"]
pub mod int_wire;

// The payloads of the WAI-native integer codecs (`extensions/integer-payloads.md`):
// the WIV1, WIH1, WIA1 and WIS1 parsers and writers, the JSON converters, and
// `decode_int`, the one integer decode path, with the pin and key-log checks over
// parameter sets held in memory. No ONNX runtime and no filesystem: the neural sink
// delegates the integer capabilities to it, and it builds for wasm32. Its video, audio
// and splat arms sit behind their own features.
#[cfg(feature = "neural_int")]
pub mod int_payload;

#[cfg(feature = "neural")]
pub mod neural;
// The neural C FFI uses the `ffi` feature's shared buffer and error types, so it
// builds with `neural` and `ffi`; it needs no codec library. The Rust neural
// decoders (above) need neither the C ABI nor the codec chain.
#[cfg(all(feature = "neural", feature = "ffi"))]
pub mod ffi_neural;

// Shared deterministic ONNX session loader, used by both ort-backed paths.
#[cfg(any(feature = "neural", feature = "semantic"))]
pub(crate) mod ort_session;

// The perceptual / generative-semantic path: transmit a compact
// "understanding" (CLIP embedding + thumb + edges), regenerate at the sink
// with any conforming generator, conform by CLIP similarity (not byte
// identity). The Rust port of the moved-out `wai-neural` prototype — the
// generator and embedder are sink-supplied traits, never bundled.
#[cfg(feature = "semantic")]
pub mod semantic;

// Interactive worlds (extensions/interactive-worlds): media that consumes
// input. A world is a deterministic content-addressed artifact; every event
// is a signed CausalOp; conformance is replay-equivalence — identical
// state hash at every checkpoint, no tolerance parameter. Pure Rust,
// closed-form fixed-point; no ML dep chain.
#[cfg(feature = "world")]
pub mod world;

// Object-based spatial audio (extensions/spatial-audio): the deterministic
// Fx mixdown engine. Conformance is mixdown-equivalence — same scene +
// declared layout → identical canonical PCM. Reuses the world `Fx` floor.
#[cfg(feature = "audio_scene")]
pub mod audio_scene;

// Haptics (extensions/haptics): touch as instructions — a keyframed
// intensity/sharpness envelope reconstructed in the Fx floor.
#[cfg(feature = "haptic")]
pub mod haptic;

// Volumetric / 4D temporal Gaussian splats (extensions/volumetric): each
// Gaussian carries keyframed tracks; the sink interpolates the cloud at
// frame N in the Fx floor (frame-state-equivalence). Reuses the world Fx
// floor + blake3; the EWA render stays the sink's.
#[cfg(feature = "splat4d")]
pub mod splat4d;

// Music as instructions (extensions/score): a score of note events
// reconstructed to a canonical PCM mixdown by a deterministic trig-free
// synth in the Fx floor (mixdown-equivalence). The soundfont/neural
// instrument render stays the sink's. Reuses the world Fx floor + blake3.
#[cfg(feature = "score")]
pub mod score;

// Asset provenance (extensions/provenance): the "verify whatever it
// carries" half — a signed, energy-accounted lineage for opaque captured
// content WAI does not reconstruct. Reuses the JWP Merkle + Ed25519.
#[cfg(feature = "provenance")]
pub mod provenance;

// Reproducible-reconstruction binding: a C2PA/JPEG-Trust hard binding over the
// deterministically decoded pixels (the reconstruct-side analogue of `provenance`).
#[cfg(feature = "provenance")]
pub mod reconstruction_binding;

// The acquisition class an energy figure is sealed beside — one definition
// shared by every receipt here that carries `joules_micro`: always present in the
// C2PA energy binding, the int_motion receipt and the OTT receipts; an optional
// label (absent = legacy, unlabelled) in the families that predate it. Splits hardware evidence into an on-chip counter class and a calibrated
// external-instrument class, each with a required declared uncertainty, and keeps
// the legacy `HwShunt` label verifiable. Pure std with no optional
// dependencies, so it is compiled unconditionally.
pub mod energy_class;

// The integers a measurement report carries for a figure obtained under the
// bracketed protocol, the exact arithmetic every reader applies to them (the figure
// they give, the least declaration they support, the derived attribution verdict),
// the liveness rule a power reader's rail must meet, and the build record
// (energy-measurement §3.1, §6.2). Integer only, pure std, compiled unconditionally.
pub mod energy_report;

// What build.rs records about the build, shared with build.rs through `#[path]`;
// compiled into the crate for its tests.
#[cfg(test)]
mod build_info;

// The bracketed marginal protocol (energy-measurement §3) every reference meter
// runs: idle bracket, a burst released from a start barrier, busy bracket, and
// the §4 / §2.3 rules for when a figure may be sealed under a hardware class.
// Native only — it spawns threads and runs the power reader as a subprocess.
#[cfg(not(target_arch = "wasm32"))]
pub mod energy_burst;

// Signed-byte pins for the receipt families that seal `joules_micro`: an
// unlabelled receipt must keep the exact bytes it had before the optional
// acquisition class existed. Test-only.
#[cfg(all(test, feature = "world"))]
mod receipt_pins;

// The joules a reconstruction cost, bound to that reconstruction. Fills the slot
// C2PA 2.4's `c2pa.environmental-sustainability` opened but left self-declared:
// same digest as the reconstruction binding, plus the acquisition class and
// coverage the standard assertion cannot express (extensions/energy-binding.md).
#[cfg(feature = "provenance")]
pub mod energy_binding;

/// Writes a real, signed C2PA manifest carrying those bindings.
///
/// [`energy_binding`] and [`reconstruction_binding`] define assertion *shapes*; this
/// emits them into an actual manifest, and enforces the one rule the C2PA SDK cannot —
/// that the two digests in a manifest must name the same decode.
#[cfg(feature = "c2pa_emit")]
pub mod c2pa_emit;

// jwp-receipts §2.1: an object's content hash, BLAKE3 over a domain and the envelope.
// One module, gated only on BLAKE3, so every receipt family computes it in one place.
#[cfg(feature = "jwp_hash")]
pub mod jwp_hash;

// SPEC §7.1: a WAI2 component exploded into its WAI1 envelope, WAI1 envelopes packed
// into a WAI2, and the check of an entry's envelope_manifest. Content hashes need BLAKE3.
#[cfg(feature = "jwp_hash")]
mod container_explode;

// Staged delivery (extensions/staged-delivery.md): a base first, then refinements as
// their own objects, bound to what they refine by content hash; the residual payload
// WIR1, its predictors, the per-unit application algorithm and the live schedule.
#[cfg(feature = "staged")]
pub mod staged;

// Typed receipt classes (extensions/jwp-receipts.md §2.4.3–§2.4.7, §2.6, §3.1–§3.2):
// energy, lawful-basis, log-inclusion, soft-binding and binding-recovery statements
// about delivered objects, on one `claim` envelope and one signature rule beside the
// delivery class `group`/`object` carry. A recovery through a soft binding attests the
// ancestor, never the object in hand. An OER receipt an energy claim names is read and
// verified by `oer` under oer-receipts' own rules.
#[cfg(feature = "receipt_claims")]
pub mod claim_receipt;

// §3.1 step 1's reading of a claim's JSON text: RFC 8259 with a claim's own limits
// (no repeated member name, no unpaired surrogate escape, 32 levels), each number read
// from its spelling. Claims, and §7's key logs, grants and statuses, which jwp-receipts
// reads the same way; an OER receipt is read by `oer::load`.
#[cfg(feature = "receipt_claims")]
mod claim_text;

// JWP delivery receipts (extensions/jwp-receipts.md §2.2–§2.4.2, §3, §3.3): group and
// object receipts read and verified, in the legacy forms and the labelled ones — an
// object's figure, class and origin in its Merkle leaf, a group total's class under a
// versioned signing payload — with the position check, the group-total reading and the
// WAI_RECEIPT property's readings (moq-streaming-format §5).
#[cfg(feature = "receipt_claims")]
pub mod jwp_delivery;

// Figure profiles (energy-measurement §6.1): how a measurement or operating-point claim
// names the receipt that seals its figure, by that receipt's identity domain, and the
// figures each receipt family shows a report — read without changing any family.
#[cfg(feature = "receipt_claims")]
pub mod energy_figure;

// jwp-receipts §7.1: what a `signer_id` names — an origin-bound `did:web`, an Ed25519
// `did:key`, or a label. Ungated and dependency-free, so every surface that shows a
// signer can say which.
pub mod signer_id;

// jwp-receipts §7: key discovery and signing authority — origin key logs, anchors, the
// confirmation reported beside a verdict and never in it, and the authorisation and
// revocation of decoder and reconstruct modules (§7.9). No network, no clock.
#[cfg(feature = "key_discovery")]
pub mod key_log;

// wai.world.model — generative-world transport: a signed, replay-equivalent action
// trace (the world CausalOp log) + per-frame provenance. The wire carries the
// action trace + a declared model_id, not the pixels; the sink renders. The neural
// sibling of wai.world.replay.
#[cfg(feature = "world_model")]
pub mod world_model;

// Linear film (extensions/linear-film): "a film is a sealed, camera-on-rails
// world." The world replay (replay-equivalence) + a keyframed camera track in
// the Fx floor + a frame schedule; verified frame-by-frame (film-equivalence).
// Reuses the world engine + JWP Merkle + Ed25519; the render stays the sink's.
#[cfg(feature = "film")]
pub mod film;

// Deterministic quantum-circuit SIMULATION as transportable content
// (extensions/quantum-sim, `wai.quantum.circuit`): the wire carries a compact
// gate op-log (WQC container), the sink classically simulates it in a fixed-point
// complex floor (Amp = i64 re/im at 2^FRAC), and the reconstructed statevector is
// byte-identical on every machine (statevector-equivalence). Clifford+T + dyadic
// phase, so the controlled-phase ladder of the QFT ("quantum FFT") reconstructs
// byte-exact. Pure i64, no float/ONNX; compiles to wasm32. Quantum HARDWARE is
// deliberately absent — NISQ noise breaks the determinism the standard rests on.
#[cfg(feature = "quantum")]
pub use wai_quantum::quantum;
#[cfg(feature = "quantum")]
pub mod quantum_envelope;

// The energy-accounted seal for a quantum reconstruction (extensions/quantum-sim
// § Receipt): a signed receipt separating the portable-exact WORK (n_ops·2^n
// amplitude updates, recomputable by anyone) from the measured-attested ENERGY
// (joules_micro from the sink's meter, and the class that labels it), both bound to a
// re-simulatable statevector
// hash. A JWP profile — reuses the world Merkle + Ed25519.
#[cfg(feature = "quantum_receipt")]
pub use wai_quantum::quantum_receipt;

// The acquisition class of a quantum receipt's joule figure, as an optional
// signed label (`Labelled`, `LabelledQbom`). Present with any quantum feature
// that seals receipts; unlabelled receipts keep their exact bytes.
#[cfg(any(feature = "quantum_receipt", feature = "quantum_ops", feature = "quantum_phasor_meter"))]
pub use wai_quantum::quantum_energy;

#[cfg(feature = "video_receipt")]
pub mod video_receipt;

// Balanced-ternary matrix-product-state transform (extensions/ternary-tt,
// `wai.ternary.tt`): quantum-INSPIRED (tensor-network) compression. The ternary
// weight fabric (BitNet-b1.58, 5 trits/byte) + MPS are ported, not reinvented;
// the one change is an INTEGER core scale, so the whole decode is pure i64/i128
// and a reconstruction is byte-identical on every machine (portable recon hash).
// Lossy codec, deterministic decode; encoder-side float SVD only.
#[cfg(feature = "ternary")]
pub mod ternary;

// 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 and the class that labels it), bound to the
// WQTT payload hash and a
// re-decodable reconstruction hash. A JWP profile — reuses the world Merkle + Ed25519.
#[cfg(feature = "ternary_receipt")]
pub mod ternary_receipt;

// Quantum-operations attestation (extensions/quantum-ops): signed, content-
// addressed, joule-metered, grant-authorized receipts of calibration runs
// (`wai.quantum.calibration`) and QPU jobs (`wai.quantum.job`) — the verify-half
// of WAI applied to the quantum-control industry. A job binds the exact
// calibration state it ran under; verify() enforces the grant's joule ceiling.
// WAI owns the receipt, not the hardware. Reuses the world Merkle + Ed25519.
#[cfg(feature = "quantum_ops")]
pub use wai_quantum::quantum_ops;

// Attested per-session manifest (wai.video.manifest): the incumbent OTT 1:1
// manifest, made deterministic (a pure function of the session *class*, so it
// dedups across viewers), energy-accounted, and sealed in a signed receipt that
// binds the JCP grant, the stitched ads and the blackouts applied. Reuses the
// world Merkle + Ed25519 and the GrantRef from quantum_ops — no pixel decode.
#[cfg(feature = "video_manifest")]
pub mod wai_video_manifest;

// Where a receipt's joules_micro actually comes from. Makes the provenance
// ladder mechanical: only a counter meter can yield a hardware class (on-chip,
// or a calibrated instrument when constructed with a certificate reference),
// each with its declared uncertainty; a model meter can only ever say
// ModelBased; and a meter with no hardware returns None rather than a
// fabricated figure.
#[cfg(feature = "energy_meter")]
pub mod energy_meter;

// Attested server-side ad insertion (wai.video.ssai): a deterministic ad
// decision + per-impression signed receipt. Budget enforcement is a checkable
// fact — verify() recomputes the billable spend and rejects it over the grant's
// funds_ceiling. Links to a manifest by manifest_hash; reuses the manifest
// module's EnergyProvenance and the world Merkle + Ed25519.
// Pure decision policy for the video capabilities — no crypto, no I/O, so a
// model checker can reach it. Holds `decide` and the spend accounting, whose
// limits are proved rather than sampled; the signing layer lives in
// wai_video_ssai and re-exports these types so the public surface is unchanged.
#[cfg(feature = "video_policy")]
pub mod wai_video_policy;

#[cfg(feature = "video_ssai")]
pub mod wai_video_ssai;

// Attested content-key release (wai.video.keys): every DRM key release — and
// every refusal — is a signed receipt whose decision verify() recomputes from
// the bound (grant, entitlement, times), with a BLAKE3 key-commitment that
// proves which key was released without carrying it. The content-protection
// audit trail as a checkable fact.
#[cfg(feature = "video_keys")]
pub mod wai_video_keys;

// Deterministic packaging + attested SegmentMap (wai.video.package): a source is
// sliced into content-hashed segments; the signed Merkle SegmentMap is what a
// manifest reference is checked against, and identical content (ads, bumpers,
// replays, simulcast overlap) dedups to one stored/encoded copy — a saving
// verify() recomputes rather than takes on trust.
#[cfg(feature = "video_package")]
pub mod wai_video_package;

// Virtual linear / FAST channel assembly (wai.video.channel): the capstone. A
// continuous schedule (gapless, non-overlapping — verify() rejects dead air)
// whose program-as-run per window is recomputed, not logged. Windows chain via
// parent_receipt_hash, so a channel's history is a hash chain: operational
// accountability as a cryptographic artifact rather than an operator's log.
#[cfg(feature = "video_channel")]
pub mod wai_video_channel;

// Deterministic autonomous CALIBRATION engines (extensions/quantum-ops § Calibration):
// a fixed-point qubit-device simulator + autonomous tune-up algorithms (Rabi π-pulse)
// (autonomous gate tune-up), done byte-exactly and reproducibly, sealing a
// wai.quantum.calibration receipt per run. Pure integer.
#[cfg(feature = "quantum_cal")]
pub use 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. Pure fixed-point, byte-exact on every machine,
// each step sealing a signed, joule-metered MitigationReceipt binding
// (raw data, noise-model hash, method, seed) → (mitigated estimate ± error).
#[cfg(feature = "quantum_mitigate")]
pub use 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. Plain BP fails on quantum codes
// (degeneracy + short cycles); relay legs with disordered per-node memory break
// the symmetry. Byte-exact on every machine; each decode seals a signed,
// joule-metered DecodeReceipt carrying joules-per-decode.
#[cfg(feature = "quantum_qec")]
pub use wai_quantum::quantum_qec;

// Deterministic FILTER-FUNCTION control + NOISE SPECTROSCOPY (extensions/quantum-ops
// § Calibration, frequency domain): the coherence-decay overlap χ = (1/π)∫S(ω)F(ω)/ω².
// DD noise spectroscopy reconstructs the hidden PSD from a filter bank (Richardson–
// Lucy); filter-function robust control reshapes a DD sequence to push its stopband
// over the noise. Fully offline, byte-exact, each sealing a wai.quantum.calibration
// receipt — the matched pair that extends the calibration suite to 1/f noise.
#[cfg(feature = "quantum_control")]
pub use 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. Recovers a hidden device's Pauli error rates
// from a simulated twirled-cycle experiment (fixed f_a = exp(-2Σλ), inverted by
// multiplicative NNLS), byte-exact, sealing a signed model whose content hash is
// exactly the noise_model_hash a MitigationReceipt binds — the producer for the
// PEC/PEA hook the mitigation layer already exposes.
#[cfg(feature = "quantum_noise")]
pub use 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. Two Cliffords are
// equal iff they conjugate every Pauli identically; routing preserves semantics up
// to the final qubit permutation. Seals a signed CompileReceipt that a routed
// circuit is equivalent to its source — compilation correctness, unsigned today.
#[cfg(feature = "quantum_compile")]
pub use wai_quantum::quantum_compile;

// OER/2 OUTCOME-AND-ENERGY RECEIPTS (extensions/oer-receipts): a receipt that says
// what a unit of work was, what it cost, how that cost is GRADED (projected /
// simulated / derived / measured — the evidential standing, alongside the
// acquisition class of energy-measurement.md), and what it rests on; canonicalised,
// content-addressed, hash-chained and Ed25519-signed. This is the third verifier of
// the draft, beside the reference Python and the portable C kernel; conformance is
// the SAME REASON SET for every vector in oer-conformance/, not a pass/fail bit.
#[cfg(feature = "oer")]
pub mod oer;

// 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 — half a Bell
// pair has no state vector at all — so this is what makes "what did the other end
// receive" an answerable question.
#[cfg(feature = "quantum_info")]
pub use 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` — at
// d = 2 it reproduces the qubit simulator exactly, which is how it is checked.
#[cfg(feature = "quantum_qudit")]
pub use wai_quantum::quantum_qudit;

// KEY DISTRIBUTION AND SECURITY (extensions/quantum-sim § Communication): BB84
// with an intercept-resend eavesdropper — a quiet channel yields a perfect key,
// interception costs a quarter of it — and the no-cloning theorem priced.
#[cfg(feature = "quantum_comm")]
pub use wai_quantum::quantum_comm;

// THE LIMITS ON ENCODING AND TRANSPORT (extensions/quantum-sim § Source): von
// Neumann entropy, the Schumacher limit, and the Holevo bound. Holevo says `n`
// qubits carry at most `n` classical bits, so quantum does NOT compress classical
// media; where it genuinely wins is protocols, not codecs. Computing the limits is
// what lets WAI state what is possible instead of overclaiming.
#[cfg(feature = "quantum_source")]
pub use wai_quantum::quantum_source;

// TRANSPORT ITSELF (extensions/quantum-sim § Channel): Kraus channels — bit flip,
// dephasing, depolarizing, amplitude damping — and linear-inversion tomography to
// see what actually arrived. The law that matters: push an ensemble through a
// channel and its Holevo bound can only fall. Noise never creates information, and
// nothing downstream recovers what the channel discarded.
#[cfg(feature = "quantum_channel")]
pub use wai_quantum::quantum_channel;

// Deterministic neutral-atom REARRANGEMENT (extensions/quantum-ops § Register
// preparation, `wai.quantum.rearrange`): a Hungarian / LSAP solver over integer
// Manhattan costs that assigns every defect-free target site a distinct loaded
// atom minimizing total move distance, turning a stochastic ~half-full load into a
// defect-free register. Seals a signed RearrangeReceipt whose success verdict
// (every target covered by a valid bijection of present atoms) is re-checkable.
#[cfg(feature = "quantum_atom")]
pub use wai_quantum::quantum_atom;

// WAI Quantum Toolchain (`wai.quantum.toolchain`) — the compute core of a
// classical-hardware quantum IDE: algorithm library + state analysis + backend
// selection (Clifford → statevector → tensor-network) + OpenQASM interop, over the
// byte-exact fixed-point simulator. Framework-neutral and offline.
#[cfg(feature = "quantum_toolchain")]
pub use wai_quantum::quantum_toolchain;

// Matrix Product State backend (`wai.quantum.mps`) — the tensor-network classical
// referee: a bounded-bond MPS evolved with a deterministic complex Jacobi SVD
// truncation, bit-reproducible on every machine, reporting max bond + retained
// weight (an approximate method's honest contract), verified against the dense sim.
#[cfg(feature = "quantum_mps")]
pub use wai_quantum::quantum_mps;

// Stabilizer / CHP backend (`wai.quantum.stabilizer`) — the O(n²) Clifford tier:
// the Aaronson–Gottesman tableau simulates and samples Clifford circuits far past
// the dense 2^n wall (thousands of qubits), exact integer arithmetic, deterministic
// histograms. Rejects non-Clifford gates so the caller falls back to a universal
// backend.
#[cfg(feature = "quantum_stabilizer")]
pub use wai_quantum::quantum_stabilizer;

// Sparse-Pauli / Heisenberg propagation (`wai.quantum.pauli`) — the observable
// referee: propagate an observable backward through the circuit as a truncated sum
// of Pauli strings (Clifford → 1 term, diagonal rotation → 2), computing ⟨O⟩ on
// large low-magic circuits where no 2^n state vector exists. Verified vs dense.
#[cfg(feature = "quantum_pauli")]
pub use wai_quantum::quantum_pauli;

#[cfg(feature = "quantum_spd")]
pub use wai_quantum::quantum_spd;

#[cfg(feature = "quantum_spd_receipt")]
pub use wai_quantum::quantum_spd_receipt;

#[cfg(feature = "quantum_bptn")]
pub use wai_quantum::quantum_bptn;

#[cfg(feature = "quantum_resource")]
pub use wai_quantum::quantum_resource;

#[cfg(feature = "quantum_resource_receipt")]
pub use wai_quantum::quantum_resource_receipt;

#[cfg(feature = "quantum_frame")]
pub use wai_quantum::quantum_frame;

#[cfg(feature = "quantum_frame")]
pub use wai_quantum::quantum_match;

#[cfg(feature = "quantum_tn")]
pub use wai_quantum::quantum_tn;

#[cfg(feature = "quantum_gbs")]
pub use wai_quantum::quantum_gbs;

#[cfg(feature = "quantum_sv")]
pub use wai_quantum::quantum_sv;

#[cfg(feature = "quantum_arch")]
pub use wai_quantum::quantum_arch;

#[cfg(feature = "quantum_ldpc")]
pub use wai_quantum::quantum_ldpc;

#[cfg(any(feature = "quantum_tn", feature = "quantum_sv"))]
pub use wai_quantum::gates;
#[cfg(feature = "quantum_qir")]
pub use wai_quantum::quantum_qir;

// Variational quantum machine learning (`wai.quantum.vml`) — the interference-based
// ML the thermodynamic pivot left behind: a Quantum Circuit Born Machine trained by
// exact parameter-shift gradient on the classical state vector, plus a
// barren-plateau probe (the honest limit). Deterministic f64.
#[cfg(feature = "quantum_vml")]
pub use wai_quantum::quantum_vml;

// The phasor bridge (`wai.quantum.phasor`) — a quantum feature-map model is exactly
// a Fourier series of phasors; compute it on the state vector, extract the spectrum,
// and reproduce the identical function as a classical phasor sum (FHRR/HDC) + a
// qFHRR quantized-phase variant. Same interference, two substrates.
#[cfg(feature = "quantum_phasor")]
pub use wai_quantum::quantum_phasor;

// The full Born machine on the qFHRR substrate (`wai.quantum.qfhrr`) — run the whole
// generative distribution with amplitude phases at qFHRR (b-bit) resolution: a
// trained Born machine deployed end-to-end on the phasor substrate, converging to
// the exact state vector as phase bits grow.
#[cfg(feature = "quantum_qfhrr")]
pub use wai_quantum::quantum_qfhrr;

// Phasor-feature classifier (`wai.quantum.kernel`) — the quantum kernel as random
// Fourier / FHRR phasor features + a ridge classifier: separates nonlinearly-
// separable data a linear model cannot, at qFHRR resolution, with counted phasor
// ops for joule pricing.
#[cfg(feature = "quantum_kernel")]
pub use wai_quantum::quantum_kernel;

// Phasor energy meter (extensions/quantum-sim § Receipt, `wai.quantum.phasor`): the
// energy-accounted seal for an interference computation — portable-exact phasor
// work (linear, recomputable) split from measured-attested joules and their class, so
// qFHRR is an
// accountable substrate, not merely a fast one. Reuses the JWP Merkle + Ed25519.
#[cfg(feature = "quantum_phasor_meter")]
pub use 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 without quantum memory vs O(1/ε²) n-independent copies with a two-copy Bell
// measurement (Chen–Cotler–Huang–Li). The advantage that survives dequantization and
// makes `noise_learn`'s Bell/CB sampling data-efficient. Pure f64, deterministic.
#[cfg(feature = "quantum_qdata")]
pub use wai_quantum::quantum_qdata;

// Quantum Bill of Materials (extensions/quantum-ops § Provenance,
// `wai.quantum.qbom`): assemble the stage receipts of one quantum computation into
// a single signed, content-addressed provenance manifest — the audit sidecar the
// operations layer doesn't sign. Exposes a provenance root + total energy, and
// binds each listed stage to a receipt that itself verifies (a swapped or forged
// stage breaks the bill). The synthesis of the quantum-ops receipt family.
#[cfg(feature = "quantum_qbom")]
pub use wai_quantum::quantum_qbom;

pub use codecs::{
    sink_capabilities,
    CAP_AUDIO_FLAC, CAP_AUDIO_OPUS,
    CAP_IMAGE_AVIF, CAP_IMAGE_JPEG, CAP_IMAGE_JXL, CAP_IMAGE_PNG,
    CAP_NEURAL_BMSHJ2018, CAP_NEURAL_DAC, CAP_NEURAL_DCVC_RT, CAP_NEURAL_ENCODEC32,
    CAP_NEURAL_GLC, CAP_NEURAL_MIMI, CAP_NEURAL_VIDEO_BMSHJ2018, CAP_NEURAL_WAVTOKENIZER,
    CAP_TEXT_XZ, CAP_TEXT_ZSTD,
    CAP_VIDEO_AV1, CAP_VIDEO_AV1_LOSSLESS,
};
pub use container::{Conditioning, Manifest, ModelRequirement, Wai};

#[cfg(all(test, feature = "codecs"))]
mod integration_tests {
    use super::*;

    #[test]
    fn end_to_end_image_jxl_lossless() {
        // build an image, encode as JXL lossless, wrap in a WAI envelope,
        // round-trip the envelope, decode, byte-compare.
        let h = 64u32;
        let w = 64u32;
        let mut rgb = vec![0u8; (h * w * 3) as usize];
        for i in 0..h as usize {
            for j in 0..w as usize {
                let p = (i * w as usize + j) * 3;
                rgb[p] = (i * 4) as u8;
                rgb[p + 1] = (j * 4) as u8;
                rgb[p + 2] = ((i + j) * 2) as u8;
            }
        }
        let payload = codecs::image::jxl_encode(&rgb, h, w, None).unwrap();
        let manifest = Manifest::new(
            "image",
            "replicate",
            ModelRequirement::new(CAP_IMAGE_JXL).with_fallback(CAP_IMAGE_PNG),
            Conditioning::new("jxl"),
        )
        .with_target(serde_json::json!({"h": h, "w": w}));
        let wai = Wai::new(manifest, payload);
        let bytes = wai.to_bytes().unwrap();
        let recovered = Wai::from_bytes(&bytes).unwrap();
        assert_eq!(recovered.capability(), CAP_IMAGE_JXL);
        let (rec_rgb, rh, rw) = codecs::image::jxl_decode(&recovered.payload).unwrap();
        assert_eq!((rh, rw), (h, w));
        assert_eq!(rec_rgb, rgb, "JXL lossless via WAI envelope must round-trip exactly");
    }
}