Skip to content

The design language that makes your AI harness better at design.

JavaScript
69.9 KB
Raw Blame
use super::{manifest, server, store};
use serde_json::{Value, json};
use std::{
    fs,
    path::PathBuf,
    sync::atomic::{AtomicUsize, Ordering},
};
static NEXT: AtomicUsize = AtomicUsize::new(0);

#[test]
fn first_viewport_acceptance_closes_both_review_stages_after_later_edits() {
    let f = Fixture::new();
    let mut kit = f.manifest();
    kit["id"] = json!("kit");
    kit["stage"] = json!("components");
    // A native captured fixture; no browser or model calls in this unit test.
    let mut hero = f.manifest();
    hero["stage"] = json!("hero");
    let dir = store::prepare_captured(&f.store, &f.project, &hero, Some(&mut Native)).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    let receipt = store::submit(&dir, &approve(&state)).unwrap();
    assert_eq!(receipt["visualDecision"], "approved");
    fs::write(f.project.join("shared.css"), "footer{color:blue}").unwrap();
    fs::write(
        f.project.join("control.html"),
        "<button>Updated page</button>",
    )
    .unwrap();
    let result =
        super::lifecycle::inspect(&[dir.clone()], &["components".into(), "hero".into()]).unwrap();
    assert_eq!(result["status"], "accepted");
    assert_eq!(result["scope"], "first-viewport");
    assert_eq!(result["completionFeedback"], Value::Null);
    // Neither a new assembly ID nor a kit request creates a round or edits the receipt.
    hero["id"] = json!("another-assembly");
    assert_eq!(store::prepare(&f.store, &f.project, &hero).unwrap(), dir);
    assert_eq!(store::prepare(&f.store, &f.project, &kit).unwrap(), dir);
    assert_eq!(
        store::read(&dir.join("current.json")).unwrap()["receipt"],
        receipt
    );
    assert_eq!(
        super::verify::approved(&f.store, &f.project, "no-new-manifest.json").unwrap(),
        receipt
    );
}

#[test]
fn new_build_does_not_inherit_terminal_review_and_foreign_corruption_is_ignored() {
    let f=Fixture::new();
    let bad=f.store.join("a".repeat(64));fs::create_dir_all(&bad).unwrap();
    fs::write(bad.join("current.json"),"broken JSON").unwrap();
    let mut hero=f.manifest();hero["stage"]=json!("hero");
    let dir=store::prepare_captured(&f.store,&f.project,&hero,Some(&mut Native)).unwrap();
    let state=store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir,&approve(&state)).unwrap();
    assert!(super::lifecycle::final_session(&f.store,&f.project.canonicalize().unwrap()).unwrap().is_some());
    fs::create_dir_all(f.project.join(".impeccable/build")).unwrap();
    fs::write(f.project.join(".impeccable/build/state.json"),r#"{"startedAt":"new-build","artifact":"index.html"}"#).unwrap();
    assert!(super::lifecycle::final_session(&f.store,&f.project.canonicalize().unwrap()).unwrap().is_none());
    let next=store::prepare(&f.store,&f.project,&hero).unwrap();
    assert_eq!(next,dir);
    let next=store::read(&next.join("current.json")).unwrap();
    assert!(next["receipt"].is_null());
    assert!(next["draft"]["decisions"].as_object().unwrap().is_empty());
    assert_eq!(next["packet"]["round"],2);
}

#[test]
fn needs_work_and_unverified_receipts_never_close_review() {
    let f = Fixture::new();
    let mut hero = f.manifest();
    hero["stage"] = json!("hero");
    let dir = store::prepare(&f.store, &f.project, &hero).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    assert!(!super::lifecycle::closed(
        &store::read(&dir.join("current.json")).unwrap()
    ));
    let mut state = state;
    state["capture"] = json!({"schema":"native-component-previews-v1"});
    state["receipt"] = json!({"captureVerified":true,"visualDecision":"changes-requested",
        "capture":state["capture"],"submission":{"requestId":state["packet"]["id"],"packetRevision":state["packet"]["revision"]}});
    store::write(&dir.join("current.json"), &state).unwrap();
    assert!(!super::lifecycle::closed(&state));
    let result = super::lifecycle::inspect(&[dir], &["hero".into()]).unwrap();
    assert_eq!(result["status"], "pending");
    assert!(result["completionFeedback"]
        .as_str()
        .unwrap()
        .contains("not approved"));
}

