a220d16a48
`wai generate` makes a wai.generate.spectral picture with the reference generator at any size and prints its SHA-256; with --instr it makes a listed size of an instruction object of form v0, which it reads as a sink does, and --write-instr writes one. `wai score build` writes a WSCR from integer note fields only; `wai score render` prints samples, pcm_sha256, mixdown_blake3 and score_hash, and --pcm writes the samples. Vectors: tests/vectors/generate/sizes.json (256x128, 640x320) and instr-v0.json (the object, its four listed sizes and 28 objects a sink refuses); score-conformance gains pcm_sha256 for every vector and notes/<name>.json, the authoring form, which `wai score build` turns back into the committed WSCR byte for byte. Every pin was made natively and equals the shared browser binding's output. `wai wrap` refuses a wai.generate.spectral payload that is not a form-v0 object, in every build. No library source changes. Co-Authored-By: Claude Opus 5.5 <[email protected]>
277 lines
15 KiB
Rust
277 lines
15 KiB
Rust
//! `wai wrap` writes an envelope that pins no prior, so SPEC §7 limits the intent
|
|
//! it may claim: `replicate` only over the standard classes, where a sink accepts
|
|
//! it unpinned. It used to write `intent = replicate` over every capability,
|
|
//! `wai.image.jpegai` included. These tests run the binary itself; the rule it
|
|
//! applies is `codecs::unpinned_envelope_intent`, which the library tests check
|
|
//! for every registered capability.
|
|
//!
|
|
//! `wrap` needs no codec feature, so these run in the no-system-dependency CI
|
|
//! matrix (`--test cli_wrap_intent`).
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::{Command, Output};
|
|
|
|
use wai::container::{Wai, WaiMulti};
|
|
|
|
/// The committed JPEG AI reference codestream; `wrap` treats any payload as opaque.
|
|
fn payload() -> PathBuf {
|
|
Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/vectors/jpegai/test256.bin")
|
|
}
|
|
|
|
fn scratch(name: &str) -> PathBuf {
|
|
let dir = Path::new(env!("CARGO_TARGET_TMPDIR")).join("cli_wrap_intent");
|
|
std::fs::create_dir_all(&dir).unwrap();
|
|
let p = dir.join(name);
|
|
let _ = std::fs::remove_file(&p);
|
|
p
|
|
}
|
|
|
|
fn wrap(cap: &str, out: &Path, extra: &[&str]) -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_wai"))
|
|
.arg("wrap").arg(cap).arg(payload()).arg("-o").arg(out).args(extra)
|
|
.output()
|
|
.expect("run wai")
|
|
}
|
|
|
|
#[test]
|
|
fn wrap_refuses_replicate_over_jpegai_and_writes_nothing() {
|
|
for extra in [&[][..], &["--intent", "replicate"][..]] {
|
|
let out = scratch("jpegai.wai");
|
|
let run = wrap("wai.image.jpegai", &out, extra);
|
|
let stderr = String::from_utf8_lossy(&run.stderr);
|
|
assert!(!run.status.success(), "{extra:?}: wrap must refuse; stderr: {stderr}");
|
|
assert!(stderr.contains("not writing intent=replicate over wai.image.jpegai"), "{stderr}");
|
|
assert!(stderr.contains("entropy-consistency"), "the refusal names the tier: {stderr}");
|
|
assert!(stderr.contains("--intent"), "the refusal says how to proceed: {stderr}");
|
|
assert!(!out.exists(), "{extra:?}: a refused wrap must not write an envelope");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn wrap_writes_another_intent_over_jpegai_when_asked() {
|
|
let out = scratch("jpegai-improve.wai");
|
|
let run = wrap("wai.image.jpegai", &out, &["--intent", "improve"]);
|
|
assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
|
|
let env = Wai::read(&out).unwrap();
|
|
assert_eq!(env.intent(), "improve");
|
|
assert_eq!(env.replicate_refusal(), None);
|
|
assert_eq!(env.payload, std::fs::read(payload()).unwrap(), "the payload is carried byte-identically");
|
|
}
|
|
|
|
#[test]
|
|
fn wrap_refuses_replicate_when_the_fallback_is_jpegai() {
|
|
// The primary backs an unpinned replicate, but a sink without it decodes
|
|
// through the fallback (SPEC §4 step 5), where replicate is refused.
|
|
for extra in [&["--fallback", "wai.image.jpegai"][..],
|
|
&["--fallback", "wai.image.jpegai", "--intent", "replicate"][..]] {
|
|
let out = scratch("jp2-fb-jpegai.wai");
|
|
let run = wrap("wai.image.jp2", &out, extra);
|
|
let stderr = String::from_utf8_lossy(&run.stderr);
|
|
assert!(!run.status.success(), "{extra:?}: wrap must refuse; stderr: {stderr}");
|
|
assert!(stderr.contains("with fallback wai.image.jpegai"), "{stderr}");
|
|
assert!(stderr.contains("entropy-consistency"), "the refusal names the tier: {stderr}");
|
|
assert!(!out.exists(), "{extra:?}: a refused wrap must not write an envelope");
|
|
}
|
|
// Another intent is carried, fallback and all.
|
|
let out = scratch("jp2-fb-jpegai-improve.wai");
|
|
let run = wrap("wai.image.jp2", &out, &["--fallback", "wai.image.jpegai", "--intent", "improve"]);
|
|
assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
|
|
let env = Wai::read(&out).unwrap();
|
|
assert_eq!(env.intent(), "improve");
|
|
assert_eq!(env.fallback(), Some("wai.image.jpegai"));
|
|
}
|
|
|
|
#[test]
|
|
fn wrap_still_writes_replicate_with_a_standard_fallback() {
|
|
let out = scratch("jp2-fb-png.wai");
|
|
let run = wrap("wai.image.jp2", &out, &["--fallback", "wai.image.png"]);
|
|
assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
|
|
let env = Wai::read(&out).unwrap();
|
|
assert_eq!(env.intent(), "replicate");
|
|
assert_eq!(env.fallback(), Some("wai.image.png"));
|
|
}
|
|
|
|
#[test]
|
|
fn wrap_refuses_an_unpinned_replicate_over_an_integer_exact_neural_codec() {
|
|
// Integer-exact, but `replicate` over it needs a pinned integer-exact prior,
|
|
// which `wrap` does not write.
|
|
let out = scratch("int_hyper.wai");
|
|
let run = wrap("wai.neural.int_hyper", &out, &[]);
|
|
assert!(!run.status.success());
|
|
assert!(String::from_utf8_lossy(&run.stderr).contains("no pinned prior"));
|
|
assert!(!out.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn wrap_still_writes_replicate_over_a_standard_codec() {
|
|
// `wai.image.jp2` is StandardTolerance: replicate is honoured, promising the
|
|
// standard's decoder conformance, and needs no prior.
|
|
let out = scratch("jp2.wai");
|
|
let run = wrap("wai.image.jp2", &out, &[]);
|
|
assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
|
|
let env = Wai::read(&out).unwrap();
|
|
assert_eq!(env.intent(), "replicate");
|
|
assert_eq!(env.replicate_refusal(), None, "a sink accepts what wrap wrote");
|
|
assert_eq!(env.payload, std::fs::read(payload()).unwrap());
|
|
}
|
|
|
|
#[test]
|
|
fn wrap_holds_a_companion_envelope_to_the_same_intent_rule() {
|
|
// With `--companion` the output is a WAI2 envelope; its intent is checked over
|
|
// the base payload's capability as the WAI1 form's is (and over each
|
|
// companion's). HDR dynamic metadata may bind to a neural video payload
|
|
// (SPEC §7.1), whose class is NeuralFloat.
|
|
let meta = payload();
|
|
let meta = meta.to_str().unwrap();
|
|
let hdr = ["--companion", "wai.meta.hdr10plus", meta];
|
|
for extra in [hdr.to_vec(), [&["--intent", "replicate"][..], &hdr[..]].concat()] {
|
|
let out = scratch("dcvc-hdr.wai");
|
|
let run = wrap("wai.neural.dcvc_rt", &out, &extra);
|
|
let stderr = String::from_utf8_lossy(&run.stderr);
|
|
assert!(!run.status.success(), "{extra:?}: wrap must refuse; stderr: {stderr}");
|
|
assert!(stderr.contains("not writing intent=replicate over wai.neural.dcvc_rt"), "{stderr}");
|
|
assert!(!out.exists(), "{extra:?}: a refused wrap must not write an envelope");
|
|
}
|
|
// Another intent is carried, companion and all.
|
|
let out = scratch("dcvc-hdr-improve.wai");
|
|
let run = wrap("wai.neural.dcvc_rt", &out, &[&["--intent", "improve"][..], &hdr[..]].concat());
|
|
assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
|
|
let env = WaiMulti::read(&out).unwrap();
|
|
assert_eq!(env.intent(), "improve");
|
|
assert_eq!(env.check_component_roles(), Ok(()));
|
|
// A standard base still gets `replicate`.
|
|
let out = scratch("hevc-hdr.wai");
|
|
let run = wrap("wai.video.hevc", &out, &hdr);
|
|
assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
|
|
let env = WaiMulti::read(&out).unwrap();
|
|
assert_eq!(env.intent(), "replicate");
|
|
assert_eq!(env.check_component_roles(), Ok(()));
|
|
// The WAI2 form takes no fallback; that is the refusal, whatever the
|
|
// fallback's class, rather than the WAI1 fallback-intent check.
|
|
let out = scratch("hevc-hdr-fb.wai");
|
|
let run = wrap("wai.video.hevc", &out,
|
|
&[&["--fallback", "wai.image.jpegai"][..], &hdr[..]].concat());
|
|
let stderr = String::from_utf8_lossy(&run.stderr);
|
|
assert!(!run.status.success(), "wrap must refuse; stderr: {stderr}");
|
|
assert!(stderr.contains("--fallback names a WAI1 alternative"), "{stderr}");
|
|
assert!(!out.exists(), "a refused wrap must not write an envelope");
|
|
}
|
|
|
|
/// SPEC §5 pins the payload of each WAI-native integer codec to a binary format
|
|
/// (`extensions/integer-payloads.md`). `wai wrap` parses the payload as a sink does
|
|
/// and writes nothing when it is not its capability's format: a tool's JSON output
|
|
/// (`bad_magic`, converted first, never wrapped), another format, a `WIV1` cut inside
|
|
/// its header (`stream_length`), and a keyframe-0 `WIV1` under `wai.video.int_hyper`
|
|
/// (`keyframe_capability_mismatch`), whose magic and version are right. The binary
|
|
/// payloads wrap; `wai inspect` reports what a parse finds in an envelope another
|
|
/// writer made.
|
|
#[test]
|
|
fn wrap_refuses_a_payload_that_is_not_the_pinned_integer_format() {
|
|
let v = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/vectors");
|
|
let wrap_file = |cap: &str, input: &Path, out: &Path, extra: &[&str]| -> Output {
|
|
Command::new(env!("CARGO_BIN_EXE_wai"))
|
|
.arg("wrap").arg(cap).arg(input).arg("-o").arg(out).args(extra)
|
|
.output()
|
|
.expect("run wai")
|
|
};
|
|
for (cap, json, bin, code) in [
|
|
("wai.video.int_motion", "int_video/int_video_bitstream.json", "int_video/int_video_bitstream.wiv1", "bad_magic"),
|
|
("wai.neural.int_hyper", "int_hyper/tiny_bitstream.json", "int_hyper/tiny_bitstream.wih1", "bad_magic"),
|
|
("wai.audio.int_codec", "int_video/video_nk_bitstream.wiv1", "int_audio/audio_bitstream.wia1", "format_capability_mismatch"),
|
|
("wai.splat.int_codec", "int_splat/splat.json", "int_splat/splat.wis1", "bad_magic"),
|
|
("wai.video.int_hyper", "int_video/int_video_bitstream.wiv1", "int_video/video_nk_bitstream.wiv1", "keyframe_capability_mismatch"),
|
|
] {
|
|
let out = scratch("int-payload.wai");
|
|
let run = wrap_file(cap, &v.join(json), &out, &["--intent", "improve"]);
|
|
let stderr = String::from_utf8_lossy(&run.stderr);
|
|
assert!(!run.status.success(), "{cap} {json}: wrap must refuse; stderr: {stderr}");
|
|
assert!(stderr.contains(code) && stderr.contains("integer-payloads"), "{cap}: {stderr}");
|
|
assert!(!out.exists(), "{cap}: a refused wrap must not write an envelope");
|
|
let run = wrap_file(cap, &v.join(bin), &out, &["--intent", "improve"]);
|
|
assert!(run.status.success(), "{cap} {bin}: {}", String::from_utf8_lossy(&run.stderr));
|
|
assert_eq!(Wai::read(&out).unwrap().payload, std::fs::read(v.join(bin)).unwrap());
|
|
}
|
|
// A WIV1 cut inside its fixed header.
|
|
let cut = scratch("int-payload-cut.wiv1");
|
|
std::fs::write(&cut, &std::fs::read(v.join("int_video/int_video_bitstream.wiv1")).unwrap()[..30]).unwrap();
|
|
let out = scratch("int-payload-cut.wai");
|
|
let run = wrap_file("wai.video.int_motion", &cut, &out, &["--intent", "improve"]);
|
|
assert!(!run.status.success() && String::from_utf8_lossy(&run.stderr).contains("stream_length"), "{}", String::from_utf8_lossy(&run.stderr));
|
|
assert!(!out.exists());
|
|
// The same rule for a WAI2 base.
|
|
let out = scratch("int-payload-hdr.wai");
|
|
let run = wrap_file("wai.video.int_motion", &v.join("int_video/int_video_bitstream.json"), &out,
|
|
&["--companion", "wai.meta.hdr10plus", payload().to_str().unwrap()]);
|
|
assert!(!run.status.success() && String::from_utf8_lossy(&run.stderr).contains("bad_magic"));
|
|
assert!(!out.exists());
|
|
// inspect reports an envelope that carries the JSON form.
|
|
let out = scratch("int-payload-json.wai");
|
|
wai::container::Wai::new(
|
|
wai::container::Manifest::new("video", "improve", wai::container::ModelRequirement::new("wai.video.int_motion"),
|
|
wai::container::Conditioning::new("bytes")),
|
|
std::fs::read(v.join("int_video/int_video_bitstream.json")).unwrap(),
|
|
).write(&out).unwrap();
|
|
let run = Command::new(env!("CARGO_BIN_EXE_wai")).arg("inspect").arg(&out).output().expect("run wai");
|
|
let stdout = String::from_utf8_lossy(&run.stdout);
|
|
assert!(stdout.contains("integer payload:") && stdout.contains("bad_magic"), "{stdout}");
|
|
// ...and one whose keyframe-0 WIV1 sits under wai.video.int_hyper.
|
|
let out = scratch("int-payload-k0.wai");
|
|
wai::container::Wai::new(
|
|
wai::container::Manifest::new("video", "improve", wai::container::ModelRequirement::new("wai.video.int_hyper"),
|
|
wai::container::Conditioning::new("bytes")),
|
|
std::fs::read(v.join("int_video/int_video_bitstream.wiv1")).unwrap(),
|
|
).write(&out).unwrap();
|
|
let run = Command::new(env!("CARGO_BIN_EXE_wai")).arg("inspect").arg(&out).output().expect("run wai");
|
|
let stdout = String::from_utf8_lossy(&run.stdout);
|
|
assert!(stdout.contains("integer payload:") && stdout.contains("keyframe_capability_mismatch"), "{stdout}");
|
|
// ...and an encrypted one, whose ciphertext is checked only after decryption.
|
|
let out = scratch("int-payload-encrypted.wai");
|
|
let mut m = wai::container::Manifest::new("video", "improve", wai::container::ModelRequirement::new("wai.video.int_motion"),
|
|
wai::container::Conditioning::new("bytes"));
|
|
m.security = Some(wai::container::Security::new("aes-256-gcm", 7));
|
|
wai::container::Wai::new(m, vec![0x5a; 64]).write(&out).unwrap();
|
|
let run = Command::new(env!("CARGO_BIN_EXE_wai")).arg("inspect").arg(&out).output().expect("run wai");
|
|
let stdout = String::from_utf8_lossy(&run.stdout);
|
|
assert!(stdout.contains("integer payload: encrypted"), "{stdout}");
|
|
}
|
|
|
|
/// SPEC §5, *Payload of `wai.generate.spectral`*: `wrap` reads the instruction object of
|
|
/// form v0 in every build, the generator's own feature or not. It carries the committed
|
|
/// object under intent `create`, refuses `replicate` over the generator (a generator
|
|
/// has no source to replicate), and refuses the same object in another spacing — as
|
|
/// capability or as fallback — writing nothing.
|
|
#[test]
|
|
fn wrap_carries_only_an_instruction_object_under_the_generator() {
|
|
let v: serde_json::Value = serde_json::from_slice(&std::fs::read(
|
|
Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/vectors/generate/instr-v0.json")).unwrap()).unwrap();
|
|
let object = v["object"].as_str().unwrap();
|
|
let good = scratch("instr-v0.payload");
|
|
std::fs::write(&good, object).unwrap();
|
|
let wrap_file = |cap: &str, payload: &Path, out: &Path, extra: &[&str]| {
|
|
Command::new(env!("CARGO_BIN_EXE_wai")).arg("wrap").arg(cap).arg(payload).arg("-o").arg(out).args(extra)
|
|
.output().expect("run wai")
|
|
};
|
|
let out = scratch("generate-create.wai");
|
|
let run = wrap_file("wai.generate.spectral", &good, &out, &["--intent", "create"]);
|
|
assert!(run.status.success(), "{}", String::from_utf8_lossy(&run.stderr));
|
|
let env = Wai::read(&out).unwrap();
|
|
assert_eq!((env.capability(), env.intent()), ("wai.generate.spectral", "create"));
|
|
assert_eq!(env.payload, object.as_bytes(), "the object is carried byte for byte");
|
|
|
|
let out = scratch("generate-replicate.wai");
|
|
let run = wrap_file("wai.generate.spectral", &good, &out, &["--intent", "replicate"]);
|
|
assert!(!run.status.success() && !out.exists());
|
|
assert!(String::from_utf8_lossy(&run.stderr).contains("GenerativeDeterministic"));
|
|
|
|
let spaced = scratch("instr-v0-spaced.payload");
|
|
std::fs::write(&spaced, object.replace("\"seed\":7", "\"seed\": 7")).unwrap();
|
|
for (cap, extra) in [("wai.generate.spectral", &["--intent", "create"][..]),
|
|
("wai.image.png", &["--fallback", "wai.generate.spectral", "--intent", "create"][..])] {
|
|
let out = scratch("generate-spaced.wai");
|
|
let run = wrap_file(cap, &spaced, &out, extra);
|
|
let stderr = String::from_utf8_lossy(&run.stderr);
|
|
assert!(!run.status.success(), "{cap} {extra:?}: wrap must refuse");
|
|
assert!(stderr.contains("instruction object of form v0") && stderr.contains("canonical"), "{cap} {extra:?}: {stderr}");
|
|
assert!(!out.exists(), "{cap} {extra:?}: a refused wrap must not write an envelope");
|
|
}
|
|
}
|