Skip to content

AI media harness for planning, generating, and editing locally

TypeScript
28.3 KB
Raw Blame
use super::*;

fn image_fixture() -> ProjectConfig {
    serde_json::from_str(include_str!("../../../fixtures/project-v1-image.json")).unwrap()
}

#[test]
fn image_parent_editing_instructions_survive_native_save_and_reopen() {
    let mut config = image_fixture();
    let mut snapshot: serde_json::Value = serde_json::from_str(include_str!("../../../fixtures/image-generation-snapshot.json")).unwrap();
    snapshot["scene"]["rootType"] = serde_json::json!("image");
    snapshot["scene"]["sourceImage"] = serde_json::json!({"name":"Original", "relativePath":"media/original.png", "width":640, "height":480});
    snapshot["scene"]["nodes"][0]["description"] = serde_json::json!("Make the sky pink");
    config.assets.push(serde_json::from_value(serde_json::json!({
        "id":"original", "kind":"image", "name":"Original", "relativePath":"media/original.png", "mimeType":"image/png",
        "width":640, "height":480, "createdAt":config.created_at, "imageEditing":snapshot
    })).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let opened = read_project(Path::new(&created.folder_path)).unwrap();
    assert_eq!(opened.config.assets, config.assets);
    let mut invalid = opened.config;
    invalid.assets[0].image_editing.as_mut().unwrap().scene.source_image.as_mut().unwrap().relative_path = "media/another.png".into();
    assert!(validate_and_normalize_config(invalid).is_err());
}

#[test]
fn image_editing_draft_survives_save_and_reopen() {
    let mut config = image_fixture();
    let mut snapshot: serde_json::Value = serde_json::from_str(include_str!("../../../fixtures/image-generation-snapshot.json")).unwrap();
    snapshot["scene"]["rootType"] = serde_json::json!("image");
    snapshot["scene"]["sourceImage"] = serde_json::json!({"name":"Source", "relativePath":"media/imported/source.png", "width":65, "height":41});
    snapshot["scene"]["outputSize"] = serde_json::json!({"width":128,"height":64});
    snapshot["scene"]["nodes"].as_array_mut().unwrap().push(serde_json::json!({
        "id":"lasso", "parentId":"image-root", "kind":"object", "name":"Lasso", "description":"A flower", "text":"", "colors":[],
        "box":{"x":100,"y":200,"width":300,"height":400}, "lasso":[{"x":0,"y":0},{"x":1000,"y":0},{"x":0,"y":1000}],
        "lassoContours":[[{"x":100,"y":100},{"x":200,"y":100},{"x":100,"y":200}]]
    }));
    config.assets.push(serde_json::from_value(serde_json::json!({
        "id":"draft", "kind":"image", "name":"Editing Source", "relativePath":"media/imported/source.png", "mimeType":"image/png",
        "width":65, "height":41, "createdAt":config.created_at, "imageDraft":true, "imageGeneration":snapshot
    })).unwrap());
    snapshot["scene"]["rootType"] = serde_json::json!("prompt");
    snapshot["scene"]["sourceImage"] = serde_json::Value::Null;
    snapshot["scene"].as_object_mut().unwrap().remove("outputSize");
    snapshot["scene"]["nodes"].as_array_mut().unwrap().truncate(1);
    snapshot["scene"]["nodes"][0]["description"] = serde_json::json!("");
    config.assets.push(serde_json::from_value(serde_json::json!({
        "id":"empty-draft", "kind":"image", "name":"New image", "mimeType":"image/jpeg",
        "createdAt":config.created_at, "imageDraft":true, "imageGeneration":snapshot
    })).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let opened = read_project(Path::new(&created.folder_path)).unwrap();
    assert_eq!(opened.config.assets, config.assets);
    let mut invalid_size = opened.config.clone();
    invalid_size.assets[0].image_generation.as_mut().unwrap().scene.output_size.as_mut().unwrap().width = 127;
    assert!(validate_and_normalize_config(invalid_size).is_err());
    let mut invalid = opened.config;
    invalid.assets[0].image_generation = None;
    assert!(validate_and_normalize_config(invalid).is_err());
}

#[test]
fn edited_png_preserves_exact_pixels_and_exports_to_jpeg() {
    let folder = project_folder();
    let rgba: Vec<u8> = (0..65 * 41).flat_map(|index| [(index % 256) as u8, 80, 160, 255]).collect();
    let saved = crate::commands::artifacts::write_generated_png_frame(&folder.path().to_string_lossy(), "edit-test", 65, 41, &rgba).unwrap();
    let source = folder.path().join(saved.relative_path);
    assert_eq!(::image::open(&source).unwrap().to_rgba8().as_raw(), &rgba);
    let copy = folder.path().join("copy.png");
    export_image_file(&source, &copy).unwrap();
    assert_eq!(fs::read(&source).unwrap(), fs::read(copy).unwrap());
    let jpeg = folder.path().join("export.jpg");
    export_image_file(&source, &jpeg).unwrap();
    assert_eq!(::image::image_dimensions(jpeg).unwrap(), (65, 41));
}

#[test]
fn image_root_survives_save_and_agent_hierarchy_replacement() {
    use crate::project::commands::{execute_commands_at, ProjectCommand};
    let mut config = image_fixture();
    let scene = config.image_scene.as_mut().unwrap();
    scene.style.mode = "none".into();
    scene.negative_prompts = Some(std::collections::BTreeMap::from([("moss".into(), "watermark".into())]));
    scene.cfg_scales = Some(std::collections::BTreeMap::from([("moss".into(), 4.5), ("future-model".into(), 2.0)]));
    scene.generation_effects = Some(serde_json::from_str(include_str!("../../../fixtures/generation-effects.json")).unwrap());
    scene.root_type = Some("image".into());
    scene.source_image = Some(crate::project::image::ImageSource { relative_path: "media/imported/source.png".into(), name: "Source".into(), width: 65, height: 41 });
    scene.output_size = Some(crate::project::image::ImageOutputSize { width: 128, height: 64 });
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let reopened = read_project(Path::new(&created.folder_path)).unwrap();
    assert_eq!(reopened.config.image_scene, config.image_scene);
    let mut command = serde_json::to_value(config.image_scene.as_ref().unwrap()).unwrap();
    for field in ["rootType", "sourceImage", "outputAssetId", "outputSize", "generationEffects", "cfgScales", "negativePrompts"] { command.as_object_mut().unwrap().remove(field); }
    command["op"] = serde_json::json!("image.set");
    let parsed: ProjectCommand = serde_json::from_value(command).unwrap();
    let changed = execute_commands_at(&config, &[parsed], &config.updated_at).unwrap();
    assert_eq!(changed.image_scene, config.image_scene);
}

#[test]
fn generated_jpeg_preserves_resolution_and_stays_inside_the_project() {
    let folder = project_folder();
    let root = folder.path().to_string_lossy();
    let rgba = vec![128; 640 * 416 * 4];
    let saved = write_generated_image_frame(&root, "image-test", 640, 416, &rgba).unwrap();
    assert_eq!((saved.width, saved.height), (640, 416));
    assert_eq!(saved.relative_path, "media/generated/image-test.jpg");
    let bytes = fs::read(folder.path().join(saved.relative_path)).unwrap();
    assert!(bytes.starts_with(&[0xff, 0xd8]));
    // Baseline JPEG SOF: precision, then big-endian height and width.
    let sof = bytes
        .windows(2)
        .position(|pair| pair == [0xff, 0xc0])
        .unwrap();
    assert_eq!(&bytes[sof + 5..sof + 9], &[1, 160, 2, 128]);
    assert!(write_generated_image_frame(&root, "../escape", 640, 416, &rgba).is_err());
    assert!(write_generated_image_frame(&root, "bad-pixels", 640, 416, &[0; 4]).is_err());
}

#[test]
fn image_export_writes_real_png_or_copies_jpeg_without_changing_pixels_or_resolution() {
    let folder = project_folder();
    let root = folder.path().to_string_lossy();
    let rgba: Vec<u8> = (0..64 * 40).flat_map(|index| [(index % 256) as u8, 80, 160, 255]).collect();
    let saved = write_generated_image_frame(&root, "export-test", 64, 40, &rgba).unwrap();
    let source = folder.path().join(saved.relative_path);
    let jpeg = fs::read(&source).unwrap();
    for extension in ["jpg", "jpeg", "JPG"] {
        let destination = folder.path().join(format!("export.{extension}"));
        export_image_file(&source, &destination).unwrap();
        assert_eq!(fs::read(destination).unwrap(), jpeg);
    }
    let destination = folder.path().join("export.PNG");
    export_image_file(&source, &destination).unwrap();
    let png = fs::read(&destination).unwrap();
    assert!(png.starts_with(b"\x89PNG\r\n\x1a\n"));
    let decoded = ::image::load_from_memory_with_format(&png, ::image::ImageFormat::Png).unwrap();
    let original = ::image::load_from_memory_with_format(&jpeg, ::image::ImageFormat::Jpeg).unwrap();
    assert_eq!((decoded.width(), decoded.height()), (64, 40));
    assert_eq!(decoded.to_rgb8(), original.to_rgb8());
    export_image_file(&source, &folder.path().join("no-extension")).unwrap();
    assert_eq!(fs::read(folder.path().join("no-extension.jpg")).unwrap(), jpeg);
    let unsupported = folder.path().join("export.gif");
    fs::write(&unsupported, b"existing file").unwrap();
    assert!(export_image_file(&source, &unsupported).is_err());
    assert_eq!(fs::read(unsupported).unwrap(), b"existing file");
    assert_eq!(fs::read(source).unwrap(), jpeg);
}

#[test]
fn image_export_resizes_and_reencodes_at_the_chosen_quality() {
    use crate::commands::artifacts::{export_image_file_with, ImageExportFormat, ImageExportOptions};
    let folder = project_folder();
    let root = folder.path().to_string_lossy();
    let rgba: Vec<u8> = (0..128 * 80).flat_map(|index| [(index % 256) as u8, (index / 7 % 256) as u8, 160, 255]).collect();
    let saved = write_generated_image_frame(&root, "resize-test", 128, 80, &rgba).unwrap();
    let source = folder.path().join(saved.relative_path);
    let original = fs::read(&source).unwrap();
    let half = folder.path().join("half.png");
    export_image_file_with(&source, &half, ImageExportOptions { format: Some(ImageExportFormat::Png), width: Some(64), height: Some(40), quality: None, ..Default::default() }).unwrap();
    assert_eq!(::image::image_dimensions(&half).unwrap(), (64, 40));
    let enlarged = folder.path().join("enlarged.jpg");
    export_image_file_with(&source, &enlarged, ImageExportOptions { format: Some(ImageExportFormat::Jpg), width: Some(1280), height: Some(720), quality: Some(90), ..Default::default() }).unwrap();
    let decoded = ::image::open(&enlarged).unwrap().to_rgb8();
    assert_eq!(decoded.dimensions(), (1280, 720));
    // Content fills the new canvas, including its far edge, rather than padding.
    assert!(decoded.get_pixel(1279, 719)[2] > 100);
    assert_eq!(fs::read(&source).unwrap(), original);
    let low = folder.path().join("low.jpg");
    export_image_file_with(&source, &low, ImageExportOptions { format: Some(ImageExportFormat::Jpg), width: None, height: None, quality: Some(20), ..Default::default() }).unwrap();
    let low = fs::read(low).unwrap();
    assert_ne!(low, original);
    assert!(low.len() < original.len());
    let best = folder.path().join("best.jpg");
    export_image_file_with(&source, &best, ImageExportOptions { format: Some(ImageExportFormat::Jpg), width: None, height: None, quality: Some(100), ..Default::default() }).unwrap();
    assert_eq!(fs::read(best).unwrap(), original);
    let zero = folder.path().join("zero.jpg");
    assert!(export_image_file_with(&source, &zero, ImageExportOptions { format: None, width: Some(0), height: Some(40), quality: None, ..Default::default() }).is_err());
}

#[test]
fn image_settings_survive_save_without_changing_video_settings() {
    let mut config = image_fixture();
    config.image_settings = Some(serde_json::from_value(serde_json::json!({
        "resolution": "1536p", "aspectRatio": "1:1", "defaultLook": "watercolor"
    })).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let opened = read_project(Path::new(&created.folder_path)).unwrap();
    assert_eq!(opened.config.image_settings, config.image_settings);
    assert_eq!(opened.config.settings, config.settings);
    assert_eq!(opened.config.brief, config.brief);
    let mut invalid = opened.config;
    invalid.image_settings.as_mut().unwrap().resolution = "invalid".into();
    assert!(validate_and_normalize_config(invalid).is_err());
}

#[test]
fn image_export_does_not_silently_skip_a_selected_upscaler() {
    use crate::commands::artifacts::{export_image_file_with, ImageExportOptions};
    use crate::slopfab::upscale::{UpscaleConfig, UpscaleMethod};
    let folder = tempfile::tempdir().unwrap();
    let source = folder.path().join("source.png");
    ::image::RgbaImage::from_pixel(32, 32, ::image::Rgba([40, 80, 120, 100])).save(&source).unwrap();
    let original = fs::read(&source).unwrap();
    for method in [UpscaleMethod::Realesrgan, UpscaleMethod::Seedvr2] {
        let destination = folder.path().join("export.png");
        let error = export_image_file_with(&source, &destination, ImageExportOptions {
            upscale: Some(UpscaleConfig { method, model_path: folder.path().join("missing.safetensors").to_string_lossy().into(), vae_path: None }),
            ..Default::default()
        }).unwrap_err();
        assert!(error.contains("weights are missing"));
        assert!(!destination.exists());
        assert_eq!(fs::read(&source).unwrap(), original);
    }
}

#[test]
fn image_tree_survives_folder_creation_save_and_reopen() {
    let root = tempfile::tempdir().unwrap();
    let config = image_fixture();
    let created = create_project_in(root.path(), &config).unwrap();
    let folder = Path::new(&created.folder_path);
    let mut opened = read_project(folder).unwrap();
    opened.config.image_scene.as_mut().unwrap().nodes[2].text = "TO THE MOON".into();
    write_project(folder, &opened.config).unwrap();
    let reopened = read_project(folder).unwrap();
    assert_eq!(reopened.config.generation_type, GenerationType::Image);
    assert_eq!(reopened.config.image_scene, opened.config.image_scene);
    assert!(reopened.config.generation_jobs.is_empty());
    let wire = serde_json::to_value(config.clone()).unwrap();
    assert_eq!(wire["imageScene"]["nodes"][1]["parentId"], "image-root");
    let roundtrip: ProjectConfig = serde_json::from_value(wire).unwrap();
    assert_eq!(roundtrip.image_scene, config.image_scene);
}

#[test]
fn image_template_settings_survive_save_and_reopen() {
    for template in [
        serde_json::json!({"kind":"extend", "sourceId":"source", "sourceName":"Original", "generatorName":"Default generator", "prompt":"Continue the forest", "steps":28, "seed":-1, "bounds":{"x":-64,"y":-32,"width":768,"height":640}}),
        serde_json::json!({"kind":"character-sheet", "sourceId":"source", "sourceName":"Original", "generatorName":"Default generator", "prompt":"Red coat", "steps":28, "seed":0, "height":1024}),
        serde_json::json!({"kind":"character-sheet", "sourceId":"source", "sourceName":"Original", "generatorName":"Default generator", "prompt":"Red coat", "steps":28, "seed":0, "height":1024, "views":{"closeUp":false,"front":false,"side":true,"back":true}}),
        serde_json::json!({"kind":"character-sheet", "sourceId":"source", "sourceName":"Original", "generatorName":"MiniMax H3 Image", "prompt":"Red coat", "steps":6, "seed":0, "height":3424, "views":{"closeUp":true,"front":true,"side":true,"back":true}}),
    ] {
        for pending in [true, false] {
            let mut config = image_fixture();
            let mut snapshot: serde_json::Value = serde_json::from_str(include_str!("../../../fixtures/image-generation-snapshot.json")).unwrap();
            snapshot["template"] = template.clone();
            snapshot["usedSeed"] = serde_json::json!(1234);
            if template["height"] == 3424 {
                snapshot["scene"]["rootType"] = serde_json::json!("image");
                snapshot["scene"]["sourceImage"] = serde_json::json!({"relativePath":"media/result.png", "name":"Character sheet", "width":9184, "height":3424});
            }
            config.assets.push(serde_json::from_value(serde_json::json!({
                "id":"template-result", "kind":"image", "name":"Template result", "mimeType":"image/png",
                "width":512, "height":512, "createdAt":config.created_at, "imageDraft":pending,
                "relativePath":if pending { None } else { Some("media/result.png") }, "imageGeneration":snapshot
            })).unwrap());
            let root = tempfile::tempdir().unwrap();
            let created = create_project_in(root.path(), &config).unwrap();
            let reopened = read_project(Path::new(&created.folder_path)).unwrap();
            assert_eq!(reopened.config.assets, config.assets);
            let mut invalid = config;
            invalid.assets.last_mut().unwrap().image_generation.as_mut().unwrap().template.as_mut().unwrap().kind = "unknown".into();
            assert!(validate_and_normalize_config(invalid).is_err());
        }
    }
}

#[test]
fn image_and_video_content_coexist_after_save_and_reopen_for_both_legacy_types() {
    for generation_type in [GenerationType::Video, GenerationType::Image] {
        let root = tempfile::tempdir().unwrap();
        let mut config = created_fixture();
        config.generation_type = generation_type;
        config.image_scene = image_fixture().image_scene;
        let created = create_project_in(root.path(), &config).unwrap();
        let folder = Path::new(&created.folder_path);
        let mut opened = read_project(folder).unwrap();
        opened.config.image_scene.as_mut().unwrap().nodes[2].text = "Film poster".into();
        write_project(folder, &opened.config).unwrap();
        let reopened = read_project(folder).unwrap();
        assert_eq!(reopened.config.image_scene, opened.config.image_scene);
        assert_eq!(reopened.config.timeline, config.timeline);
        assert_eq!(reopened.config.generation_jobs, opened.config.generation_jobs);
        assert_eq!(reopened.config.generation_type, config.generation_type);
    }
}

#[test]
fn image_generation_history_survives_native_save_and_reopen_and_validates_snapshots() {
    let mut snapshot: serde_json::Value = serde_json::from_str(include_str!("../../../fixtures/image-generation-snapshot.json")).unwrap();
    snapshot["usedSeed"] = serde_json::json!(9_007_199_254_740_991_u64);
    snapshot["scene"]["nodes"][1]["referenceIds"] = snapshot["scene"]["referenceIds"].clone();
    snapshot["scene"]["referenceIds"] = serde_json::json!([]);
    let expected: crate::project::image::ImageGenerationSnapshot = serde_json::from_value(snapshot.clone()).unwrap();
    let mut config = image_fixture();
    config.assets.push(serde_json::from_value(serde_json::json!({
        "id": "image-history", "kind": "image", "name": "Lantern", "relativePath": "media/generated/lantern.jpg",
        "mimeType": "image/jpeg", "width": 1088, "height": 1344, "createdAt": config.created_at,
        "imageGeneration": snapshot,
    })).unwrap());
    let root = tempfile::tempdir().unwrap();
    let created = create_project_in(root.path(), &config).unwrap();
    let opened = read_project(Path::new(&created.folder_path)).unwrap();
    assert_eq!(opened.config.assets[0].image_generation.as_ref(), Some(&expected));
    let mut updated = opened.config;
    updated.image_scene.as_mut().unwrap().background = "Changed since generation".into();
    updated.references.clear();
    write_project(Path::new(&created.folder_path), &updated).unwrap();
    let reopened = read_project(Path::new(&created.folder_path)).unwrap();
    assert_eq!(reopened.config.assets[0].image_generation.as_ref(), Some(&expected));
    for invalid in ["tree", "reference", "resolution", "seed"] {
        let mut bad = reopened.config.clone();
        let history = bad.assets[0].image_generation.as_mut().unwrap();
        match invalid {
            "tree" => history.scene.nodes[1].parent_id = Some("missing".into()),
            "reference" => history.references.clear(),
            "seed" => history.used_seed = Some(9_007_199_254_740_992),
            _ => history.resolution = "invalid".into(),
        }
        assert!(validate_and_normalize_config(bad).is_err(), "{invalid}");
    }
}

#[test]
fn invalid_image_hierarchies_and_bounds_are_rejected() {
    for invalid in ["cycle", "missing", "duplicate", "disconnected", "bounds"] {
        let mut config = image_fixture();
        let scene = config.image_scene.as_mut().unwrap();
        match invalid {
            "cycle" => scene.nodes[1].parent_id = Some(scene.nodes[2].id.clone()),
            "missing" => scene.nodes[1].parent_id = Some("missing".into()),
            "duplicate" => scene.nodes[1].id = scene.nodes[0].id.clone(),
            "disconnected" => scene.nodes[1].parent_id = None,
            _ => scene.nodes[1].r#box.as_mut().unwrap().width = 1000.0,
        }
        assert!(validate_and_normalize_config(config).is_err(), "{invalid}");
    }
}

#[test]
fn agent_image_edits_preserve_outputs_and_work_in_video_projects_but_reject_invalid_trees() {
    use crate::project::commands::{execute_commands_at, ProjectCommand};
    let mut config = image_fixture();
    config.image_scene.as_mut().unwrap().output_asset_id = Some("generated-picture".into());
    let mut command = serde_json::to_value(config.image_scene.as_ref().unwrap()).unwrap();
    command.as_object_mut().unwrap().remove("outputAssetId");
    command["op"] = serde_json::json!("image.set");
    command["background"] = serde_json::json!("A moonlit ocean");
    let parsed: ProjectCommand = serde_json::from_value(command.clone()).unwrap();
    let next = execute_commands_at(&config, &[parsed.clone()], &config.updated_at).unwrap();
    assert_eq!(
        next.image_scene.as_ref().unwrap().background,
        "A moonlit ocean"
    );
    assert_eq!(
        next.image_scene
            .as_ref()
            .unwrap()
            .output_asset_id
            .as_deref(),
        Some("generated-picture")
    );
    let video = created_fixture();
    let mixed = execute_commands_at(&video, &[parsed], &config.updated_at).unwrap();
    assert_eq!(mixed.image_scene.as_ref().unwrap().background, "A moonlit ocean");
    assert_eq!(mixed.timeline, video.timeline);
    assert_eq!(mixed.generation_jobs, video.generation_jobs);
    command["nodes"][1]["parentId"] = serde_json::json!("missing");
    let parsed: ProjectCommand = serde_json::from_value(command).unwrap();
    assert!(execute_commands_at(&config, &[parsed], &config.updated_at).is_err());
}

#[test]
fn granular_image_commands_edit_subtrees_without_touching_generated_outputs() {
    use crate::project::commands::{execute_commands_at, parse_jsonl_commands};
    let cases: serde_json::Value =
        serde_json::from_str(include_str!("../../../fixtures/image-commands.json")).unwrap();
    let stream = cases["commands"]
        .as_array()
        .unwrap()
        .iter()
        .map(|command| serde_json::to_string(command).unwrap())
        .collect::<Vec<_>>()
        .join("\n")
        + "\n{\"op\":\"commit\",\"summary\":\"Composed balloons\"}";
    let commands = parse_jsonl_commands(&stream).unwrap().commands;
    let mut current = image_fixture();
    current.image_scene.as_mut().unwrap().output_asset_id = Some("saved-result".into());
    let next = execute_commands_at(&current, &commands, &current.updated_at).unwrap();
    let scene = next.image_scene.unwrap();
    assert_eq!(scene.output_asset_id.as_deref(), Some("saved-result"));
    assert_eq!(scene.nodes[0].description, "Balloons over the sea");
    assert_eq!(scene.style.lighting, "Soft morning light");
    assert_eq!(scene.style.mode, "art");
    let siblings: Vec<_> = scene
        .nodes
        .iter()
        .filter(|node| node.parent_id.as_deref() == Some("image-root"))
        .map(|node| node.id.as_str())
        .collect();
    assert_eq!(siblings, ["caption", "sky-copy", "group-rocket"]);
    let balloon = scene
        .nodes
        .iter()
        .find(|node| node.id == "sky-copy--balloon")
        .unwrap();
    assert_eq!(balloon.parent_id.as_deref(), Some("caption"));
    assert_eq!(balloon.description, "A red balloon");
    assert_eq!(
        balloon.r#box,
        Some(crate::project::image::ImageBox {
            x: 250.0,
            y: 250.0,
            width: 50.0,
            height: 50.0
        })
    );
    assert!(scene
        .nodes
        .iter()
        .all(|node| node.id != "sky" && node.id != "balloon"));
    assert_eq!(
        scene.nodes.iter().find(|node| node.id == "title"),
        Some(&current.image_scene.as_ref().unwrap().nodes[2])
    );
    let mut video = current.clone();
    video.generation_type = GenerationType::Video;
    let mixed = execute_commands_at(&video, &commands, &current.updated_at).unwrap();
    assert_eq!(mixed.image_scene.as_ref(), Some(&scene));
    assert_eq!(mixed.timeline, video.timeline);
    assert_eq!(mixed.generation_jobs, video.generation_jobs);
}

#[test]
fn image_prompts_cite_existing_references_and_keep_them_from_removal() {
    use crate::project::commands::{execute_commands_at, ProjectCommand};
    let command = |value: serde_json::Value| -> ProjectCommand { serde_json::from_value(value).unwrap() };
    let current = image_fixture();
    let add = command(serde_json::json!({"op":"ref.add","id":"ref-mara","name":"Mara","text":"A lighthouse keeper","use":["character"]}));
    let cite = command(serde_json::json!({"op":"image.configure","prompt":"@[ref:ref-mara] holds the lantern","background":"Fog"}));
    let next = execute_commands_at(&current, &[add.clone(), cite], &current.updated_at).unwrap();
    assert_eq!(next.image_scene.as_ref().unwrap().cited_reference_ids().unwrap(), ["ref-mara"]);
    let remove = command(serde_json::json!({"op":"ref.remove","id":"ref-mara"}));
    let error = execute_commands_at(&next, &[remove], &next.updated_at).unwrap_err();
    assert!(error.contains("still used by the image"), "{error}");
    for text in ["@[ref:missing] waves", "A @[ref:ref-mara"] {
        let cite = command(serde_json::json!({"op":"image.configure","background":text}));
        assert!(execute_commands_at(&current, &[add.clone(), cite], &current.updated_at).is_err(), "{text}");
    }
}

#[test]
fn invalid_image_commands_roll_back_the_entire_batch() {
    use crate::project::commands::{execute_commands_at, ProjectCommand};
    let cases: serde_json::Value =
        serde_json::from_str(include_str!("../../../fixtures/image-commands.json")).unwrap();
    let current = image_fixture();
    let original = current.clone();
    let valid: ProjectCommand = serde_json::from_value(
        serde_json::json!({"op":"image.configure","background":"Must not stick"}),
    )
    .unwrap();
    for invalid in cases["invalid"].as_array().unwrap() {
        if let Ok(command) = serde_json::from_value::<ProjectCommand>(invalid.clone()) {
            assert!(
                execute_commands_at(&current, &[valid.clone(), command], &current.updated_at)
                    .is_err(),
                "{invalid}"
            );
        }
        assert_eq!(current, original);
    }
}

#[test]
fn image_node_patches_distinguish_missing_and_null_and_initialize_older_image_projects() {
    use crate::project::commands::{execute_commands_at, ProjectCommand};
    let current = image_fixture();
    let edit = |config: &ProjectConfig, value: serde_json::Value| {
        let command: ProjectCommand = serde_json::from_value(value).unwrap();
        execute_commands_at(config, &[command], &config.updated_at).unwrap()
    };
    let renamed = edit(
        &current,
        serde_json::json!({"op":"image.node.set","id":"group-rocket","name":"Vehicle"}),
    );
    assert_eq!(
        renamed.image_scene.as_ref().unwrap().nodes[1].r#box,
        current.image_scene.as_ref().unwrap().nodes[1].r#box
    );
    let cleared = edit(
        &renamed,
        serde_json::json!({"op":"image.node.set","id":"group-rocket","box":null}),
    );
    assert!(cleared.image_scene.as_ref().unwrap().nodes[1]
        .r#box
        .is_none());
    assert_eq!(
        cleared.image_scene.as_ref().unwrap().nodes[2].r#box,
        current.image_scene.as_ref().unwrap().nodes[2].r#box
    );
    let mut older = current;
    older.image_scene = None;
    let initialized = edit(
        &older,
        serde_json::json!({"op":"image.node.add","id":"subject","parent":"image-root","kind":"object","name":"Subject"}),
    );
    assert_eq!(
        initialized.image_scene.as_ref().unwrap().nodes[0].description,
        older.brief.prompt
    );
    assert_eq!(initialized.image_scene.as_ref().unwrap().nodes.len(), 2);
}

#[test]
fn image_cfg_rejects_invalid_values() {
    for scale in [-1.0, f64::NAN, f64::INFINITY, f64::MAX] {
        let mut config = image_fixture();
        config.image_scene.as_mut().unwrap().cfg_scales = Some(std::collections::BTreeMap::from([("moss".into(), scale)]));
        assert!(validate_and_normalize_config(config).is_err());
    }
}