#[test]
fn hosted_capture_routes_to_the_review_tool_before_browser_or_store_access() {
    let f = Fixture::new();
    let (mut io, captured) = impeccable_common::Io::captured("", f.project.clone(),
        std::collections::HashMap::from([
            ("HOME".into(), f.root.to_string_lossy().into_owned()),
            ("IMPECCABLE_COMPONENT_REVIEW_TOOL".into(), "component_review".into()),
        ]));
    let args = vec!["capture".into(), "--manifest".into(), "review.json".into()];
    assert_eq!(super::run_with_capturer(&args, &mut io, None), 1);
    let error = String::from_utf8(captured.stderr.borrow().clone()).unwrap();
    assert!(error.contains("Call component_review with manifest_path=\"review.json\""), "{error}");
    assert!(!f.root.join(".impeccable").exists());
}
#[test]
fn hosted_lifecycle_owes_no_components_review_for_a_spec_with_nothing_to_decide() {
    let f = Fixture::new();
    let lifecycle = |project: Option<&std::path::Path>| {
        let (mut io, captured) = impeccable_common::Io::captured("", f.project.clone(),
            std::collections::HashMap::from([("HOME".into(), f.root.to_string_lossy().into_owned())]));
        let mut args: Vec<String> = ["lifecycle", "--hosted", "--require", "components", "--require", "hero"].map(String::from).to_vec();
        if let Some(project) = project { args.extend(["--project".into(), project.to_string_lossy().into_owned()]); }
        assert_eq!(super::run(&args, &mut io), 0);
        let out = captured.stdout.borrow().clone();
        serde_json::from_slice::<Value>(&out).unwrap()
    };
    // No spec yet: the components stage stays owed, with or without the project named.
    assert_eq!(lifecycle(Some(&f.project))["stage"], "components");
    fs::create_dir_all(f.project.join(".impeccable/build")).unwrap();
    // A spec without a regions array is not a measured spec: still owed.
    fs::write(f.project.join(super::plan::SPEC), b"{}").unwrap();
    assert_eq!(lifecycle(Some(&f.project))["stage"], "components");
    fs::write(f.project.join(super::plan::SPEC), br#"{"regions":[{"id":"copy","kind":"text","box":{"x":0,"y":0,"w":1,"h":1}}]}"#).unwrap();
    assert_eq!(lifecycle(None)["stage"], "components");
    // Named, a spec with nothing to decide releases the kit review; the hero review still binds.
    let named = lifecycle(Some(&f.project));
    assert_eq!((named["status"].as_str(), named["stage"].as_str()), (Some("pending"), Some("hero")), "{named}");
    // A spec with a raster region owes the kit review again.
    fs::write(f.project.join(super::plan::SPEC), br#"{"regions":[{"id":"art","kind":"plate","box":{"x":0,"y":0,"w":1,"h":1}}]}"#).unwrap();
    assert_eq!(lifecycle(Some(&f.project))["stage"], "components");
}
struct Fixture {
    root: PathBuf,
    project: PathBuf,
    store: PathBuf,
}
impl Fixture {
    fn new() -> Self {
        let root = std::env::temp_dir().join(format!(
            "impeccable-component-review-{}-{}",
            std::process::id(),
            NEXT.fetch_add(1, Ordering::Relaxed)
        ));
        let project = root.join("project");
        let store = root.join("store");
        fs::create_dir_all(&project).unwrap();
        for (name, body) in [
            ("comp.png", b"comp".as_slice()),
            ("art.png", b"art"),
            ("control.html", b"<button>Go</button>"),
            ("shared.css", b"button{color:red}"),
        ] {
            fs::write(project.join(name), body).unwrap();
        }
        Self {
            root,
            project,
            store,
        }
    }
    fn manifest(&self) -> Value {
        json!({"schemaVersion":1,"id":"hero","title":"Hero review","comp":{"path":"comp.png","width":100,"height":100},"components":[{"id":"art","name":"Art","medium":"Raster","note":"Illustration","box":{"x":0,"y":0,"w":0.5,"h":1},"preview":{"kind":"image","path":"art.png"},"dependencies":[]},{"id":"control","name":"Control","medium":"HTML","note":"Semantic control","box":{"x":0.5,"y":0,"w":0.5,"h":1},"preview":{"kind":"page","path":"control.html"},"dependencies":["shared.css"]}]})
    }
    fn prepare(&self) -> PathBuf {
        store::prepare(&self.store, &self.project, &self.manifest()).unwrap()
    }
}
impl Drop for Fixture {
    fn drop(&mut self) {
        let _ = fs::remove_dir_all(&self.root);
    }
}
fn approve(state: &Value) -> Value {
    let mut decisions = serde_json::Map::new();
    for c in state["packet"]["components"].as_array().unwrap() {
        decisions.insert(
            c["id"].as_str().unwrap().into(),
            json!({"revision":c["revision"],"action":"approve","feedback":"","split":false}),
        );
    }
    json!({"schemaVersion":1,"requestId":state["packet"]["id"],"packetRevision":state["packet"]["revision"],"decisions":decisions,"missing":[],"inventoryConfirmed":true})
}
#[test]
fn immutable_snapshots_and_idempotent_feedback_survive_reload() {
    let f = Fixture::new();
    let dir = f.prepare();
    let state = store::read(&dir.join("current.json")).unwrap();
    let body = approve(&state);
    let receipt = store::submit(&dir, &body).unwrap();
    assert_eq!(store::submit(&dir, &body).unwrap(), receipt);
    assert_eq!(
        store::read(&dir.join("current.json")).unwrap()["receipt"],
        receipt
    );
    assert_eq!(receipt["reviewer"], "local-browser");
    assert_eq!(receipt["captureVerified"], false);
    let mut conflict = body;
    conflict["decisions"]["art"]["feedback"] = json!("different");
    assert!(
        store::submit(&dir, &conflict)
            .unwrap_err()
            .contains("already")
    );
}
#[test]
fn source_change_rejects_pending_approval_and_invalidates_only_affected_components() {
    let f = Fixture::new();
    let dir = f.prepare();
    let first = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&first)).unwrap();
    fs::write(f.project.join("art.png"), b"new art").unwrap();
    let dir = f.prepare();
    let next = store::read(&dir.join("current.json")).unwrap();
    assert_ne!(first["packet"]["revision"], next["packet"]["revision"]);
    assert!(next["draft"]["decisions"]["art"].is_null());
    assert_eq!(next["draft"]["decisions"]["control"]["action"], "approve");
    assert_eq!(next["draft"]["inventoryConfirmed"], false);
    assert!(
        store::submit(&dir, &approve(&first))
            .unwrap_err()
            .contains("stale")
    );
    fs::write(f.project.join("shared.css"), b"changed again").unwrap();
    assert!(
        store::submit(&dir, &approve(&next))
            .unwrap_err()
            .contains("stale")
    );
}
#[test]
fn missing_regions_persist_across_rounds_and_old_receipts_are_preserved() {
    let f = Fixture::new();
    let dir = f.prepare();
    let first = store::read(&dir.join("current.json")).unwrap();
    let mut body = approve(&first);
    body["missing"] = json!([{"id":"missing-1","name":"Brushwork","feedback":"Restore it","box":{"x":0.2,"y":0.2,"w":0.1,"h":0.1}}]);
    body["inventoryConfirmed"] = json!(false);
    let receipt = store::submit(&dir, &body).unwrap();
    fs::write(f.project.join("art.png"), b"repair").unwrap();
    f.prepare();
    let next = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(next["draft"]["missing"], body["missing"]);
    let history = store::read(&dir.join(format!(
        "revisions/{}.json",
        first["packet"]["revision"].as_str().unwrap()
    )))
    .unwrap();
    assert_eq!(history["receipt"], receipt);
}
#[test]
fn refusal_paths_cannot_be_turned_into_approval() {
    let f = Fixture::new();
    let dir = f.prepare();
    let state = store::read(&dir.join("current.json")).unwrap();
    let mut body = approve(&state);
    body["inventoryConfirmed"] = json!(false);
    assert!(store::submit(&dir, &body).is_err());
    body["inventoryConfirmed"] = json!(true);
    body["decisions"]["art"]["action"] = json!("skip");
    assert!(store::submit(&dir, &body).is_err());
    body["decisions"]["art"]["action"] = json!("approve");
    body["decisions"]["art"]["revision"] = json!("invented");
    assert!(store::submit(&dir, &body).is_err());
    assert!(store::read(&dir.join("current.json")).unwrap()["receipt"].is_null());
}
#[test]
fn files_are_confined_and_store_is_outside_project() {
    let f = Fixture::new();
    let mut manifest = f.manifest();
    manifest["components"][0]["preview"]["path"] = json!("../outside.png");
    assert!(manifest::freeze(&f.project, &manifest).is_err());
    assert!(
        store::prepare(
            &f.project.join("forged-approvals"),
            &f.project,
            &f.manifest()
        )
        .is_err()
    );
    #[cfg(unix)]
    {
        std::os::unix::fs::symlink(&f.root, f.project.join("outside")).unwrap();
        manifest["components"][0]["preview"]["path"] = json!("outside/project/art.png");
        let frozen = manifest::freeze(&f.project, &manifest);
        assert!(frozen.is_ok());
        std::os::unix::fs::symlink("/etc/hosts", f.project.join("leak")).unwrap();
        manifest["components"][0]["preview"]["path"] = json!("leak");
        assert!(manifest::freeze(&f.project, &manifest).is_err());
    }
}
#[test]
fn malformed_maps_and_cross_origin_posts_are_rejected() {
    let f = Fixture::new();
    let mut manifest = f.manifest();
    manifest["components"][0]["box"]["w"] = json!(0);
    assert!(manifest::freeze(&f.project, &manifest).is_err());
    assert!(server::authorized(
        "POST",
        Some("127.0.0.1:4321"),
        Some("http://127.0.0.1:4321"),
        Some("same-origin"),
        4321
    ));
    for origin in [None, Some("null"), Some("https://evil.example")] {
        assert!(!server::authorized(
            "POST",
            Some("127.0.0.1:4321"),
            origin,
            Some("same-origin"),
            4321
        ));
    }
    assert!(!server::authorized(
        "GET",
        Some("evil.example"),
        None,
        None,
        4321
    ));
    assert!(super::decode_path("a%20b.png").is_ok());
    assert!(super::decode_path("%00").is_err());
}

#[test]
fn prepare_cli_reports_an_existing_receipt_instead_of_requesting_review_again() {
    let f = Fixture::new();
    fs::write(
        f.project.join("review.json"),
        serde_json::to_vec(&f.manifest()).unwrap(),
    )
    .unwrap();
    let args = vec![
        "prepare".into(),
        "--manifest".into(),
        "review.json".into(),
        "--store".into(),
        f.store.to_string_lossy().into_owned(),
    ];
    let invoke = || {
        let (mut io, captured) =
            impeccable_common::Io::captured("", f.project.clone(), Default::default());
        assert_eq!(super::run(&args, &mut io), 0);
        let result = serde_json::from_slice::<Value>(&captured.stdout.borrow()).unwrap();
        result
    };
    let initial = invoke();
    assert_eq!(initial["status"], "awaiting-review");
    let dir = f.store.join(initial["session"].as_str().unwrap());
    let first = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&first)).unwrap();
    assert_eq!(invoke()["status"], "approved");
}

#[test]
fn repair_history_records_feedback_changes_and_removed_components() {
    let f = Fixture::new();
    let dir = f.prepare();
    let first = store::read(&dir.join("current.json")).unwrap();
    let mut body = approve(&first);
    body["decisions"]["art"]["action"] = json!("revise");
    body["decisions"]["art"]["feedback"] = json!("Preserve the motif");
    store::submit(&dir, &body).unwrap();
    fs::write(f.project.join("art.png"), b"repair").unwrap();
    f.prepare();
    let next = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(next["history"]["packet"]["round"], 1);
    assert_eq!(
        next["history"]["draft"]["decisions"]["art"]["feedback"],
        "Preserve the motif"
    );
    assert_eq!(
        next["history"]["changes"]["art"]["files"],
        json!(["art.png"])
    );
    assert_eq!(next["history"]["changes"]["control"]["kind"], "unchanged");
    let mut manifest = f.manifest();
    manifest["components"].as_array_mut().unwrap().remove(1);
    store::prepare(&f.store, &f.project, &manifest).unwrap();
    let removed = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(removed["history"]["removed"][0]["id"], "control");
    assert_eq!(removed["draft"]["inventoryConfirmed"], false);
}
#[test]
fn reverting_to_old_content_cannot_reuse_an_old_round_or_approval() {
    let f = Fixture::new();
    let dir = f.prepare();
    let first = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&first)).unwrap();
    fs::write(f.project.join("art.png"), b"repair").unwrap();
    f.prepare();
    fs::write(f.project.join("art.png"), b"art").unwrap();
    f.prepare();
    let third = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(third["packet"]["round"], 3);
    assert_ne!(first["packet"]["revision"], third["packet"]["revision"]);
    assert!(store::submit(&dir, &approve(&first)).is_err());
    assert!(third["draft"]["decisions"]["art"].is_null());
    let archive = store::read(&dir.join(format!(
        "revisions/{}.json",
        first["packet"]["revision"].as_str().unwrap()
    )))
    .unwrap();
    assert_eq!(archive["packet"]["round"], 1);
    assert_eq!(archive["receipt"]["visualDecision"], "approved");
}

#[test]
fn preparing_again_before_a_reply_preserves_outstanding_feedback_and_carried_approvals() {
    let f = Fixture::new();
    let dir = f.prepare();
    let first = store::read(&dir.join("current.json")).unwrap();
    let mut body = approve(&first);
    body["decisions"]["art"]["action"] = json!("revise");
    body["decisions"]["art"]["feedback"] = json!("Keep the motif");
    store::submit(&dir, &body).unwrap();
    fs::write(f.project.join("art.png"), b"repair one").unwrap();
    f.prepare();
    fs::write(f.project.join("art.png"), b"repair two").unwrap();
    f.prepare();
    let third = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(
        third["history"]["feedback"]["art"]["decision"]["feedback"],
        "Keep the motif"
    );
    assert_eq!(third["history"]["feedback"]["art"]["round"], 1);
    assert_eq!(third["history"]["changes"]["control"]["carried"], true);
    store::submit(&dir, &approve(&third)).unwrap();
    fs::write(f.project.join("art.png"), b"another version").unwrap();
    f.prepare();
    let fourth = store::read(&dir.join("current.json")).unwrap();
    assert!(fourth["history"]["feedback"]["art"].is_null());
}

#[test]
fn failed_native_capture_does_not_replace_the_current_review() {
    struct Refuse;
    impl super::capture::ComponentCapturer for Refuse {
        fn capture(
            &mut self,
            _: &mut Value,
            _: &std::collections::BTreeMap<String, Vec<u8>>,
        ) -> Result<super::capture::CapturedPreviews, String> {
            Err("missing stylesheet".into())
        }
    }
    let f = Fixture::new();
    let dir = f.prepare();
    let before = fs::read(dir.join("current.json")).unwrap();
    assert!(
        store::prepare_captured(&f.store, &f.project, &f.manifest(), Some(&mut Refuse))
            .unwrap_err()
            .contains("missing stylesheet")
    );
    assert_eq!(fs::read(dir.join("current.json")).unwrap(), before);
}
#[test]
fn producer_capture_claims_are_never_authority() {
    let f = Fixture::new();
    let mut input = f.manifest();
    input["captureVerified"] = json!(true);
    input["capture"] = json!({"schema":"native-component-previews-v1"});
    input["components"][0]["capture"] = json!({"verified":true});
    input["components"][0]["preview"]["sourceKind"] = json!("page");
    let dir = store::prepare(&f.store, &f.project, &input).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    assert!(state["packet"]["capture"].is_null());
    assert!(state["packet"]["components"][0]["capture"].is_null());
    assert!(state["packet"]["components"][0]["preview"]["sourceKind"].is_null());
    assert_eq!(
        store::submit(&dir, &approve(&state)).unwrap()["captureVerified"],
        false
    );
}

#[test]
fn native_capture_outputs_are_immutable_and_source_changes_invalidate_approval() {
    struct Renderer;
    impl super::capture::ComponentCapturer for Renderer {
        fn capture(
            &mut self,
            packet: &mut Value,
            _: &std::collections::BTreeMap<String, Vec<u8>>,
        ) -> Result<super::capture::CapturedPreviews, String> {
            // A trusted in-process renderer double, never a producer JSON claim.
            packet["components"][1]["preview"] = json!({"kind":"image","url":"/files/_review_captures/control.png","sourceKind":"page"});
            Ok(super::capture::CapturedPreviews {
                files: std::collections::BTreeMap::from([(
                    "_review_captures/control.png".into(),
                    b"native pixels".to_vec(),
                )]),
                evidence: json!({"schema":"native-component-previews-v1","components":[{"id":"art"},{"id":"control"}]}),
            })
        }
    }
    let f = Fixture::new();
    let dir =
        store::prepare_captured(&f.store, &f.project, &f.manifest(), Some(&mut Renderer)).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::sources_current(&state).unwrap();
    assert!(
        state["sources"]
            .get("_review_captures/control.png")
            .is_none()
    );
    let receipt = store::submit(&dir, &approve(&state)).unwrap();
    assert_eq!(receipt["captureVerified"], true);
    assert_eq!(receipt["reviewer"], "local-browser");
    fs::write(f.project.join("art.png"), b"changed").unwrap();
    assert!(store::sources_current(&state).is_err());
    store::prepare_captured(&f.store, &f.project, &f.manifest(), Some(&mut Renderer)).unwrap();
    let next = store::read(&dir.join("current.json")).unwrap();
    assert!(next["draft"]["decisions"]["art"].is_null());
    assert_eq!(next["draft"]["decisions"]["control"]["action"], "approve");
    assert_ne!(state["packet"]["revision"], next["packet"]["revision"]);
    assert_eq!(
        store::submit(&dir, &approve(&next)).unwrap()["captureVerified"],
        true
    );
}

#[test]
fn changing_manifest_without_prepare_rejects_review_submission() {
    let f = Fixture::new();
    let input = f.manifest();
    let file = f.project.join("review.json");
    fs::write(&file, serde_json::to_vec(&input).unwrap()).unwrap();
    let dir = store::prepare_file(&f.store, &f.project, "review.json", None).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    let mut changed = input;
    changed["components"][0]["box"]["w"] = json!(0.4);
    fs::write(&file, serde_json::to_vec(&changed).unwrap()).unwrap();
    assert!(
        store::submit(&dir, &approve(&state))
            .unwrap_err()
            .contains("stale")
    );
}

#[test]
fn versioned_packet_keeps_submitted_round_when_current_advances() {
    let f = Fixture::new();
    let dir = f.prepare();
    let state = store::read(&dir.join("current.json")).unwrap();
    let revision = state["packet"]["revision"].as_str().unwrap();
    let receipt = store::submit(&dir, &approve(&state)).unwrap();
    assert_eq!(
        server::packet_state(&dir, Some(revision)).unwrap()["receipt"],
        receipt
    );
    fs::write(f.project.join("art.png"), b"new artwork").unwrap();
    f.prepare();
    let old = server::packet_state(&dir, Some(revision)).unwrap();
    assert_eq!(old["packet"], state["packet"]);
    assert_eq!(old["receipt"], receipt);
    assert_eq!(old["historical"], true);
    assert!(old["sourceStatus"].is_null());
    assert_ne!(
        server::packet_state(&dir, None).unwrap()["packet"]["revision"],
        revision
    );
    assert!(server::packet_state(&dir, Some("../../current")).is_err());
    assert!(store::submit(&dir, &approve(&state)).is_err());
}

#[test]
fn verify_requires_native_approval_and_current_manifest_and_dependencies() {
    let f = Fixture::new();
    fs::write(f.project.join("review.json"), f.manifest().to_string()).unwrap();
    let dir = store::prepare_file(&f.store,&f.project,"review.json",Some(&mut Native)).unwrap();
    assert!(super::verify::approved(&f.store,&f.project,"review.json").is_err());
    let state = store::read(&dir.join("current.json")).unwrap();
    let mut needs_work = approve(&state);
    needs_work["decisions"]["art"]["action"] = json!("revise");
    needs_work["decisions"]["art"]["feedback"] = json!("Wrong shape");
    store::submit(&dir,&needs_work).unwrap();
    assert!(super::verify::approved(&f.store,&f.project,"review.json").is_err());
    fs::write(f.project.join("art.png"), b"repaired art").unwrap();
    let dir = store::prepare_file(&f.store,&f.project,"review.json",Some(&mut Native)).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir,&approve(&state)).unwrap();
    assert_eq!(super::verify::approved(&f.store,&f.project,"review.json").unwrap()["visualDecision"],"approved");
    fs::write(f.project.join("other.json"), f.manifest().to_string()).unwrap();
    assert!(super::verify::approved(&f.store,&f.project,"other.json").unwrap_err().contains("bind"));
    fs::write(f.project.join("shared.css"), b"changed after approval").unwrap();
    assert!(super::verify::approved(&f.store,&f.project,"review.json").unwrap_err().contains("changed"));
}

#[test]
fn measured_inventory_is_bound_without_repeated_author_dependencies() {
    let f = Fixture::new();
    fs::create_dir_all(f.project.join(".impeccable/build")).unwrap();
    let path = f.project.join(".impeccable/build/spec.json");
    fs::write(&path, br#"{"regions":[{"id":"art","kind":"plate"},{"id":"control","kind":"control"}]}"#).unwrap();
    let mut input = f.manifest(); input["stage"] = json!("components");
    let dir = store::prepare(&f.store, &f.project, &input).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    assert!(state["sources"][".impeccable/build/spec.json"].is_string());
    let mut missing = input.clone(); missing["components"].as_array_mut().unwrap().pop();
    assert!(store::prepare(&f.store, &f.project, &missing).unwrap_err().contains("omitted measured region"));
    let mut flattened = input; flattened["components"][1]["preview"] = json!({"kind":"image","path":"art.png"});
    assert!(store::prepare(&f.store, &f.project, &flattened).unwrap_err().contains("rendered code preview"));
    fs::write(path, br#"{"regions":[]}"#).unwrap();
    assert!(store::sources_current(&state).is_err());
}

#[test]
fn schema_v2_component_manifests_are_retired_but_v2_hero_still_freezes() {
    let f = Fixture::new();
    fs::create_dir_all(f.project.join(".impeccable/build")).unwrap();
    fs::write(f.project.join(".impeccable/build/spec.json"), br#"{"regions":[{"id":"art","kind":"plate"},{"id":"control","kind":"control"}]}"#).unwrap();
    let mut input = f.manifest();
    input["schemaVersion"] = json!(2);
    input["stage"] = json!("components");
    assert!(manifest::freeze(&f.project, &input).unwrap_err().contains("component-review plan"));
    input["stage"] = json!("hero");
    assert!(manifest::freeze(&f.project, &input).is_ok());
    input["stage"] = Value::Null;
    assert!(manifest::freeze(&f.project, &input).is_err());
}

#[test]
fn visual_approvals_survive_shared_source_edits_but_not_changed_scope_or_pixels() {
    struct Renderer(&'static [u8]);
    impl super::capture::ComponentCapturer for Renderer {
        fn capture(
            &mut self,
            packet: &mut Value,
            _: &std::collections::BTreeMap<String, Vec<u8>>,
        ) -> Result<super::capture::CapturedPreviews, String> {
            packet["components"][1]["preview"] = json!({"kind":"image","sourceKind":"page","url":"/files/_review_captures/control.png"});
            Ok(super::capture::CapturedPreviews {
                files: std::collections::BTreeMap::from([(
                    "_review_captures/control.png".into(),
                    self.0.to_vec(),
                )]),
                evidence: json!({"schema":"native-component-previews-v1","components":[{"id":"art"},{"id":"control","views":{"preview":{"kind":"static-code","entry":"control.html","screenshotSha256":manifest::digest(self.0),"viewport":{"width":100,"height":100,"dpr":1}}}}]}),
            })
        }
    }
    let f = Fixture::new();
    let dir = store::prepare_captured(
        &f.store,
        &f.project,
        &f.manifest(),
        Some(&mut Renderer(b"same pixels")),
    )
    .unwrap();
    let before = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&before)).unwrap();
    fs::write(
        f.project.join("shared.css"),
        b"button{color:red} .unrelated{color:blue}",
    )
    .unwrap();
    assert!(store::sources_current(&before).is_err());
    store::prepare_captured(
        &f.store,
        &f.project,
        &f.manifest(),
        Some(&mut Renderer(b"same pixels")),
    )
    .unwrap();
    let mut after = store::read(&dir.join("current.json")).unwrap();
    assert_ne!(
        before["packet"]["components"][1]["revision"],
        after["packet"]["components"][1]["revision"]
    );
    assert_eq!(after["draft"]["decisions"]["control"]["action"], "approve");
    assert_eq!(
        after["visualApprovalCarry"]["control"]["basis"],
        "identical-native-captures-v1"
    );
    assert!(after["receipt"].is_null());
    assert_eq!(after["history"]["changes"]["control"]["kind"], "unchanged");
    assert_eq!(after["history"]["changes"]["control"]["sourceChanged"], true);
    assert_eq!(after["history"]["changes"]["control"]["carried"], true);
    // Existing pending packets can gain carry-forward without changing their revision.
    after["draft"]["decisions"]
        .as_object_mut()
        .unwrap()
        .remove("control");
    store::write(&dir.join("current.json"), &after).unwrap();
    assert_eq!(store::refresh_approvals(&dir).unwrap(), 1);
    assert_eq!(store::refresh_approvals(&dir).unwrap(), 0);
    let carried = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(carried["packet"], after["packet"]);
    assert_eq!(carried["sources"], after["sources"]);
    // Changed scope, comp, preview bytes, absent proof and corrupt blobs fail closed.
    let previous = store::read(&dir.join(format!(
        "revisions/{}.json",
        before["packet"]["revision"].as_str().unwrap()
    )))
    .unwrap();
    // Component decisions approve the isolated preview, not its contextual
    // surroundings or the dependency closure of a shared document.
    let mut component_previous = previous.clone();
    component_previous["packet"]["stage"] = json!("components");
    let mut component_current = after.clone();
    component_current["packet"]["stage"] = json!("components");
    component_current["packet"]["components"][1]["dependencies"] = json!(["shared.css", "unrelated.png"]);
    component_current["packet"]["components"][1]["context"] = json!({"kind":"image","url":"/files/unrelated-context.png"});
    component_current["capture"]["components"][1]["views"]["preview"]["rasterElements"] = json!(12);
    assert_eq!(super::visual_approval::carry(&component_previous, &mut component_current, &dir.join("blobs")), 1);
    assert_eq!(component_current["draft"]["decisions"]["control"]["action"], "approve");
    assert!(component_current["receipt"].is_null());
    for field in ["box", "medium", "note", "preview"] {
        let mut changed = component_current.clone();
        changed["draft"]["decisions"].as_object_mut().unwrap().remove("control");
        changed["packet"]["components"][1][field] = json!("changed");
        assert_eq!(super::visual_approval::carry(&component_previous, &mut changed, &dir.join("blobs")), 0, "component scope: {field}");
    }
    for field in ["box", "medium", "note", "context"] {
        let mut changed = after.clone();
        changed["packet"]["components"][1][field] = json!("changed");
        assert_eq!(
            super::visual_approval::carry(&previous, &mut changed, &dir.join("blobs")),
            0,
            "{field}"
        );
    }
    let mut changed = after.clone();
    changed["capture"] = Value::Null;
    assert_eq!(
        super::visual_approval::carry(&previous, &mut changed, &dir.join("blobs")),
        0
    );
    let mut changed = after.clone();
    changed["draft"]["decisions"]["control"] = json!({"action":"revise"});
    assert_eq!(
        super::visual_approval::carry(&previous, &mut changed, &dir.join("blobs")),
        0
    );
    let mut changed = after.clone();
    changed["capture"]["components"][1]["views"]["preview"]["viewport"]["width"] = json!(200);
    assert_eq!(super::visual_approval::carry(&previous, &mut changed, &dir.join("blobs")), 0);
    let mut unsubmitted = previous.clone();
    unsubmitted["receipt"] = Value::Null;
    assert_eq!(super::visual_approval::carry(&unsubmitted, &mut after.clone(), &dir.join("blobs")), 0);
    let pixel_path = dir.join("blobs").join(manifest::digest(b"same pixels"));
    fs::write(&pixel_path, b"corrupted capture").unwrap();
    assert_eq!(super::visual_approval::carry(&previous, &mut after.clone(), &dir.join("blobs")), 0);
    fs::write(&pixel_path, b"same pixels").unwrap();
    store::submit(&dir, &approve(&carried)).unwrap();
    store::prepare_captured(
        &f.store,
        &f.project,
        &f.manifest(),
        Some(&mut Renderer(b"different pixels")),
    )
    .unwrap();
    let changed = store::read(&dir.join("current.json")).unwrap();
    assert!(changed["draft"]["decisions"]["control"].is_null());
    store::prepare_captured(&f.store,&f.project,&f.manifest(),Some(&mut Renderer(b"same pixels"))).unwrap();
    let restored=store::read(&dir.join("current.json")).unwrap();
    assert_eq!(restored["draft"]["decisions"]["control"]["action"],"approve");
    assert!(restored["receipt"].is_null());
}

#[test]
fn review_groups_preserve_instances_and_require_a_shared_code_document() {
    let f = Fixture::new();
    fs::create_dir_all(f.project.join(".impeccable/build")).unwrap();
    fs::write(f.project.join(".impeccable/build/spec.json"), r#"{"regions":[]}"#).unwrap();
    let mut input=f.manifest(); input["stage"]=json!("components");
    input["components"][1]["reviewGroup"]=json!("Labels");
    let mut peer=input["components"][1].clone(); peer["id"]=json!("peer");
    input["components"].as_array_mut().unwrap().push(peer);
    let (packet, _) = manifest::freeze(&f.project, &input).unwrap();
    assert_eq!(packet["components"].as_array().unwrap().len(),3);
    assert_eq!(packet["components"][2]["reviewGroup"],"Labels");
    let mut invalid=input.clone();invalid["components"][0]["reviewGroup"]=json!("Labels");
    assert!(manifest::freeze(&f.project,&invalid).unwrap_err().contains("raster assets remain individual"));
    input["components"][2]["preview"]["path"]=json!("different.html");
    assert!(manifest::freeze(&f.project,&input).unwrap_err().contains("share one code document"));
}

#[test]
fn invalid_component_geometry_names_the_component_and_bounds() {
    let f = Fixture::new();
    let mut input = f.manifest();
    input["components"][0]["box"]["w"] = json!(2);
    let error = manifest::freeze(&f.project, &input).unwrap_err();
    assert!(error.contains("art") && error.contains("box") && error.contains("2") && error.contains("normalized"), "{error}");
    let mut input = f.manifest();
    let duplicate = input["components"][0].clone();
    input["components"].as_array_mut().unwrap().push(duplicate);
    let error = manifest::freeze(&f.project, &input).unwrap_err();
    assert!(error.contains("duplicate component id") && error.contains("art"), "{error}");
}

#[test]
fn component_review_refuses_groups_that_mix_measured_roles() {
    let f = Fixture::new();
    fs::create_dir_all(f.project.join(".impeccable/build")).unwrap();
    let mut input = f.manifest();
    input["stage"] = json!("components");
    input["components"][1]["reviewGroup"] = json!("peers");
    let mut peer = input["components"][1].clone(); peer["id"] = json!("peer");
    input["components"].as_array_mut().unwrap().push(peer);
    let mut spec = json!({"regions":[{"id":"control","kind":"control"},{"id":"peer","kind":"text"}]});
    let path = f.project.join(".impeccable/build/spec.json");
    fs::write(&path, spec.to_string()).unwrap();
    assert!(manifest::freeze(&f.project,&input).unwrap_err().contains("mixes region kinds"));
    spec["regions"][1]["kind"] = json!("control");
    fs::write(&path, spec.to_string()).unwrap();
    assert_eq!(manifest::freeze(&f.project,&input).unwrap().0["components"].as_array().unwrap().len(),3);
}

#[test]
fn measured_inventory_reports_all_independent_failures_before_capture() {
    let f = Fixture::new();
    fs::create_dir_all(f.project.join(".impeccable/build")).unwrap();
    fs::write(f.project.join(".impeccable/build/spec.json"), br#"{"regions":[{"id":"missing-one","kind":"plate"},{"id":"control","kind":"control"},{"id":"missing-two","kind":"text"}]}"#).unwrap();
    let mut input = f.manifest();
    input["stage"] = json!("components");
    input["components"][1]["preview"] = json!({"kind":"image","path":"art.png"});
    let error = store::prepare(&f.store, &f.project, &input).unwrap_err();
    assert!(error.contains("missing-one"));
    assert!(error.contains("missing-two"));
    assert!(error.contains("semantic region \"control\" requires a rendered code preview"));
    assert!(!f.store.exists(), "invalid inventory must not publish a review");
}

/// Behaves like the native adapter: code views become hash-named captures with proofs.
struct Native;
impl super::capture::ComponentCapturer for Native {
    fn capture(&mut self, packet: &mut Value, inputs: &std::collections::BTreeMap<String, Vec<u8>>) -> Result<super::capture::CapturedPreviews, String> {
        let (mut files, mut evidence) = (std::collections::BTreeMap::new(), vec![]);
        for c in packet["components"].as_array_mut().unwrap() {
            let path = c["preview"]["url"].as_str().unwrap().strip_prefix("/files/").unwrap().to_string();
            let proof = if c["preview"]["kind"] == "image" {
                json!({"kind":"raster-source","path":path,"sha256":manifest::digest(&inputs[&path])})
            } else {
                let png = format!("pixels of {path}").into_bytes();
                let hash = manifest::digest(&png);
                c["preview"] = json!({"kind":"image","sourceKind":"page","url":format!("/files/_review_captures/{hash}.png")});
                files.insert(format!("_review_captures/{hash}.png"), png);
                json!({"kind":"static-code","entry":path,"screenshotSha256":hash,"viewport":{"width":100,"height":100,"dpr":1}})
            };
            c["thumbnail"] = json!({"url":c["preview"]["url"]});
            evidence.push(json!({"id":c["id"],"views":{"preview":proof}}));
        }
        Ok(super::capture::CapturedPreviews { files, evidence: json!({"schema":"native-component-previews-v1","components":evidence}) })
    }
}

#[test]
fn verify_recomputes_capture_integrity_instead_of_trusting_stored_flags() {
    let f = Fixture::new();
    fs::write(f.project.join("review.json"), f.manifest().to_string()).unwrap();
    // A plain prepare with a forged capture claim and receipt flag.
    let dir = store::prepare_file(&f.store, &f.project, "review.json", None).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    let mut forged = store::read(&dir.join("current.json")).unwrap();
    forged["capture"] = json!({"schema":"native-component-previews-v1","components":[]});
    forged["receipt"]["capture"] = forged["capture"].clone();
    forged["receipt"]["captureVerified"] = json!(true);
    store::write(&dir.join("current.json"), &forged).unwrap();
    assert!(super::verify::approved(&f.store, &f.project, "review.json").unwrap_err().contains("not intact"));
    forged["capture"]["components"] = json!([{"id":"art"},{"id":"control"}]);
    forged["receipt"]["capture"] = forged["capture"].clone();
    store::write(&dir.join("current.json"), &forged).unwrap();
    assert!(super::verify::approved(&f.store, &f.project, "review.json").unwrap_err().contains("not intact"));
    // A genuine capture passes; dropping evidence or swapping captured pixels does not.
    fs::write(f.project.join("art.png"), b"new art").unwrap();
    let dir = store::prepare_file(&f.store, &f.project, "review.json", Some(&mut Native)).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    let good = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(super::verify::approved(&f.store, &f.project, "review.json").unwrap()["visualDecision"], "approved");
    let mut partial = good.clone();
    partial["capture"]["components"].as_array_mut().unwrap().pop();
    partial["receipt"]["capture"] = partial["capture"].clone();
    store::write(&dir.join("current.json"), &partial).unwrap();
    assert!(super::verify::approved(&f.store, &f.project, "review.json").unwrap_err().contains("cover"));
    store::write(&dir.join("current.json"), &good).unwrap();
    let captured = good["files"].as_object().unwrap().iter().find(|(p, _)| p.starts_with("_review_captures/")).unwrap().1.as_str().unwrap();
    fs::write(dir.join("blobs").join(captured), b"swapped").unwrap();
    assert!(super::verify::approved(&f.store, &f.project, "review.json").unwrap_err().contains("pinned bytes"));
}

fn serve_in_thread(dir: &std::path::Path, idle_ms: u64) -> std::sync::mpsc::Receiver<Result<i32, String>> {
    let (tx, rx) = std::sync::mpsc::channel();
    let d = dir.to_path_buf();
    std::thread::spawn(move || {
        let (mut io, _) = impeccable_common::Io::captured("", d.clone(), Default::default());
        let limits = server::Limits { idle: std::time::Duration::from_millis(idle_ms), grace: std::time::Duration::from_millis(100) };
        tx.send(server::serve(&d, 0, &mut io, limits, None)).ok();
    });
    rx
}

#[test]
fn serve_exits_after_submission_or_idle_and_removes_its_service_record() {
    let f = Fixture::new();
    let dir = f.prepare();
    let rx = serve_in_thread(&dir, 300);
    assert_eq!(rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap(), Ok(4));
    assert!(!dir.join("service.json").exists());
    let state = store::read(&dir.join("current.json")).unwrap();
    let rx = serve_in_thread(&dir, 60_000);
    // Wait for the record rather than a fixed delay: a loaded runner can take
    // longer than any fixed sleep to bind and write it.
    let started = std::time::Instant::now();
    while !dir.join("service.json").exists() && started.elapsed() < std::time::Duration::from_secs(10) {
        std::thread::sleep(std::time::Duration::from_millis(20));
    }
    assert!(dir.join("service.json").exists());
    store::submit(&dir, &approve(&state)).unwrap();
    assert_eq!(rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap(), Ok(0));
    assert!(!dir.join("service.json").exists());
}

// A browser loading the review opens a burst of sockets (fonts, script,
// packet, snapshot files) and keeps some idle. tiny_http 0.12 left part of
// such a burst unanswered (#1071); every request must get its answer.
#[test]
fn serve_answers_a_burst_of_connections() {
    let f = Fixture::new();
    let dir = f.prepare();
    let rx = serve_in_thread(&dir, 60_000);
    let started = std::time::Instant::now();
    let url = loop {
        if let Ok(s) = store::read(&dir.join("service.json")) {
            break s["url"].as_str().unwrap().to_string();
        }
        assert!(started.elapsed() < std::time::Duration::from_secs(10), "no service record");
        std::thread::sleep(std::time::Duration::from_millis(20));
    };
    let host = url.trim_start_matches("http://").trim_end_matches('/').to_string();
    let addr: std::net::SocketAddr = host.parse().unwrap();
    let request = format!("GET /review.css HTTP/1.1\r\nHost: {host}\r\n\r\n");
    for _ in 0..3 {
        assert_eq!(impeccable_common::http::burst_answered(addr, request.as_bytes(), 4, 8), 8, "connections stranded");
    }
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    assert_eq!(rx.recv_timeout(std::time::Duration::from_secs(5)).unwrap(), Ok(0));
}

#[test]
fn status_hides_dead_servers_and_serve_refuses_sessions_without_a_browser() {
    let f = Fixture::new();
    let dir = f.prepare();
    let id = dir.file_name().unwrap().to_string_lossy().into_owned();
    store::write(&dir.join("service.json"), &json!({"url":"http://127.0.0.1:9/","pid":2147483000i64})).unwrap();
    let run = |cmd: &str, env: &[(&str, &str)]| {
        let env = env.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect();
        let (mut io, out) = impeccable_common::Io::captured("", f.project.clone(), env);
        let args: Vec<String> = [cmd, "--session", &id, "--store", f.store.to_str().unwrap()].map(String::from).to_vec();
        let code = super::run(&args, &mut io);
        let stdout = String::from_utf8(out.stdout.borrow().clone()).unwrap();
        (code, stdout)
    };
    let (code, out) = run("status", &[]);
    assert_eq!(code, 0);
    assert_eq!(serde_json::from_str::<Value>(&out).unwrap()["service"], Value::Null);
    assert_eq!(run("serve", &[("IMPECCABLE_QUESTION_DISABLED", "1")]).0, 2);
    assert_eq!(run("serve", &[("CI", "1")]).0, 2);
}

#[test]
fn a_held_lock_is_exclusive_whatever_its_file_says() {
    let f = Fixture::new();
    let dir = f.root.join("locked");
    let held = store::lock(&dir).unwrap();
    // Contents of an old-style stale lock (dead PID) never let a second writer in.
    // Windows locks are mandatory, so the forged contents can't even be written there.
    #[cfg(unix)]
    fs::write(dir.join("review.lock"), "2147483000\n").unwrap();
    assert!(store::lock(&dir).is_err());
    drop(held);
    assert!(dir.join("review.lock").exists());
    let _again = store::lock(&dir).unwrap();
}

#[test]
fn forged_acceptance_never_closes_review_in_lifecycle() {
    let f = Fixture::new();
    let mut hero = f.manifest();
    hero["stage"] = json!("hero");
    let dir = store::prepare(&f.store, &f.project, &hero).unwrap();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    let mut forged = store::read(&dir.join("current.json")).unwrap();
    forged["capture"] = json!({"schema":"native-component-previews-v1","components":[{"id":"art"},{"id":"control"}]});
    forged["receipt"]["capture"] = forged["capture"].clone();
    forged["receipt"]["captureVerified"] = json!(true);
    store::write(&dir.join("current.json"), &forged).unwrap();
    assert!(super::lifecycle::accepted(&forged));
    let result = super::lifecycle::inspect(&[dir.clone()], &["components".into(), "hero".into()]).unwrap();
    assert_eq!(result["status"], "pending");
    assert!(super::lifecycle::final_session(&f.store, &f.project.canonicalize().unwrap()).unwrap().is_none());
}

// ---- plan and asset review (schemaVersion 3) --------------------------------

const PLAN_SPEC: &str = r#"{"comp":"comp.png","compSize":{"width":100,"height":100},"regions":[
 {"id":"nav","kind":"chrome","note":"Top bar","box":{"x":0,"y":0,"w":1,"h":0.1}},
 {"id":"art","kind":"plate","note":"Figure","box":{"x":0.5,"y":0.1,"w":0.5,"h":0.5},"plate":"assets/art.png"},
 {"id":"photo","kind":"image","note":"Harbour photo","box":{"x":0,"y":0.6,"w":0.5,"h":0.4},"plate":"assets/photo.png"},
 {"id":"headline","kind":"text","note":"A little closer","box":{"x":0.05,"y":0.2,"w":0.4,"h":0.2}},
 {"id":"brushed-panel","kind":"chrome","note":"Brushed steel","box":{"x":0,"y":0.4,"w":0.5,"h":0.1},"flags":[{"id":"painted-pixels","message":"soft gradients"}]},
 {"id":"ground","kind":"chrome","container":true,"note":"Page ground","box":{"x":0,"y":0,"w":1,"h":1}},
 {"id":"strip","kind":"band","note":"Band","box":{"x":0,"y":0.9,"w":1,"h":0.1}},
 {"id":"table","kind":"text","codeDrawn":true,"note":"Tide table","box":{"x":0.5,"y":0.6,"w":0.5,"h":0.3}}]}"#;

impl Fixture {
    fn plan_project(&self) {
        fs::create_dir_all(self.project.join(".impeccable/build")).unwrap();
        fs::write(self.project.join(".impeccable/build/spec.json"), PLAN_SPEC).unwrap();
        fs::write(self.project.join(".impeccable/build/state.json"), r#"{"startedAt":"build-1","artifact":"index.html"}"#).unwrap();
    }
    fn plates(&self) {
        fs::create_dir_all(self.project.join("assets")).unwrap();
        fs::write(self.project.join("assets/art.png"), b"art plate").unwrap();
        fs::write(self.project.join("assets/photo.png"), b"photo plate").unwrap();
    }
    fn io(&self) -> (impeccable_common::Io, impeccable_common::Captured) {
        impeccable_common::Io::captured("", self.project.clone(), std::collections::HashMap::from([("HOME".into(), self.root.to_string_lossy().into_owned())]))
    }
    /// `component-review <args> --store <store>` with no native capturer at all.
    fn cli(&self, args: &[&str]) -> (i32, String, String) {
        let (mut io, captured) = self.io();
        let mut argv: Vec<String> = args.iter().map(|a| a.to_string()).collect();
        argv.extend(["--store".into(), self.store.to_string_lossy().into_owned()]);
        let code = super::run_with_capturer(&argv, &mut io, None);
        let text = |b: &std::cell::RefCell<Vec<u8>>| String::from_utf8(b.borrow().clone()).unwrap();
        (code, text(&captured.stdout), text(&captured.stderr))
    }
    fn plan_round(&self) -> PathBuf {
        assert_eq!(self.cli(&["plan"]).0, 0);
        let (code, out, err) = self.cli(&["capture", "--manifest", ".impeccable/review/components.json"]);
        assert_eq!(code, 0, "{err}");
        let session: Value = serde_json::from_str(&out).unwrap();
        self.store.join(session["session"].as_str().unwrap())
    }
    fn gate(&self) -> Result<(), String> {
        super::plan::gate(&self.store, &self.project, "impeccable")
    }
}

#[test]
fn plan_refuses_listing_every_missing_plate_then_orders_roles_from_the_spec() {
    let f = Fixture::new();
    f.plan_project();
    let (code, _, err) = f.cli(&["plan"]);
    assert_eq!(code, 1);
    assert!(err.contains("2 raster region(s) lack their plate") && err.contains("art (plate): assets/art.png") && err.contains("photo (image): assets/photo.png"), "{err}");
    assert!(!f.project.join(".impeccable/review/components.json").exists());
    f.plates();
    let (code, out, err) = f.cli(&["plan"]);
    assert_eq!(code, 0, "{err}");
    assert!(out.contains("2 assets, 3 plan items (2 flagged or code-drawn), 3 code regions") && out.contains("NEXT impeccable component-review capture --manifest .impeccable/review/components.json"), "{out}");
    let packet = store::read(&f.project.join(".impeccable/review/components.json")).unwrap();
    let ids = |key: &str| packet[key].as_array().unwrap().iter().map(|c| c["id"].as_str().unwrap().to_string()).collect::<Vec<_>>();
    assert_eq!(ids("components"), ["brushed-panel", "table", "art", "photo", "nav"]);
    assert_eq!(ids("codeRegions"), ["headline", "ground", "strip"]);
    assert_eq!(packet["schemaVersion"], 3);
    assert_eq!(packet["stage"], "components");
    assert_eq!(packet["comp"], json!({"path":"comp.png","width":100,"height":100}));
    assert_eq!(packet["specSha256"], manifest::digest(PLAN_SPEC.as_bytes()));
    let c = &packet["components"];
    assert_eq!((c[0]["role"].as_str(), c[0]["name"].as_str(), c[0]["codeDrawn"].as_bool()), (Some("plan"), Some("Brushed panel"), Some(false)));
    assert_eq!(c[0]["flags"][0]["id"], "painted-pixels");
    assert_eq!(c[0]["preview"], json!({"kind":"comp-crop"}));
    assert_eq!(c[1]["codeDrawn"], true);
    assert_eq!(c[2]["preview"], json!({"kind":"image","path":"assets/art.png"}));
    assert_eq!((c[2]["role"].as_str(), c[2]["medium"].as_str()), (Some("asset"), Some("raster")));
    assert!(c[4]["flags"].is_null());
    assert_eq!(packet["codeRegions"][0], json!({"id":"headline","name":"Headline","kind":"text","box":{"x":0.05,"y":0.2,"w":0.4,"h":0.2},"note":"A little closer"}));
}

#[test]
fn plan_capture_needs_no_browser_and_approval_verifies_against_the_pinned_spec() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    assert_eq!(state["capture"]["schema"], super::capture::PLAN_SCHEMA);
    let proofs = state["capture"]["components"].as_array().unwrap();
    assert_eq!(proofs[0]["views"]["preview"], json!({"kind":"comp-crop","compPath":"comp.png","compSha256":manifest::digest(b"comp"),"box":state["packet"]["components"][0]["box"]}));
    assert_eq!(proofs[2]["views"]["preview"]["kind"], "raster-source");
    assert!(state["packet"]["components"][0]["preview"]["url"].is_null());
    assert_eq!(state["packet"]["codeRegions"].as_array().unwrap().len(), 3);
    assert!(f.gate().unwrap_err().contains("not accepted"));
    let receipt = store::submit(&dir, &approve(&state)).unwrap();
    assert_eq!((receipt["visualDecision"].as_str(), receipt["captureVerified"].as_bool()), (Some("approved"), Some(true)));
    assert_eq!(super::verify::approved(&f.store, &f.project, ".impeccable/review/components.json").unwrap(), receipt);
    assert_eq!(super::lifecycle::inspect(&[dir.clone()], &["components".into()]).unwrap()["status"], "approved");
    f.gate().unwrap();
    // Stored flags are claims: a packet digest that no longer matches the pinned spec fails integrity.
    let mut forged = store::read(&dir.join("current.json")).unwrap();
    forged["packet"]["specSha256"] = json!("0".repeat(64));
    assert!(super::verify::capture_intact(&dir, &forged).unwrap_err().contains("spec digest"));
    let mut moved = store::read(&dir.join("current.json")).unwrap();
    moved["capture"]["components"][0]["views"]["preview"]["box"]["x"] = json!(0.3);
    moved["receipt"]["capture"] = moved["capture"].clone();
    assert!(super::verify::capture_intact(&dir, &moved).unwrap_err().contains("comp-crop evidence"));
    // A native-schema claim is not plan evidence.
    let mut native = store::read(&dir.join("current.json")).unwrap();
    native["capture"]["schema"] = json!(super::capture::NATIVE_SCHEMA);
    native["receipt"]["capture"] = native["capture"].clone();
    assert!(!super::lifecycle::accepted(&native));
    // A spec change after acceptance reopens the gate and needs a new round.
    let mut spec: Value = serde_json::from_str(PLAN_SPEC).unwrap();
    spec["regions"][3]["note"] = json!("A little closer to the sea");
    fs::write(f.project.join(".impeccable/build/spec.json"), spec.to_string()).unwrap();
    assert!(f.gate().unwrap_err().contains("earlier spec.json"));
    assert!(super::verify::approved(&f.store, &f.project, ".impeccable/review/components.json").is_err());
}

#[test]
fn plan_freeze_binds_the_spec_and_the_complete_inventory() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let packet = super::plan::build(&f.project).unwrap();
    manifest::freeze(&f.project, &packet).unwrap();
    let mut omitted = packet.clone();
    omitted["codeRegions"].as_array_mut().unwrap().remove(0);
    assert!(manifest::freeze(&f.project, &omitted).unwrap_err().contains("omitted measured region \"headline\""));
    let mut foreign = packet.clone();
    foreign["codeRegions"][0]["id"] = json!("elsewhere");
    assert!(manifest::freeze(&f.project, &foreign).unwrap_err().contains("not a measured region"));
    let mut rendered = packet.clone();
    rendered["components"][0]["preview"] = json!({"kind":"page","path":"control.html"});
    assert!(manifest::freeze(&f.project, &rendered).unwrap_err().contains("comp-crop"));
    let mut stale = packet.clone();
    stale["specSha256"] = json!("0".repeat(64));
    assert!(manifest::freeze(&f.project, &stale).unwrap_err().contains("component-review plan"));
    let mut grouped = packet;
    grouped["components"][4]["reviewGroup"] = json!("bars");
    assert!(manifest::freeze(&f.project, &grouped).unwrap_err().contains("reviewGroup"));
}

#[test]
fn an_asset_split_into_layers_requests_changes_and_a_plan_item_cannot_split() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    let components = state["packet"]["components"].as_array().unwrap();
    let asset = components.iter().find(|c| c["role"] == "asset").unwrap();
    let plan = components.iter().find(|c| c["role"] == "plan").unwrap();
    let (asset_id, plan_id) = (asset["id"].as_str().unwrap(), plan["id"].as_str().unwrap());
    let mut body = approve(&state);
    body["decisions"][asset_id]["split"] = json!(true);
    assert!(store::submit(&dir, &body).is_err(), "an approval never splits");
    body["decisions"][asset_id] = json!({"revision":asset["revision"],"action":"revise","feedback":"","split":true});
    body["decisions"][plan_id] = json!({"revision":plan["revision"],"action":"revise","feedback":"Split it","split":true});
    assert!(store::submit(&dir, &body).is_err(), "split is for assets");
    body["decisions"][plan_id] = json!({"revision":plan["revision"],"action":"approve","feedback":"","split":false});
    let receipt = store::submit(&dir, &body).unwrap();
    assert_eq!(receipt["visualDecision"], "changes-requested");
    assert_eq!(receipt["submission"]["decisions"][asset_id]["split"], true);
}

#[test]
fn a_plan_item_revise_carries_the_map_change_and_requests_changes() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    let mut body = approve(&state);
    let rev = state["packet"]["components"][0]["revision"].clone();
    body["decisions"]["brushed-panel"] = json!({"revision":rev,"action":"revise","feedback":"Extend the photo under the band","split":false});
    let receipt = store::submit(&dir, &body).unwrap();
    assert_eq!(receipt["visualDecision"], "changes-requested");
    assert_eq!(receipt["submission"]["decisions"]["brushed-panel"]["feedback"], "Extend the photo under the band");
    assert!(f.gate().unwrap_err().contains("requested changes"));
}

#[test]
fn reclassification_requests_changes_and_carries_unchanged_decisions_into_the_next_round() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    let rev = |i: usize| state["packet"]["components"][i]["revision"].clone();
    let mut body = approve(&state);
    // A plan item takes reclassify with a raster kind, or revise with the reviewer's words.
    body["decisions"]["brushed-panel"] = json!({"revision":rev(0),"action":"revise","feedback":"  ","split":false});
    assert!(store::submit(&dir, &body).unwrap_err().contains("needs feedback"));
    body["decisions"]["brushed-panel"] = json!({"revision":rev(0),"action":"reclassify","kind":"svg","feedback":"","split":false});
    assert!(store::submit(&dir, &body).is_err());
    body["decisions"]["art"] = json!({"revision":rev(2),"action":"reclassify","kind":"image","feedback":"","split":false});
    body["decisions"]["brushed-panel"]["kind"] = json!("texture");
    assert!(store::submit(&dir, &body).is_err(), "assets are not reclassified");
    body["decisions"]["art"] = json!({"revision":rev(2),"action":"approve","feedback":"","split":false});
    let mut unknown = body.clone();
    unknown["reclassify"] = json!([{"id":"nav","kind":"plate"}]);
    assert!(store::submit(&dir, &unknown).unwrap_err().contains("codeRegions"), "a component is decided in decisions");
    body["reclassify"] = json!([{"id":"headline","kind":"plate","feedback":"This lettering is painted"}]);
    let receipt = store::submit(&dir, &body).unwrap();
    assert_eq!(receipt["visualDecision"], "changes-requested");
    assert!(f.gate().unwrap_err().contains("requested changes"));
    // Apply the receipt: headline becomes a plate, the panel a texture.
    let mut spec: Value = serde_json::from_str(PLAN_SPEC).unwrap();
    spec["regions"][3]["kind"] = json!("plate");
    spec["regions"][3]["plate"] = json!("assets/headline.png");
    spec["regions"][4]["kind"] = json!("texture");
    spec["regions"][4]["plate"] = json!("assets/panel.png");
    spec["regions"][4].as_object_mut().unwrap().remove("flags");
    fs::write(f.project.join(".impeccable/build/spec.json"), spec.to_string()).unwrap();
    fs::write(f.project.join("assets/headline.png"), b"headline plate").unwrap();
    fs::write(f.project.join("assets/panel.png"), b"panel plate").unwrap();
    let next_dir = f.plan_round();
    assert_eq!(next_dir, dir);
    let next = store::read(&next_dir.join("current.json")).unwrap();
    assert_eq!(next["packet"]["round"], 2);
    let carried: Vec<&str> = next["draft"]["decisions"].as_object().unwrap().keys().map(String::as_str).collect();
    assert_eq!(carried, ["table", "art", "photo", "nav"], "unchanged approvals carry across a spec change");
    assert_eq!(next["history"]["feedback"]["headline"]["decision"]["action"], "reclassify");
    assert_eq!(next["history"]["feedback"]["brushed-panel"]["decision"]["kind"], "texture");
    store::submit(&next_dir, &approve(&next)).unwrap();
    f.gate().unwrap();
}

#[test]
fn approving_every_component_while_reclassifying_a_code_region_is_not_approval() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    let mut body = approve(&state);
    body["inventoryConfirmed"] = json!(false);
    assert!(store::submit(&dir, &body).unwrap_err().contains("confirm inventory"));
    body["reclassify"] = json!([{"id":"headline","kind":"plate"},{"id":"headline","kind":"image"}]);
    assert!(store::submit(&dir, &body).is_err(), "one reclassification per region");
    body["reclassify"] = json!([{"id":"headline","kind":"plate"}]);
    let receipt = store::submit(&dir, &body).unwrap();
    assert_eq!(receipt["visualDecision"], "changes-requested");
    assert!(super::verify::approved(&f.store, &f.project, ".impeccable/review/components.json").is_err());
    // v1/v2 reviews have no reclassification.
    let legacy = Fixture::new();
    let legacy_dir = legacy.prepare();
    let mut legacy_body = approve(&store::read(&legacy_dir.join("current.json")).unwrap());
    legacy_body["reclassify"] = json!([{"id":"art","kind":"plate"}]);
    assert!(store::submit(&legacy_dir, &legacy_body).is_err());
}

#[test]
fn hosted_gate_requires_an_accepted_intact_review_in_the_named_sessions() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let hosted = |dirs: &[PathBuf]| super::plan::gate_hosted(dirs, &f.project, "impeccable", "component_review");
    assert!(hosted(&[]).unwrap_err().contains("not accepted"));
    let dir = f.plan_round();
    let err = hosted(&[dir.clone()]).unwrap_err();
    assert!(err.contains("not accepted") && err.contains("call component_review"), "{err}");
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    hosted(&[dir.clone()]).unwrap();
    // A forged or tampered session is not acceptance.
    let good = store::read(&dir.join("current.json")).unwrap();
    let mut forged = good.clone();
    forged["capture"]["components"].as_array_mut().unwrap().pop();
    forged["receipt"]["capture"] = forged["capture"].clone();
    store::write(&dir.join("current.json"), &forged).unwrap();
    assert!(hosted(&[dir.clone()]).is_err());
    store::write(&dir.join("current.json"), &good).unwrap();
    let blob = good["files"]["assets/art.png"].as_str().unwrap();
    fs::write(dir.join("blobs").join(blob), b"swapped").unwrap();
    assert!(hosted(&[dir.clone()]).is_err());
    fs::write(dir.join("blobs").join(blob), b"art plate").unwrap();
    hosted(&[dir.clone()]).unwrap();
    // A spec changed since the review, or an unreadable session, refuses.
    fs::write(f.project.join(".impeccable/build/spec.json"), PLAN_SPEC.replace("Top bar", "Top rail")).unwrap();
    assert!(hosted(&[dir.clone()]).unwrap_err().contains("earlier spec.json"));
    assert!(hosted(&[f.root.join("nowhere")]).is_err());
}

#[test]
fn hosted_gate_checks_the_builders_files_not_the_hosts_snapshot() {
    // gallery-20261004-c-sol-08: the host recorded its review-project snapshot as the
    // session's project, the builder's sandbox could not read it, and the gate called
    // the EPERM "a reviewed plate changed" three rounds running.
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    let mut snapshot = store::read(&dir.join("current.json")).unwrap();
    snapshot["project"] = json!(f.root.join("host-snapshot-unreadable").to_string_lossy());
    store::write(&dir.join("current.json"), &snapshot).unwrap();
    let hosted = || super::plan::gate_hosted(std::slice::from_ref(&dir), &f.project, "impeccable", "component_review");
    hosted().unwrap();
    fs::write(f.project.join("assets/art.png"), b"a different art plate").unwrap();
    let err = hosted().unwrap_err();
    assert!(err.contains("A reviewed plate changed") && err.contains("assets/art.png changed"), "{err}");
}

#[cfg(unix)]
#[test]
fn an_unreadable_reviewed_file_is_reported_as_unreadable_not_changed() {
    use std::os::unix::fs::PermissionsExt;
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    let art = f.project.join("assets/art.png");
    fs::set_permissions(&art, fs::Permissions::from_mode(0o000)).unwrap();
    let result = f.gate();
    fs::set_permissions(&art, fs::Permissions::from_mode(0o644)).unwrap();
    if result.is_ok() { return; } // root reads through mode bits
    let err = result.unwrap_err();
    assert!(err.contains("could not be checked") && err.contains("not a changed plate") && !err.contains("A reviewed plate changed"), "{err}");
    // A directory the builder cannot traverse is unreadable too, not a vanished plate.
    let assets = f.project.join("assets");
    fs::set_permissions(&assets, fs::Permissions::from_mode(0o000)).unwrap();
    let result = f.gate();
    fs::set_permissions(&assets, fs::Permissions::from_mode(0o755)).unwrap();
    let err = result.unwrap_err();
    assert!(err.contains("could not be checked") && !err.contains("disappeared"), "{err}");
}

#[test]
fn plan_leaves_bare_grounds_and_straight_rules_to_code_unless_flagged() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let mut spec: Value = serde_json::from_str(PLAN_SPEC).unwrap();
    let regions = spec["regions"].as_array_mut().unwrap();
    regions[0]["surface"] = json!({"flat": true, "rules": false});
    regions.push(json!({"id":"rule","kind":"chrome","note":"Brass hairline","box":{"x":0,"y":0.5,"w":1,"h":0.01},"surface":{"flat":false,"rules":true}}));
    regions.push(json!({"id":"mark","kind":"chrome","note":"Wave mark","box":{"x":0.9,"y":0,"w":0.05,"h":0.05},"surface":{"flat":false,"rules":false}}));
    regions.push(json!({"id":"moulding","kind":"chrome","note":"Moulded frieze","box":{"x":0,"y":0.95,"w":1,"h":0.05},"surface":{"flat":false,"rules":true},"flags":[{"id":"painted-pixels","message":"Looks painted"}]}));
    fs::write(f.project.join(".impeccable/build/spec.json"), serde_json::to_vec(&spec).unwrap()).unwrap();
    let (code, _, err) = f.cli(&["plan"]);
    assert_eq!(code, 0, "{err}");
    let packet = store::read(&f.project.join(".impeccable/review/components.json")).unwrap();
    let ids = |key: &str| packet[key].as_array().unwrap().iter().map(|c| c["id"].as_str().unwrap().to_string()).collect::<Vec<_>>();
    assert_eq!(ids("components"), ["brushed-panel", "table", "moulding", "art", "photo", "mark"]);
    assert_eq!(ids("codeRegions"), ["nav", "headline", "ground", "strip", "rule"]);
}

#[test]
fn plan_puts_flagged_assets_first_with_their_flags() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let mut spec: Value = serde_json::from_str(PLAN_SPEC).unwrap();
    spec["regions"][2]["flags"] = json!([{"id":"baked-composite","message":"Frame and view are one image here, so the page can't swap the view on its own."}]);
    fs::write(f.project.join(".impeccable/build/spec.json"), serde_json::to_vec(&spec).unwrap()).unwrap();
    let (code, out, err) = f.cli(&["plan"]);
    assert_eq!(code, 0, "{err}");
    assert!(out.contains("2 assets (1 flagged), 3 plan items (2 flagged or code-drawn)"), "{out}");
    let packet = store::read(&f.project.join(".impeccable/review/components.json")).unwrap();
    let ids: Vec<&str> = packet["components"].as_array().unwrap().iter().map(|c| c["id"].as_str().unwrap()).collect();
    // Flagged items of either role keep spec order at the front.
    assert_eq!(ids, ["photo", "brushed-panel", "table", "art", "nav"]);
    assert_eq!(packet["components"][0]["flags"][0]["id"], "baked-composite");
    assert_eq!(packet["components"][0]["role"], "asset");
    assert!(packet["components"][3]["flags"].is_null());
}

#[test]
fn a_plate_replaced_after_acceptance_reopens_the_plan_review() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    f.gate().unwrap();
    fs::write(f.project.join("assets/art.png"), b"a different art plate").unwrap();
    let err = f.gate().unwrap_err();
    assert!(err.contains("A reviewed plate changed") && err.contains("assets/art.png changed") && err.contains("Present a new round; unchanged decisions carry over"), "{err}");
    // A new round over the new plate is reviewable, and its acceptance opens the gate again.
    let dir = f.plan_round();
    let state = store::read(&dir.join("current.json")).unwrap();
    store::submit(&dir, &approve(&state)).unwrap();
    f.gate().unwrap();
}

#[test]
fn plan_accepts_absolute_and_backslashed_spec_paths_inside_the_project() {
    let f = Fixture::new();
    f.plan_project();
    f.plates();
    let mut spec: Value = serde_json::from_str(PLAN_SPEC).unwrap();
    spec["comp"] = json!(f.project.join("comp.png").to_string_lossy());
    spec["regions"][1]["plate"] = json!(f.project.canonicalize().unwrap().join("assets/art.png").to_string_lossy());
    spec["regions"][2]["plate"] = json!(r"assets\photo.png");
    fs::write(f.project.join(".impeccable/build/spec.json"), spec.to_string()).unwrap();
    let packet = super::plan::build(&f.project).unwrap();
    assert_eq!(packet["comp"]["path"], "comp.png");
    let preview = |id: &str| packet["components"].as_array().unwrap().iter().find(|c| c["id"] == id).unwrap()["preview"]["path"].clone();
    assert_eq!(preview("art"), "assets/art.png");
    assert_eq!(preview("photo"), "assets/photo.png");
}